diff options
| author | lundinc <lundinc@1d2547de-c912-0410-9cb9-b8ca96c0e9e2> | 2020-08-12 19:11:51 +0000 |
|---|---|---|
| committer | lundinc <lundinc@1d2547de-c912-0410-9cb9-b8ca96c0e9e2> | 2020-08-12 19:11:51 +0000 |
| commit | 42255af1e27a3157d541f0812eaca447c569ca49 (patch) | |
| tree | 5c8702c2f0dc1cb9be1a4d5ff285897d96b97dd2 /FreeRTOS-Plus/Test/CMock/vendor/unity/test | |
| parent | f5221dff43de249079c2da081723cb7a456f981f (diff) | |
| download | freertos-master.tar.gz | |
Author: Ming Yue <mingyue86010@gmail.com>
Date: Tue Aug 11 17:06:59 2020 -0700
Remove unused wolfSSL files. (#197)
* Remove unused wolfSSL files.
* Add back some removed ciphers.
* Update VS project file.
commit 0e0edd96e8236b2ea4a6e6018812807be828c77f
Author: RichardBarry <3073890+RichardBarry@users.noreply.github.com>
Date: Tue Aug 11 10:50:30 2020 -0700
Use new QEMU test project to improve stream/message buffer tests (#168)
* Add Eclipse/GCC project that targets the LM3S8962 QEMU model.
* Get the Cortex-M QEMU project working.
* Continue working on making stream buffer demo more robust and QEMU project.
* Rename directory CORTEX_LM3S8986_QEMU to CORTEX_LM3S6965_QEMU.
Work on making the Stream Buffer tests more robust.
Check in before adding in the trace recorder.
* Rename CORTEX_LM3S6969_QEMU to CORTEX_LM3S6969_GCC_QEMU.
* Make the StreamBufferDemo.c common demo file (test file) more robust to other test tasks running at an equally high priority.
* Work in progress checkin only - comments in main.c are incorrect.
* Correct comments at the top of FreeRTOS/Demo/CORTEX_LM3S6965_GCC_QEMU/main.c
Make the message buffer tests more robust in the case the a message buffer becomes full when prvSenderTask() has a higher priority than the reader task.
* Disable trace recorder in the LM3S6965 QEMU demo.
* I'm dropping FreeRTOS-Kernel reference update, since this seems to break the CMBC CI.
Co-authored-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit 157a7fc39f19583ac8481e93fa3e1c91b1e1860c
Author: Gaurav-Aggarwal-AWS <33462878+aggarg@users.noreply.github.com>
Date: Sun Aug 9 22:21:44 2020 -0700
Use chacheable RAM in IAR project for MPU_M7_NUCLEO_H743ZI2 project (#193)
This change updates the IAR project for Nucleo H743ZI2 to use the
cacheable DTC RAM and enables L1 cache. In order to ensure the correct
functioning of cache, the project sets configTEX_S_C_B_SRAM in
FreeRTOSConfig.h to not mark the RAM as shareable.
Signed-off-by: Gaurav Aggarwal <aggarg@amazon.com>
commit f3e43556f90f01b82918ad533b0c616489331919
Author: Gaurav-Aggarwal-AWS <33462878+aggarg@users.noreply.github.com>
Date: Sun Aug 9 16:23:53 2020 -0700
Add MPU demo projects for NUCLEO-H743ZI2 board (#155)
* Add MPU demo projects for NUCLEO-H743ZI2 board
It contains projects for Keil uVision, STM32CubeIDE and IAR EW. This
demo shows the use of newly added support for 16 MPU regions.
Signed-off-by: Gaurav Aggarwal <aggarg@amazon.com>
* Delete not needed CMSIS files
Signed-off-by: Gaurav Aggarwal <aggarg@amazon.com>
commit 94aa31c3cbae7c929b8a412768b74631f4a6b461
Author: TakayukiMatsuo <62984531+TakayukiMatsuo@users.noreply.github.com>
Date: Sat Aug 8 07:58:14 2020 +0900
Update wolfSSL to the latest version(v.4.4.0) (#186)
* deleted old version wolfSSL before updating
* updated wolfSSL to the latest version(v4.4.0)
* updated wolfSSL to the latest version(v4.4.0)
* added macros for timing resistance
Co-authored-by: RichardBarry <3073890+RichardBarry@users.noreply.github.com>
Co-authored-by: Ming Yue <mingyue86010@gmail.com>
commit 68518f5866aac58793c737d9a46dd07a6a816aaf
Author: RichardBarry <3073890+RichardBarry@users.noreply.github.com>
Date: Fri Aug 7 14:59:24 2020 -0700
Removed a 16MByte flash image file that was checked in by mistake (several years ago). (#173)
Remove the copies of lwIP that are no longer reference from demo projects.
Co-authored-by: Carl Lundin <53273776+lundinc2@users.noreply.github.com>
commit d4bf09480a2c77b1a25cce35b32293be61ab586f
Author: m17336 <45935231+m17336@users.noreply.github.com>
Date: Thu Aug 6 22:37:08 2020 +0300
Update previous AVR ATmega0 and AVR Dx projecs + addition of equivalent projects in MPLAB.X and IAR (#180)
* Updated indentation in AVR_ATMega4809_Atmel_Studio and AVR_Dx_Atmel_Studio projects, plus small fixes in their readme files.
* Added AVR_ATMega4809_IAR, AVR_ATMega4809_MPLAB.X, AVR_Dx_IAR and AVR_Dx_MPLAB.X demo projects.
* Removed build artefacts and added .gitignore files in AVR_ATMega4809_MPLAB.X and AVR_Dx_MPLAB.X projects.
Co-authored-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit f32a0647c8228ddd066f5d69a85b2e49086e4c95
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Mon Aug 3 16:45:10 2020 -0700
Remove CBMC patch which is not used anymore (#187)
* Delete 0002-Change-FreeRTOS_IP_Private.h-union-to-struct.patch
* Delete 0002-Change-FreeRTOS_IP_Private.h-union-to-struct.patch
commit 08af68ef9049279b265c3d00e9c48fb9594129a8
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Sat Aug 1 16:38:23 2020 -0700
Remove dependency of CBMC on Patches (#181)
* Changes to DHCP
* CBMC DNS changes
* Changes for TCP_IP
* Changes to TCP_WIN
* Define away static to nothing
* Remove patches
* Changes after Mark's comments v1
* Update MakefileCommon.json
* Correction!
commit a7fec906a415363338449447daf10d7517b78848
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Jul 29 17:39:36 2020 -0700
Misc changes (#183)
commit 07cf5e07e4a05d6775a2f9e753269f43f82cf6ba
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Jul 29 16:15:38 2020 -0700
MISRA compliance changes for FreeRTOS+TCP headers (#165)
* misra changes
* Update FreeRTOS_IP_Private.h
* Update FreeRTOS_IP_Private.h
commit e903ac0fed7ce59916899e404f3e5ae5b08d1478
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Jul 29 16:03:14 2020 -0700
UPD MISRA changes (#164)
Co-authored-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit 97551bf44e7dc7dc1e4484a8fd30f699255e8569
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Jul 29 15:52:00 2020 -0700
MISRA changes in FreeRTOS_TCP_WIN.c (#162)
commit f2611cc5e5999c4c87e040a8c2d2e6b5e77a16a6
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Jul 29 15:38:37 2020 -0700
MISRA compliance changes in FreeRTOS_Sockets{.c/.h} (#161)
* MISRA changes Sockets
* add other changes
* Update FreeRTOSIPConfig.h
* Update FreeRTOSIPConfig.h
* Update FreeRTOSIPConfig.h
* Update FreeRTOSIPConfig.h
* correction
* Add 'U'
* Update FreeRTOS_Sockets.h
* Update FreeRTOS_Sockets.h
* Update FreeRTOS_Sockets.c
* Update FreeRTOS_Sockets.h
* Update after Gary's comments
* Correction reverted
commit ae4d4d38d9b2685bae159b4c87619cdb157c0bf7
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Jul 29 13:56:57 2020 -0700
MISRA compliance changes for FreeRTOS_TCP_IP.c (#160)
* MISRA tcp-ip changes
* Changes after Hein's comments on original PR
* Update FreeRTOS_TCP_IP.c
Co-authored-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit a457f43c66eb0f4be9d8f8678c0e3fb8d7ebd57b
Author: Carl Lundin <53273776+lundinc2@users.noreply.github.com>
Date: Tue Jul 28 13:01:38 2020 -0700
Add missing error state assignment. (#166)
commit 915af50524e15a78ceb6c62b3d33f6562621ee46
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Mon Jul 27 17:30:53 2020 -0700
Add Atmel Studio projects for ATMega4809 and AVR128DA48 (#159)
* Added explicit cast to allow roll over and avoid integer promotion during cycles counters comparison in recmutex.c.
* Fixed type mismatch between declaration and definition of function xAreSemaphoreTasksStillRunning( void ).
* Added Atmel Studio demo projects for ATMega4809 and AVR128DA48.
* Per https://www.freertos.org/upgrading-to-FreeRTOS-V8.html, I'm updating portBASE_TYPE to BaseType_t.
Signed-off-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
* Update register test for ATmega4809
- to cover r28, r29, r31.
- call public API taskYIELD() instead of portYIELD().
* Update ATmega4809 readme.md to include info for serial port setup, and minor wording fix.
Co-authored-by: Alexandru Niculae - M17336 <alexandru.niculae@microchip.com>
commit 4a7a48790d64127f85cc763721b575c51c452833
Author: Carl Lundin <53273776+lundinc2@users.noreply.github.com>
Date: Thu Jul 23 10:22:33 2020 -0700
Add Uncrustify file used for Kernel. (#163)
commit e0d62163b08769fd74f020709c398f994088ca96
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Jul 22 18:06:23 2020 -0700
Sync with +TCP amazon-FreeRTOS (#158)
* DNS.c commit
* IP.c commit
* Add various source & header files
commit 8e36bee30eef2107e128edb58e83ee46e8241a91
Author: Nathan Chong <52972368+nchong-at-aws@users.noreply.github.com>
Date: Tue Jul 21 12:51:20 2020 -0400
Prove buffer lemmas (#124)
* Prove buffer lemmas
* Update queue proofs to latest kernel source
All changes were syntactic due to uncrustify code-formatting
* Strengthen prvCopyDataToQueue proof
* Add extract script for diff comparison
Co-authored-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit c720c18ada40b502436ea811e8d03dca919726d8
Author: Hein Tibosch <hein_tibosch@yahoo.es>
Date: Tue Jul 14 05:35:44 2020 +0800
FreeRTOS+TCP Adding the combined driver for SAM4E and SAME70 v2 (#78)
* Adding a combined +TCP driver for SAM4E and SAME70
* Changes after review from Aniruddha
Co-authored-by: Hein Tibosch <hein@htibosch.net>
Co-authored-by: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
commit 4237049b12d9bb6b03694fecf6ea26a353e637c8
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Mon Jul 13 12:07:56 2020 -0700
Add changes from 2225-2227 amazon-FreeRTOS (#134)
commit 7caa32863458c4470d3c620945c30824199f524c
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Fri Jul 10 23:32:30 2020 -0700
Add Full TCP test suite - not using secure sockets (#131)
* Add Full-TCP suite
* delete unnecessary files
* Change after Joshua's comments
commit d7667a0034841f2968f9f9f805030cc608bfbce1
Author: Gaurav-Aggarwal-AWS <33462878+aggarg@users.noreply.github.com>
Date: Fri Jul 3 15:45:44 2020 -0700
Remove unnecessary semicolon from the linker file (#121)
This was creating problem with the onboard LPCLink debug probe.
Signed-off-by: Gaurav Aggarwal <aggarg@amazon.com>
commit 529c481c39506d0b331bfd0cdea35e5d1aeaaad0
Author: Nathan Chong <52972368+nchong-at-aws@users.noreply.github.com>
Date: Thu Jul 2 15:55:20 2020 -0400
Add VeriFast kernel queue proofs (#117)
commit d5fedeaa96b5b1d3c0f6b9b52a8064ab72ff2821
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Jul 1 13:56:27 2020 -0700
Add checks in FreeRTOS_Socket.c (#104)
* Add fail-safes to FreeRTOS_Socket.c
* Use all 'pd' errors
* Correction after Hein's comments
* Correction after Hein's comments v2
* Changes after Hein's comments
* Update after Gary's comments
commit a9b2aac4e9fda2a259380156df9cc0af51384d2d
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Fri Jun 26 12:09:36 2020 -0700
Folder structure change + Fix broken Projects (#103)
* Update folder structure
* Correct project files
* Move test folder
* Some changes after Yuki's comments
commit 98bfc38bf3404414878dc68ea41753bea4e24c8e
Author: Hein Tibosch <hein_tibosch@yahoo.es>
Date: Thu Jun 25 13:01:45 2020 +0800
FreeRTOS+TCP : add memory statistics and dump packets, v3 (#83)
* FreeRTOS+TCP : add memory statistics and dump packets, v3
* Two changes as requested by Aniruddha
Co-authored-by: Hein Tibosch <hein@htibosch.net>
Co-authored-by: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
commit 072a173c9df31c75ff64bde440f3f316cedb9033
Author: S.Burch <8697966+wholl0p@users.noreply.github.com>
Date: Mon Jun 22 23:39:26 2020 +0200
Fixed Imports for Infineon XMC1100 Board (#88)
Co-authored-by: RichardBarry <3073890+RichardBarry@users.noreply.github.com>
commit 2df5eeef5763045c4c74ff0e2a4091b7d19bea89
Author: RichardBarry <3073890+RichardBarry@users.noreply.github.com>
Date: Mon Jun 8 14:22:46 2020 -0700
Feature/multiple direct to task notifications (#73)
* Add TaskNotifyArray.c with the single task tests updated to use the task notification array up to the point where the timer is created.
* Continue working on TaskNotifyArray.c to test the new task notification indexes. Next TaskNotifyArray.c will be refactored to break the tests up a bit.
* Refactor and update the comments in TaskNotifyArray.c - no functional changes.
* Change from the task notify "array" to task notification "indexed" nomenclature in the new task notification API functions that work on one particular task notification with the array of task notifications.
* Update the implementation of the taskNOTIFY_TAKE() and taskNOTIFY_WAIT() trace macros to take the array index of the task notification they are acting on.
Rename configNUMBER_OF_TASK_NOTIFICATIONS to configTASK_NOTIFICATION_ARRAY_ENTRIES.
Add FreeRTOS/Demo/Common/Minimal/TaskNotifyArray.c to the Visual Studio project - the file implements tests specific to the behaviour of the indexed task notification functions and should be used in addition to the tests already provided in FreeRTOS/Demo/Common/Minimal/TaskNotify.c.
commit b9e4ecfaf7286d8493d4a96a93fbb325534ad97b
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Fri Jun 5 11:10:58 2020 -0700
Remove Empty and Un-referenced folder from Demo (#86)
commit f11bcc8acc57a23fb03603762e758c25b9d0efb7
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Jun 3 16:52:31 2020 -0700
Fix a Bug and corresponding CBMC patch (#84)
* Update remove-static-in-freertos-tcp-ip.patch
* Update FreeRTOS_TCP_IP.c
* Update remove-static-in-freertos-tcp-ip.patch
* Update remove-static-in-freertos-tcp-ip.patch
Co-authored-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit bb9f92f771e5f6ea2b9b09c7e89130a75e562eb7
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Wed Jun 3 10:46:55 2020 -0700
Submodule FreeRTOS/Source 10bbbcf0b..6199b72fb (#82)
commit 6efc39f44be5b269168836e95aebbdb8ae77dce3
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Tue Jun 2 15:09:25 2020 -0700
Add Project for running integration tests v2 (#80)
* Project for integration tests
* relative paths in project files
* relative paths in project files-1
* relative paths in project files-2
* addressed comments
* addressed comments v2
Co-authored-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit 0eb5909fb02bac9dc074ff1bc2fe338d77f73764
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Thu May 28 17:05:24 2020 -0700
readme.md for ATmega328PB Xplained Mini. (#76)
readme.md to get users jump started.
commit cb7edd2323a77f3dbea144c1f48f95582becc99e
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Thu May 28 10:11:58 2020 -0700
Sync with a:FR (#75)
* AFR sync
* AFR sync: CBMC
* AFR sync: CBMC: remove .bak files
* AFR sync: CBMC: more cleanup
* Corrected CBMC proofs
* Corrected CBMC patches
* Corrected CBMC patches-1
* Corrected CBMC patches-2
* remove .bak files (3)
Co-authored-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit 6557291e5407ca7ec6beca53fced1aaa620c5c02
Author: alfred gedeon <alfred2g@hotmail.com>
Date: Wed May 27 14:44:33 2020 -0700
Test: Add Linux Networking support with demo application (#71)
* Test: Add Linux Networking support with demo application
* Test: revert files affected by uncrustify
* Test: revert files affected by uncrustify
Co-authored-by: Alfred Gedeon <gedeonag@amazon.com>
Co-authored-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit 8b079bc394e7b205d72210ce9e052404d782938f
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Wed May 27 10:44:03 2020 -0700
ATmega328PB Xplained Mini -- demo project for ATmega port. (#70)
* Bootstrap a demo from START. No driver is added in this commit.
* Add FreeRTOS source code to project. Remove unnecessary folder nesting.
Heap_4 is used here.
* Copy over main.c, FreeRTOSConfig.h, and regtest.{c, h}.
This commit compiles, but will need some work on timer used.
* This port has 2KB RAM. We are using 1KB for heap.
Further decreasing minimum stack size, and also use stack overflow check 1 to save some stack space.
* Preserve EEPROM set to false.
* End of the line.
* Reduce register test stack size.
32 8-bit register + 10 bytes for stack frame cost. Round up to 50.
* Adding Queue test in Integer test.
- g3 to easy debugging.
- mainCHECK_PERIOD is set to 1000 ticks. Note that this port for now use WDT as tick timer, and period is set to 15ms.
- vErrorChecks, is of highest priority. So if this task gets run before other tasks, the very first check will fail.
* Avoid false alarm.
Since we don't know in which order the tasks are scheduled, clearing any error for the first entry of vErrorChecks.
Signed-off-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
* ParTest.c to init, set, toggle onboard user LED at PB5.
* Added a task to blink onboard user LED.
Need a magic number for stack size.
Signed-off-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
* Explicitly setting timing slicing to 0.
This is to avoid unecessary context switch when multiple tasks are of the same priority.
Signed-off-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
* Add taskYIELD() at the end of the loop in each register test task.
This is to give other tasks of the same priority a chance to run, regardless of scheduling algorithm.
Signed-off-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
* minor, update comment in main.c.
commit 95a3a02f95749fb7a600723076e291f9dee7426c
Author: Aniruddha Kanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Fri May 22 16:26:59 2020 -0700
FreeRTOS-Plus: Unit testing Infrastructure and examples (#72)
* Added CMock as submodule
* Makefile added
* Removed TEMP from Makefile
* Added configuration files and header files
* Update Makefile
* Test runner working
* make clean
* Example added with README
* Update README.md
* Restored +TCP files
* Cleared +TCP changes
* removed comments from Makefile
* Update README.md
* Update README.md
* Update README.md
* Updated Test/Unit-test/readme.md
commit 5003d17feda25490e655c0f1c15d2b13e395c9f7
Author: Hein Tibosch <hein_tibosch@yahoo.es>
Date: Wed May 6 14:16:56 2020 -0400
FreeRTOS+TCP : renewing DHCP lease while network is down (#53)
Co-authored-by: Hein Tibosch <hein@htibosch.net>
Co-authored-by: Gary Wicker <14828980+gkwicker@users.noreply.github.com>
commit d95624c5d6ba95ec0474867d7165de2c28ed41b7
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Tue May 5 09:57:18 2020 -0700
Move CBMC proofs to FreeRTOS+ directory (#64)
* move CBMC proofs to FreeRTOS+ directory
* Failing proofs corrected
* ParseDNSReply proof added back
* removed queue_init.h from -Plus/Test
Co-authored-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit 95ae7c65758a9473ea16ab08182f056f72331de2
Author: markrtuttle <tuttle@acm.org>
Date: Wed Apr 29 04:27:45 2020 +0000
Change cbmc-viewer invocation in CBMC makefile (#63)
* Exclude FreeRTOS/Demo from CBMC proof reports.
The script cbmc-viewer generates the CBMC proof reports. The script
searches source files for symbol definitions and annotates source
files with coverage information. This patch causes cbmc-viewer to
ignore the directory FreeRTOS/Demo containing 348M of data. The
script now terminates in a few seconds.
* Make report default target for CBMC Makefile.
Modify the Makefile for CBMC proofs to generate the report by default
(and not just property checking) and modify property checking to
ignore failures (due to property assertions failing) and terminating
report generation.
Co-authored-by: Mark R. Tuttle <mrtuttle@amazon.com>
commit d421ccc89f6f6473dfdd566a00567b0e1fd4cfc3
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Sat Apr 25 16:57:35 2020 -0700
Reword readme.md under ./Test. (#61)
commit 38412865985235b90dbd9da9708b68c4de5918f5
Author: Carl Lundin <53273776+lundinc2@users.noreply.github.com>
Date: Sat Apr 25 16:56:54 2020 -0700
Removed a:FR reference. (#60)
commit 4db195c916c7b13c82ab3a34a499fe606f266810
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Tue Apr 21 15:40:08 2020 -0700
Adding FreeRTOS+TCP CBMC proofs to FreeRTOS/FreeRTOS (#56)
ParseDNSReply is to be added in the next PR.
commit 40a31b6d35a866a3a6c551d95bf08dae855da5bd
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Mon Apr 13 13:58:33 2020 -0700
'uL' -> 'UL'
commit 5b3a289b69fc92089aa8bd4d1b44ab816f326f73
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Mon Apr 13 13:50:53 2020 -0700
Changes after Gary's comments
commit edf68637dd22470a8d4f59fecc15b51379bcfeda
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Fri Apr 10 16:26:03 2020 -0700
Update FreeRTOS_ARP.c
commit 35f3ac32a8899dd714a8a48952a4224fbcebc4aa
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Fri Apr 10 15:56:18 2020 -0700
correct debug output
commit 5e12a70db4b6a8e68a434489683306f040252efa
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Fri Apr 10 15:44:45 2020 -0700
Debugging flag check added
commit 4e8ac8de25ac4088b9c789b88a77cd39df4d9167
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Thu Apr 9 16:57:19 2020 -0700
Comment style consistency and Yuhui's suggestions
commit e43f7cd086096ad60491fedba69927a1e1a82f20
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Thu Apr 9 16:47:41 2020 -0700
Cleanup
commit ab3b51c7a0d880a6bf453ec63ae604e15050f310
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Thu Apr 9 16:33:03 2020 -0700
Update after Gary's comments
commit 97f7009699ffb972c0745dfdb526d1fa4e0faf84
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Apr 8 14:30:15 2020 -0700
Update after richard's comments
commit a9fcafc074cec559dd67961ef44273df6180c2db
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Apr 8 14:07:39 2020 -0700
Corrected the formatting
- visual studio had messed up the formatting
commit c381861014a8043ce30723fc5a8cf5107719c8df
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Apr 8 13:01:12 2020 -0700
commit 2 after gary's comments
commit 75677a8d85fa802cca9058d6e23796d5043a0982
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Apr 8 12:51:10 2020 -0700
Commit after Gary's comments
commit 666c0da366030109db2c0c5e7253cebb2f899db7
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Apr 8 10:56:01 2020 -0700
Update after Yuhui's comments
- removed (void) from before memcpy, memset etc.
- corrected memcpy style as suggested by Yuhui
- Added logging for xNetworkInterfaceOutput. No need to configASSERT
commit 4a1148d15b6b8169d2412f8179f734683b179795
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Apr 1 16:05:36 2020 -0700
Coverity + MISRA compliance
Modified code to conform to the MISRA directives more closely.
commit fa74f7dccf6b1a356993c6a894f8e1173b8c8157
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Thu Apr 2 20:26:10 2020 -0700
Removing writes to read-only PLIC interrupt pending registers.
Signed-off-by: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
commit 5b9777e11e16609648fb98d2f9a47553ab238950
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Tue Mar 31 10:45:23 2020 -0700
A readme file to introduce what ./Test directory is about.
commit 211bb4cbd9ae6dfa95e8d8501f37d272bde5ab26
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Tue Mar 24 15:14:24 2020 -0700
Ignore whitespace when working with patches.
commit 8156f64d1c45dd59ef12279f19a99f03e79e1f8a
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Tue Feb 25 18:04:23 2020 -0800
Copying CBMC proofs from aws/amazon-freertos repo ./tools/cbmc to this repo ./FreeRTOS/Test/CBMC as is.
The commit ID in aws/amazon-freertos is 0c8e0217f2a43bdeb364b58ae01c6c259e03ef1b.
commit 9f316c246baafa15c542a5aea81a94f26e3d6507
Author: David Vrabel <david.vrabel@cambridgeconsultants.com>
Date: Mon Mar 16 11:21:46 2020 +0000
Demo/Posix_GCC: add demo application for Posix port using GCC
This is largely a copy of the Windows demo application with a few key
changes:
- heap_3 (use malloc()/free()) so tools like valgrind "just work".
- printf() wrapped in a mutex to prevent deadlocks on the internal
pthread mutexes inside printf().
SCons (https://scons.org/) is used as the build system.
This will be built as a 64-bit application, but note that the memory
allocation trace points only record the lower 32-bits of the address.
commit f78f919b3e2f0d707531a301a8ca07cd02bc4778
Author: Markus Rinne <markus.ka.rinne@gmail.com>
Date: Thu Mar 19 21:00:24 2020 +0200
Fix function comments
commit 1cd2d38d960a3576addb224582c88489bade5141
Author: David Chalco <david@chalco.io>
Date: Fri Mar 20 10:29:05 2020 -0700
unix separators for path and remove .exe suffix from risc compiler (works on windows/mac)
commit 938b19419eded12817737ab0644e94ed2ba7e95d
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Thu Mar 19 18:23:09 2020 -0700
Removing ./FreeRTOS-Labs directory, since:
- IoT libraries are now in LTS branch.
- FAT/POSIX/Light-weight MQTT are in https://github.com/FreeRTOS/FreeRTOS-Labs.
commit 1a4abbc9e91b13fd6394464ade59d5e048320c7c
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Tue Mar 17 19:30:02 2020 -0700
Maintenance -- clean up readme.txt and add url to GitHub. (#38)
* Removing readme.txt, as now we have README.md in place.
The only information missing from README.md is about FAQ.
* Adding FAQ information in README.md.
* Adding a .url to root to redict user to FreeRTOS github home page.
commit 47bb466aa19395b7785bcb830e2e4dd35f6bafc5
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Tue Mar 17 13:07:44 2020 -0700
Update issue templates
Template maintenance.
- adding title prefix.
- adding examples to "additional context" section.
commit f506290041f56867765f8efa70ed2862125bdb7c
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Tue Mar 17 10:15:07 2020 -0700
Create SECURITY.md
Apply the recommended SECURITY.md from AWS to our repo.
commit 8982a2f80a80a2a0a47cf82de07b52101bd9d606
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Fri Mar 13 12:50:10 2020 -0700
Add ./lib directory to make sure Zynq project compiles.
commit ecf0f12aa14ad6fdafe1ef37257cbb4e03e2abd5
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Wed Mar 11 10:19:48 2020 -0700
Sync up with Amazon-freertos repo (10th March 2020) (#34)
* Sync up with amazon-freertos
* Sync up with amazon-freertos
* Sync up with amazon-freertos
commit 0acffef047973e2e61c2201fd69cd9bbd317f674
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Tue Mar 10 10:20:48 2020 -0700
GitHub PR template. (#29)
commit c40a6da2e4cb8042b56d1b174051cbbe9813781a
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Mon Mar 9 11:18:48 2020 -0700
pass payload length when calling UDP callback (#30)
* pass payload length when calling UDP callback
commit 12d580e93d4d9074b9a867632f0681a511b4ad12
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Fri Mar 6 18:16:51 2020 -0800
Update issue templates
Initial issue template. Created following https://help.github.com/en/github/building-a-strong-community/configuring-issue-templates-for-your-repository#configuring-the-template-chooser.
If change is needed, we could go another round.
commit 9debffb5e0e42ff716f58b2270b3af09652294af
Author: Yuhui Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Fri Mar 6 17:27:46 2020 -0800
Update README.md to remove dead link.
See the conversation https://github.com/FreeRTOS/FreeRTOS/commit/42c627b2b88cb3b487fea983d8b566a8bbae54fa#comments .
Linkage for both ```./FreeRTOS/Source``` and ```./FreeRTOS/Demo``` are removed, since it looks weird to only provide linkage to Demo.
commit 7e1a4bf563240501fc45167aee9d929c533939dd
Author: AniruddhaKanhere <60444055+AniruddhaKanhere@users.noreply.github.com>
Date: Fri Mar 6 15:18:09 2020 -0800
Fix DHCP option Client-identifier (#28)
commit 42c627b2b88cb3b487fea983d8b566a8bbae54fa
Author: Yuhui.Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Fri Mar 6 09:15:11 2020 -0800
Update readme and revert relative URL. (#27)
* Reordering: bumping cloning instruction up.
* Rewording readme.md to be clear kernel code is a submodule of this repository.
* Reverting relative URL, since user cannot click through on GitHub page.
(With URL, user could still download the correct version of the code. Reverting simply due to UI issue.)
commit 5751ae9b60e248ebd0b4dd7c58df54364d2bb9d5
Author: Gaurav-Aggarwal-AWS <33462878+aggarg@users.noreply.github.com>
Date: Fri Mar 6 09:11:42 2020 -0800
Update CORTEX_MPU_M33F_NXP_LPC55S69_MCUXpresso project (#26)
This commit updates the project for LPC55S69 so that it works with the
latest version of MCUXpresso and SDK.
Signed-off-by: Gaurav Aggarwal <aggarg@amazon.com>
commit a9ffffe1f01f45f79e127c15727784984077932f
Author: Carl Lundin <53273776+lundinc2@users.noreply.github.com>
Date: Thu Mar 5 17:16:13 2020 -0800
Using Relative URL For Submoduling. (#24)
commit 52c82076b38fe73d1dc46c97abf74ae9b803696c
Author: Carl Lundin <53273776+lundinc2@users.noreply.github.com>
Date: Thu Mar 5 09:16:31 2020 -0800
use relative path to point to bundled toolchain instead (#25)
commit b877e4ec478de2c24d07ab46241070d7c66f375c
Author: lundinc2 <53273776+lundinc2@users.noreply.github.com>
Date: Tue Feb 25 13:18:38 2020 -0800
Moved vulnerability reporting and code of conduct to top of CONTRIBUTING.md (#20)
commit bef165d46799fb8faa58aaa224f80c16b6538e69
Author: Yuhui.Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Tue Feb 18 22:06:38 2020 -0800
Linking test source file from relative path. (#19)
commit 89e7bbe292afd3912d1f0b2402cc506878bad869
Author: Yuhui.Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Tue Feb 18 17:47:55 2020 -0800
A preliminary .gitignore file, to prevent us checking in files unnecessary. (#18)
https://github.com/github/gitignore.
commit c2a98127acb48c4562233230e66ca5c282688579
Author: RichardBarry <3073890+RichardBarry@users.noreply.github.com>
Date: Sun Feb 16 13:19:53 2020 -0800
Minor wording changes in the 'previous releases' section of the readme.me file. (#17)
commit 24c772d1439e5c291c0a29fce0a46996ca8afaa9
Author: Yuhui.Zheng <10982575+yuhui-zheng@users.noreply.github.com>
Date: Fri Feb 14 12:47:01 2020 -0800
Submodule kernel directory. (#16)
* Removing FreeRTOS/Source in readiness for submoduling.
* Submoduling kernel.
* README.md update due to submoduling.
When releasing, please follow these steps:
1. in local directory, clean directory and check "git status" shows "nothing to commit, working tree clean" for ALL subdirectories.
2. copy source code and instructions only to an empty folder. Git related should not be in this folder -- this covers .git, .gitignore, .github, .gitmodules, gitmessages, ......
3. zip the folder from step 2. (create both .zip and .7z)
4. attach .zip and .7z to the release. (e.g. attach these two in new release -- https://github.com/FreeRTOS/FreeRTOS/releases/new)
5. PLEASE download both, unzip, diff with your local git repo. (should not see any difference other than git related.) And, sanity check a couple of projects.
commit c3f8b91652392dc55e0d7067b90a40de5f5f0837
Author: Rashed Talukder <9218468+rashedtalukder@users.noreply.github.com>
Date: Thu Feb 13 17:47:14 2020 -0800
Update readme. Fixed typos and cli commands (#14)
commit 4723b825f2989213c1cdb2ebf4d6793e0292e363
Author: Julian Poidevin <julian-poidevin@users.noreply.github.com>
Date: Fri Feb 14 02:43:36 2020 +0100
Fixed wrong git clone SSH command (#13)
Replaced bad https URL with proper SSH URL
commit fc819b821715c42602819e58499846147a6394f5
Author: RichardBarry <3073890+RichardBarry@users.noreply.github.com>
Date: Thu Feb 13 17:42:22 2020 -0800
Correct the xTimerCreate() documentation which said NULL was returned if the timer period was passed into the function as 0, whereas that is not the case. (#15)
Add a note to the documentation for both the xTimerCreate() and xTimerCreateStatic() functions that the timer period must be greater than 0.
commit 1c711ab530b5f0dbd811d7d62e0a3763706ffff4
Author: Rashed Talukder <9218468+rashedtalukder@users.noreply.github.com>
Date: Wed Feb 12 23:00:18 2020 -0800
Updated contributions guidelines (#12)
commit 84fcc0d5317d96c6b086034093c8c1c83e050819
Author: Cobus van Eeden <35851496+cobusve@users.noreply.github.com>
Date: Wed Feb 12 15:05:06 2020 -0800
Updates to Markdown files and readme.txt (#11)
git-svn-id: http://svn.code.sf.net/p/freertos/code/trunk@2826 1d2547de-c912-0410-9cb9-b8ca96c0e9e2
Diffstat (limited to 'FreeRTOS-Plus/Test/CMock/vendor/unity/test')
59 files changed, 14425 insertions, 0 deletions
diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/.rubocop.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/.rubocop.yml new file mode 100644 index 000000000..6c9542f52 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/.rubocop.yml @@ -0,0 +1,76 @@ +# This is the configuration used to check the rubocop source code. + +#inherit_from: .rubocop_todo.yml + +AllCops: + TargetRubyVersion: 2.3 + +# These are areas where ThrowTheSwitch's coding style diverges from the Ruby standard +Style/SpecialGlobalVars: + EnforcedStyle: use_perl_names +Style/FormatString: + Enabled: false +Style/GlobalVars: + Enabled: false +Style/FrozenStringLiteralComment: + Enabled: false +Style/RegexpLiteral: + AllowInnerSlashes: true +Style/HashSyntax: + EnforcedStyle: no_mixed_keys +Style/NumericPredicate: + Enabled: false +Style/MultilineBlockChain: + Enabled: false +Style/Alias: + Enabled: false +Style/EvalWithLocation: + Enabled: false +Style/MixinUsage: + Enabled: false + +# These are also places we diverge... but we will likely comply down the road +Style/IfUnlessModifier: + Enabled: false +Style/FormatStringToken: + Enabled: false + +# This is disabled because it seems to get confused over nested hashes +Layout/AlignHash: + Enabled: false + EnforcedHashRocketStyle: table + EnforcedColonStyle: table + +# We purposefully use these insecure features because they're what makes Ruby awesome +Security/Eval: + Enabled: false +Security/YAMLLoad: + Enabled: false + +# At this point, we're not ready to enforce inline documentation requirements +Style/Documentation: + Enabled: false +Style/DocumentationMethod: + Enabled: false + +# At this point, we're not ready to enforce any metrics +Metrics/AbcSize: + Enabled: false +Metrics/BlockLength: + Enabled: false +Metrics/BlockNesting: + Enabled: false +Metrics/ClassLength: + Enabled: false +Metrics/CyclomaticComplexity: + Enabled: false +Metrics/LineLength: + Enabled: false +Metrics/MethodLength: + Enabled: false +Metrics/ModuleLength: + Enabled: false +Metrics/ParameterLists: + Enabled: false +Metrics/PerceivedComplexity: + Enabled: false diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/Makefile b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/Makefile new file mode 100644 index 000000000..d8d10d22e --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/Makefile @@ -0,0 +1,159 @@ +CC = gcc +ifeq ($(shell uname -s), Darwin) +CC = clang +endif +ifeq ($(findstring clang, $(CC)), clang) +E = -Weverything +CFLAGS += $E -Wno-unknown-warning-option -Wno-missing-prototypes +CFLAGS += -Wno-unused-macros -Wno-padded -Wno-missing-noreturn +endif +CFLAGS += -std=c99 -pedantic -Wall -Wextra -Werror +#CFLAGS += -Wconversion #disabled because if falsely complains about the isinf and isnan macros +CFLAGS += -Wno-switch-enum -Wno-double-promotion +CFLAGS += -Wbad-function-cast -Wcast-qual -Wold-style-definition -Wshadow -Wstrict-overflow \ + -Wstrict-prototypes -Wswitch-default -Wundef +#DEBUG = -O0 -g +CFLAGS += $(DEBUG) +UNITY_SUPPORT_64 = -D UNITY_SUPPORT_64 +UNITY_INCLUDE_DOUBLE = -D UNITY_INCLUDE_DOUBLE +DEFINES = -D UNITY_OUTPUT_CHAR=putcharSpy +DEFINES += -D UNITY_OUTPUT_CHAR_HEADER_DECLARATION=putcharSpy\(int\) +DEFINES += -D UNITY_OUTPUT_FLUSH=flushSpy +DEFINES += -D UNITY_OUTPUT_FLUSH_HEADER_DECLARATION=flushSpy\(void\) +DEFINES += $(UNITY_SUPPORT_64) $(UNITY_INCLUDE_DOUBLE) +SRC1 = ../src/unity.c tests/test_unity_arrays.c build/test_unity_arraysRunner.c +SRC2 = ../src/unity.c tests/test_unity_core.c build/test_unity_coreRunner.c +SRC3 = ../src/unity.c tests/test_unity_doubles.c build/test_unity_doublesRunner.c +SRC4 = ../src/unity.c tests/test_unity_floats.c build/test_unity_floatsRunner.c +SRC5 = ../src/unity.c tests/test_unity_integers.c build/test_unity_integersRunner.c +SRC6 = ../src/unity.c tests/test_unity_integers_64.c build/test_unity_integers_64Runner.c +SRC7 = ../src/unity.c tests/test_unity_memory.c build/test_unity_memoryRunner.c +SRC8 = ../src/unity.c tests/test_unity_strings.c build/test_unity_stringsRunner.c +INC_DIR = -I ../src +COV_FLAGS = -fprofile-arcs -ftest-coverage -I ../../src +BUILD_DIR = build +TARGET = build/testunity-cov.exe + +# To generate coverage, call 'make -s', the default target runs. +# For verbose output of all the tests, run 'make test'. +default: coverage +.PHONY: default coverage test clean +coverage: $(SRC1) $(SRC2) $(SRC3) $(SRC4) $(SRC5) $(SRC6) $(SRC7) $(SRC8) + cd $(BUILD_DIR) && \ + $(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC1), ../$i) $(COV_FLAGS) -o ../$(TARGET) + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) | grep 'Tests\|]]]' -A1 + cd $(BUILD_DIR) && \ + gcov unity.c | head -3 + grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true + cd $(BUILD_DIR) && \ + $(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC2), ../$i) $(COV_FLAGS) -o ../$(TARGET) + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) | grep 'Tests\|]]]' -A1 + cd $(BUILD_DIR) && \ + gcov unity.c | head -3 + grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true + cd $(BUILD_DIR) && \ + $(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC3), ../$i) $(COV_FLAGS) -o ../$(TARGET) + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) | grep 'Tests\|]]]' -A1 + cd $(BUILD_DIR) && \ + gcov unity.c | head -3 + grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true + cd $(BUILD_DIR) && \ + $(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC4), ../$i) $(COV_FLAGS) -o ../$(TARGET) + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) | grep 'Tests\|]]]' -A1 + cd $(BUILD_DIR) && \ + gcov unity.c | head -3 + grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true + cd $(BUILD_DIR) && \ + $(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC5), ../$i) $(COV_FLAGS) -o ../$(TARGET) + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) | grep 'Tests\|]]]' -A1 + cd $(BUILD_DIR) && \ + gcov unity.c | head -3 + grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true + cd $(BUILD_DIR) && \ + $(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC6), ../$i) $(COV_FLAGS) -o ../$(TARGET) + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) | grep 'Tests\|]]]' -A1 + cd $(BUILD_DIR) && \ + gcov unity.c | head -3 + grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true + cd $(BUILD_DIR) && \ + $(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC7), ../$i) $(COV_FLAGS) -o ../$(TARGET) + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) | grep 'Tests\|]]]' -A1 + cd $(BUILD_DIR) && \ + gcov unity.c | head -3 + grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true + cd $(BUILD_DIR) && \ + $(CC) $(CFLAGS) $(DEFINES) $(foreach i,$(SRC8), ../$i) $(COV_FLAGS) -o ../$(TARGET) + rm -f $(BUILD_DIR)/*.gcda + ./$(TARGET) | grep 'Tests\|]]]' -A1 + cd $(BUILD_DIR) && \ + gcov unity.c | head -3 + grep '###' $(BUILD_DIR)/unity.c.gcov -C2 || true + +test: $(SRC1) $(SRC2) $(SRC3) $(SRC4) $(SRC5) $(SRC6) $(SRC7) $(SRC8) + $(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC1) -o $(TARGET) + ./$(TARGET) + $(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC2) -o $(TARGET) + ./$(TARGET) + $(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC3) -o $(TARGET) + ./$(TARGET) + $(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC4) -o $(TARGET) + ./$(TARGET) + $(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC5) -o $(TARGET) + ./$(TARGET) + $(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC6) -o $(TARGET) + ./$(TARGET) + $(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC7) -o $(TARGET) + ./$(TARGET) + $(CC) $(CFLAGS) $(DEFINES) $(INC_DIR) $(SRC8) -o $(TARGET) + ./$(TARGET) + +# Compile only, for testing that preprocessor detection works +UNITY_C_ONLY =-c ../src/unity.c -o $(BUILD_DIR)/unity.o +intDetection: + $(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_STDINT_H + $(CC) $(CFLAGS) $(INC_DIR) $(UNITY_C_ONLY) -D UNITY_EXCLUDE_LIMITS_H + +$(BUILD_DIR)/test_unity_arraysRunner.c: tests/test_unity_arrays.c | $(BUILD_DIR) + awk $(AWK_SCRIPT) tests/test_unity_arrays.c > $@ + +$(BUILD_DIR)/test_unity_coreRunner.c: tests/test_unity_core.c | $(BUILD_DIR) + awk $(AWK_SCRIPT) tests/test_unity_core.c > $@ + +$(BUILD_DIR)/test_unity_doublesRunner.c: tests/test_unity_doubles.c | $(BUILD_DIR) + awk $(AWK_SCRIPT) tests/test_unity_doubles.c > $@ + +$(BUILD_DIR)/test_unity_floatsRunner.c: tests/test_unity_floats.c | $(BUILD_DIR) + awk $(AWK_SCRIPT) tests/test_unity_floats.c > $@ + +$(BUILD_DIR)/test_unity_integersRunner.c: tests/test_unity_integers.c | $(BUILD_DIR) + awk $(AWK_SCRIPT) tests/test_unity_integers.c > $@ + +$(BUILD_DIR)/test_unity_integers_64Runner.c: tests/test_unity_integers_64.c | $(BUILD_DIR) + awk $(AWK_SCRIPT) tests/test_unity_integers_64.c > $@ + +$(BUILD_DIR)/test_unity_memoryRunner.c: tests/test_unity_memory.c | $(BUILD_DIR) + awk $(AWK_SCRIPT) tests/test_unity_memory.c > $@ + +$(BUILD_DIR)/test_unity_stringsRunner.c: tests/test_unity_strings.c | $(BUILD_DIR) + awk $(AWK_SCRIPT) tests/test_unity_strings.c > $@ + +AWK_SCRIPT=\ + '/^void test/{ declarations[d++]=$$0; gsub(/\(?void\)? ?/,""); tests[t++]=$$0; line[u++]=NR } \ + END{ print "\#include \"unity.h\" /* Autogenerated by awk in Makefile */" ; \ + for (i=0; i<d; i++) { print declarations[i] ";" } \ + print "int main(void)\n{\n UnityBegin(\"" FILENAME "\");" ; \ + for (i=0; i<t; i++) { print " RUN_TEST(" tests[i] ", " line[i] ");" } \ + print " return UNITY_END();\n}" }' + +$(BUILD_DIR): + mkdir -p $(BUILD_DIR) + +clean: + rm -f $(TARGET) $(BUILD_DIR)/*.gc* $(BUILD_DIR)/test_unity_*Runner.c diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_cmd.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_cmd.c new file mode 100644 index 000000000..7bcf8e102 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_cmd.c @@ -0,0 +1,61 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include <setjmp.h> +#include <stdio.h> +#include "CException.h" +#include "funky.h" +#include "stanky.h" +#include <setjmp.h> + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_def.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_def.c new file mode 100644 index 000000000..b8ad559f6 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_def.c @@ -0,0 +1,57 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include <setjmp.h> +#include <stdio.h> +#include "funky.h" +#include "stanky.h" +#include <setjmp.h> + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_head1.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_head1.c new file mode 100644 index 000000000..1d01551e8 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_head1.c @@ -0,0 +1,55 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include <setjmp.h> +#include <stdio.h> +#include "testsample_head1.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_head1.h b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_head1.h new file mode 100644 index 000000000..da6b7ab26 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_head1.h @@ -0,0 +1,15 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#ifndef _TESTSAMPLE_HEAD1_H +#define _TESTSAMPLE_HEAD1_H + +#include "unity.h" +#include "funky.h" +#include "stanky.h" +#include <setjmp.h> + +void test_TheFirstThingToTest(void); +void test_TheSecondThingToTest(void); +void test_TheThirdThingToTest(void); +void test_TheFourthThingToTest(void); +#endif + diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_cmd.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_cmd.c new file mode 100644 index 000000000..45a09af22 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_cmd.c @@ -0,0 +1,80 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include <setjmp.h> +#include <stdio.h> +#include "CException.h" +#include "funky.h" +#include <setjmp.h> +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_def.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_def.c new file mode 100644 index 000000000..a7a26078b --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_def.c @@ -0,0 +1,76 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include <setjmp.h> +#include <stdio.h> +#include "funky.h" +#include <setjmp.h> +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_head1.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_head1.c new file mode 100644 index 000000000..45829fe7e --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_head1.c @@ -0,0 +1,75 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include <setjmp.h> +#include <stdio.h> +#include "testsample_mock_head1.h" +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_head1.h b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_head1.h new file mode 100644 index 000000000..30c509ad0 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_head1.h @@ -0,0 +1,13 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ +#ifndef _TESTSAMPLE_MOCK_HEAD1_H +#define _TESTSAMPLE_MOCK_HEAD1_H + +#include "unity.h" +#include "cmock.h" +#include "funky.h" +#include <setjmp.h> + +void test_TheFirstThingToTest(void); +void test_TheSecondThingToTest(void); +#endif + diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_new1.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_new1.c new file mode 100644 index 000000000..0061822e5 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_new1.c @@ -0,0 +1,89 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include <setjmp.h> +#include <stdio.h> +#include "CException.h" +#include "one.h" +#include "two.h" +#include "funky.h" +#include <setjmp.h> +#include "Mockstanky.h" + +int GlobalExpectCount; +int GlobalVerifyOrder; +char* GlobalOrderError; + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + GlobalExpectCount = 0; + GlobalVerifyOrder = 0; + GlobalOrderError = NULL; + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_new2.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_new2.c new file mode 100644 index 000000000..ee63cdc0b --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_new2.c @@ -0,0 +1,89 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include <setjmp.h> +#include <stdio.h> +#include "funky.h" +#include <setjmp.h> +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_custom_setup(); +} + +/*=======Suite Teardown=====*/ +static int suite_teardown(int num_failures) +{ +a_custom_teardown(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return suite_teardown(UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_param.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_param.c new file mode 100644 index 000000000..a42b7deae --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_param.c @@ -0,0 +1,77 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST_NO_ARGS +#define RUN_TEST(TestFunc, TestLineNum, ...) \ +{ \ + Unity.CurrentTestName = #TestFunc "(" #__VA_ARGS__ ")"; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(__VA_ARGS__); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include <setjmp.h> +#include <stdio.h> +#include "funky.h" +#include <setjmp.h> +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21, RUN_TEST_NO_ARGS); + RUN_TEST(test_TheSecondThingToTest, 43, RUN_TEST_NO_ARGS); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_run1.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_run1.c new file mode 100644 index 000000000..0061822e5 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_run1.c @@ -0,0 +1,89 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include <setjmp.h> +#include <stdio.h> +#include "CException.h" +#include "one.h" +#include "two.h" +#include "funky.h" +#include <setjmp.h> +#include "Mockstanky.h" + +int GlobalExpectCount; +int GlobalVerifyOrder; +char* GlobalOrderError; + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + GlobalExpectCount = 0; + GlobalVerifyOrder = 0; + GlobalOrderError = NULL; + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_run2.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_run2.c new file mode 100644 index 000000000..ee63cdc0b --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_run2.c @@ -0,0 +1,89 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include <setjmp.h> +#include <stdio.h> +#include "funky.h" +#include <setjmp.h> +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_custom_setup(); +} + +/*=======Suite Teardown=====*/ +static int suite_teardown(int num_failures) +{ +a_custom_teardown(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return suite_teardown(UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_yaml.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_yaml.c new file mode 100644 index 000000000..a24bb5a57 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_mock_yaml.c @@ -0,0 +1,90 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + CMock_Init(); \ + UNITY_CLR_DETAILS(); \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + CMock_Verify(); \ + } \ + CMock_Destroy(); \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include "cmock.h" +#include <setjmp.h> +#include <stdio.h> +#include "CException.h" +#include "two.h" +#include "three.h" +#include <four.h> +#include "funky.h" +#include <setjmp.h> +#include "Mockstanky.h" + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); + + +/*=======Mock Management=====*/ +static void CMock_Init(void) +{ + Mockstanky_Init(); +} +static void CMock_Verify(void) +{ + Mockstanky_Verify(); +} +static void CMock_Destroy(void) +{ + Mockstanky_Destroy(); +} + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_yaml_setup(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + CMock_Verify(); + CMock_Destroy(); + tearDown(); + CMock_Init(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/mocksample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + + CMock_Guts_MemFreeFinal(); + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_new1.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_new1.c new file mode 100644 index 000000000..7dcd3fdfe --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_new1.c @@ -0,0 +1,67 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include <setjmp.h> +#include <stdio.h> +#include "CException.h" +#include "one.h" +#include "two.h" +#include "funky.h" +#include "stanky.h" +#include <setjmp.h> + +int GlobalExpectCount; +int GlobalVerifyOrder; +char* GlobalOrderError; + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_new2.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_new2.c new file mode 100644 index 000000000..c98c697f5 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_new2.c @@ -0,0 +1,70 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include <setjmp.h> +#include <stdio.h> +#include "funky.h" +#include "stanky.h" +#include <setjmp.h> + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_custom_setup(); +} + +/*=======Suite Teardown=====*/ +static int suite_teardown(int num_failures) +{ +a_custom_teardown(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return suite_teardown(UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_param.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_param.c new file mode 100644 index 000000000..adf6c2626 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_param.c @@ -0,0 +1,58 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST_NO_ARGS +#define RUN_TEST(TestFunc, TestLineNum, ...) \ +{ \ + Unity.CurrentTestName = #TestFunc "(" #__VA_ARGS__ ")"; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(__VA_ARGS__); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include <setjmp.h> +#include <stdio.h> +#include "funky.h" +#include "stanky.h" +#include <setjmp.h> + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21, RUN_TEST_NO_ARGS); + RUN_TEST(test_TheSecondThingToTest, 43, RUN_TEST_NO_ARGS); + RUN_TEST(test_TheThirdThingToTest, 53, RUN_TEST_NO_ARGS); + RUN_TEST(test_TheFourthThingToTest, 58, RUN_TEST_NO_ARGS); + + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_run1.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_run1.c new file mode 100644 index 000000000..7dcd3fdfe --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_run1.c @@ -0,0 +1,67 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include <setjmp.h> +#include <stdio.h> +#include "CException.h" +#include "one.h" +#include "two.h" +#include "funky.h" +#include "stanky.h" +#include <setjmp.h> + +int GlobalExpectCount; +int GlobalVerifyOrder; +char* GlobalOrderError; + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_run2.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_run2.c new file mode 100644 index 000000000..c98c697f5 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_run2.c @@ -0,0 +1,70 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + setUp(); \ + TestFunc(); \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include <setjmp.h> +#include <stdio.h> +#include "funky.h" +#include "stanky.h" +#include <setjmp.h> + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_custom_setup(); +} + +/*=======Suite Teardown=====*/ +static int suite_teardown(int num_failures) +{ +a_custom_teardown(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return suite_teardown(UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_yaml.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_yaml.c new file mode 100644 index 000000000..3316024df --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/expectdata/testsample_yaml.c @@ -0,0 +1,71 @@ +/* AUTOGENERATED FILE. DO NOT EDIT. */ + +/*=======Test Runner Used To Run Each Test Below=====*/ +#define RUN_TEST(TestFunc, TestLineNum) \ +{ \ + Unity.CurrentTestName = #TestFunc; \ + Unity.CurrentTestLineNumber = TestLineNum; \ + Unity.NumberOfTests++; \ + if (TEST_PROTECT()) \ + { \ + CEXCEPTION_T e; \ + Try { \ + setUp(); \ + TestFunc(); \ + } Catch(e) { TEST_ASSERT_EQUAL_HEX32_MESSAGE(CEXCEPTION_NONE, e, "Unhandled Exception!"); } \ + } \ + if (TEST_PROTECT() && !TEST_IS_IGNORED) \ + { \ + tearDown(); \ + } \ + UnityConcludeTest(); \ +} + +/*=======Automagically Detected Files To Include=====*/ +#include "unity.h" +#include <setjmp.h> +#include <stdio.h> +#include "CException.h" +#include "two.h" +#include "three.h" +#include <four.h> +#include "funky.h" +#include "stanky.h" +#include <setjmp.h> + +/*=======External Functions This Runner Calls=====*/ +extern void setUp(void); +extern void tearDown(void); +extern void test_TheFirstThingToTest(void); +extern void test_TheSecondThingToTest(void); +extern void test_TheThirdThingToTest(void); +extern void test_TheFourthThingToTest(void); + + +/*=======Suite Setup=====*/ +static int suite_setup(void) +{ +a_yaml_setup(); +} + +/*=======Test Reset Option=====*/ +void resetTest(void); +void resetTest(void) +{ + tearDown(); + setUp(); +} + + +/*=======MAIN=====*/ +int main(void) +{ + suite_setup(); + UnityBegin("testdata/testsample.c"); + RUN_TEST(test_TheFirstThingToTest, 21); + RUN_TEST(test_TheSecondThingToTest, 43); + RUN_TEST(test_TheThirdThingToTest, 53); + RUN_TEST(test_TheFourthThingToTest, 58); + + return (UnityEnd()); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/rakefile b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/rakefile new file mode 100644 index 000000000..e5f3b748f --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/rakefile @@ -0,0 +1,163 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +$verbose = false +$extra_paths = [] + +require 'rake' +require 'rake/clean' +require_relative 'rakefile_helper' +require 'rspec/core/rake_task' + +TEMP_DIRS = [ + File.join(__dir__, 'build'), + File.join(__dir__, 'sandbox') +] + +TEMP_DIRS.each do |dir| + directory(dir) + CLOBBER.include(dir) +end + +task :prepare_for_tests => TEMP_DIRS + +include RakefileHelpers + +# Load proper GCC as defult configuration +DEFAULT_CONFIG_FILE = 'gcc_auto_stdint.yml' +configure_toolchain(DEFAULT_CONFIG_FILE) + +############# ALL THE SELF-TESTS WE CAN PERFORM +namespace :test do + desc "Build and test Unity" + task :all => [:clean, :prepare_for_tests, 'test:scripts', 'test:unit', :style, 'test:fixture', 'test:memory', 'test:summary'] + task :ci => [:clean, :prepare_for_tests, 'test:scripts', 'test:unit', :style, 'test:make', 'test:fixture', 'test:memory', 'test:summary'] + + desc "Test unity with its own unit tests" + task :unit => [:prepare_for_tests] do + run_tests unit_test_files + end + + namespace :unit do + unit_test_files.each do |f| + desc "test this unit only" + task File.basename(f,'.c').sub('test_unity_','') => [:prepare_for_tests] do + run_tests [f] + end + end + end + + desc "Test unity's helper scripts" + task :scripts => [:prepare_for_tests] do + Dir['tests/test_*.rb'].each do |scriptfile| + require "./"+scriptfile + end + end + + desc "Test unity triggered from make" + task :make => [:prepare_for_tests] do + run_make_tests() + end + + desc "Test unity fixture addon" + task :fixture => [:prepare_for_tests] do + test_fixtures() + end + + desc "Test unity memory addon" + task :memory => [:prepare_for_tests] do + test_memory() + end + + desc "Test unity examples" + task :examples => [:prepare_for_tests] do + execute("cd ../examples/example_1 && make -s ci", false) + execute("cd ../examples/example_2 && make -s ci", false) + execute("cd ../examples/example_3 && rake", false) + end + + desc "Run all rspecs" + RSpec::Core::RakeTask.new(:spec) do |t| + t.pattern = 'spec/**/*_spec.rb' + end + + desc "Generate test summary" + task :summary do + report_summary + end +end + +###################### Shorthand for many common tasks +task :ci => ['test:ci'] +task :all => ['test:all'] +task :default => [:clobber, :all] + +desc "Load configuration" +task :config, :config_file do |t, args| + configure_toolchain(args[:config_file]) +end + +task :no_color do + $colour_output = false +end + +task :verbose do + $verbose = true +end + +################### CODING STYLE VALIDATION +namespace :style do + desc "Check style" + task :check do + report "\nVERIFYING RUBY STYLE" + report execute("rubocop ../auto ../examples ../extras --config .rubocop.yml", true) + report "Styling Ruby:PASS" + end + + namespace :check do + Dir['../**/*.rb'].each do |f| + filename = File.basename(f, '.rb') + #desc "Check Style of #{filename}" + task filename.to_sym => ['style:clean'] do + report execute("rubocop #{f} --color --config .rubocop.yml", true) + report "Style Checked for #{f}" + end + end + end + + desc "Fix Style of all C Code" + task :c do + run_astyle("../src/*.* ../extras/fixture/src/*.*") + end + + namespace :c do + Dir['../{src,extras/**}/*.{c,h}'].each do |f| + filename = File.basename(f)[0..-3] + #desc "Check Style of #{filename}" + task filename.to_sym do + run_astyle f + end + end + end + + desc "Attempt to Autocorrect style" + task :auto => ['style:clean'] do + execute("rubocop ../auto ../examples ../extras --auto-correct --config .rubocop.yml") + report "Autocorrected What We Could." + end + + desc "Update style todo list" + task :todo => ['style:clean'] do + execute("rubocop ../auto ../examples ../extras --auto-gen-config --config .rubocop.yml") + report "Updated Style TODO List." + end + + task :clean do + File.delete(".rubocop_todo.yml") if File.exists?(".rubocop_todo.yml") + end +end + +task :style => ['style:check'] diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/rakefile_helper.rb b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/rakefile_helper.rb new file mode 100644 index 000000000..e205bc67d --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/rakefile_helper.rb @@ -0,0 +1,315 @@ +# ========================================== +# Unity Project - A Test Framework for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +require 'yaml' +require 'fileutils' +require_relative '../auto/unity_test_summary' +require_relative '../auto/generate_test_runner' +require_relative '../auto/colour_reporter' + +module RakefileHelpers + C_EXTENSION = '.c'.freeze + def load_configuration(config_file) + return if $configured + + $cfg_file = "targets/#{config_file}" unless config_file =~ /[\\|\/]/ + $cfg = YAML.load(File.read($cfg_file)) + $colour_output = false unless $cfg['colour'] + $configured = true if config_file != DEFAULT_CONFIG_FILE + end + + def configure_clean + CLEAN.include('build/*.*') + end + + def configure_toolchain(config_file = DEFAULT_CONFIG_FILE) + config_file += '.yml' unless config_file =~ /\.yml$/ + config_file = config_file unless config_file =~ /[\\|\/]/ + load_configuration(config_file) + configure_clean + end + + def unit_test_files + path = 'tests/test*' + C_EXTENSION + path.tr!('\\', '/') + FileList.new(path) + end + + def local_include_dirs + include_dirs = $cfg[:paths][:includes] || [] + include_dirs += $cfg[:paths][:source] || [] + include_dirs += $cfg[:paths][:test] || [] + include_dirs += $cfg[:paths][:support] || [] + include_dirs.delete_if { |dir| dir.is_a?(Array) } + include_dirs + end + + def extract_headers(filename) + includes = [] + lines = File.readlines(filename) + lines.each do |line| + m = line.match(/^\s*#include\s+\"\s*(.+\.[hH])\s*\"/) + includes << m[1] unless m.nil? + end + includes + end + + def find_source_file(header, paths) + paths.each do |dir| + src_file = dir + header.ext(C_EXTENSION) + return src_file if File.exist?(src_file) + end + nil + end + + def tackit(strings) + result = if strings.is_a?(Array) + "\"#{strings.join}\"" + else + strings + end + result + end + + def squash(prefix, items) + result = '' + items.each { |item| result += " #{prefix}#{tackit(item)}" } + result + end + + def should(behave, &block) + if block + puts 'Should ' + behave + yield block + else + puts "UNIMPLEMENTED CASE: Should #{behave}" + end + end + + def build_command_string(hash, values, defines = nil) + + # Replace named and numbered slots + args = [] + hash[:arguments].each do |arg| + if arg.include? '$' + if arg.include? ': COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + pattern = arg.gsub(': COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE','') + [ File.join('..','src') ].each do |f| + args << pattern.gsub(/\$/,f) + end + + elsif arg.include? ': COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + pattern = arg.gsub(': COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR','') + [ $extra_paths, 'src', File.join('tests'), File.join('testdata'), $cfg[:paths][:support] ].flatten.uniq.compact.each do |f| + args << pattern.gsub(/\$/,f) + end + + elsif arg.include? ': COLLECTION_DEFINES_TEST_AND_VENDOR' + pattern = arg.gsub(': COLLECTION_DEFINES_TEST_AND_VENDOR','') + [ $cfg[:defines][:test], defines ].flatten.uniq.compact.each do |f| + args << pattern.gsub(/\$/,f) + end + + elsif arg =~ /\$\{(\d+)\}/ + i = $1.to_i - 1 + if (values[i].is_a?(Array)) + values[i].each {|v| args << arg.gsub(/\$\{\d+\}/, v)} + else + args << arg.gsub(/\$\{(\d)+\}/, values[i] || '') + end + + else + args << arg + + end + else + args << arg + end + end + + # Build Command + return tackit(hash[:executable]) + squash('', args) + end + + def compile(file, defines = []) + out_file = File.join('build', File.basename(file, C_EXTENSION)) + $cfg[:extension][:object] + cmd_str = build_command_string( $cfg[:tools][:test_compiler], [ file, out_file ], defines ) + execute(cmd_str) + out_file + end + + def link_it(exe_name, obj_list) + exe_name = File.join('build', File.basename(exe_name)) + cmd_str = build_command_string( $cfg[:tools][:test_linker], [ obj_list, exe_name ] ) + execute(cmd_str) + end + + def runtest(bin_name, ok_to_fail = false, extra_args = nil) + bin_name = File.join('build', File.basename(bin_name)) + extra_args = extra_args.nil? ? "" : " " + extra_args + if $cfg[:tools][:test_fixture] + cmd_str = build_command_string( $cfg[:tools][:test_fixture], [ bin_name, extra_args ] ) + else + cmd_str = bin_name + extra_args + end + execute(cmd_str, ok_to_fail) + end + + def run_astyle(style_what) + report "Styling C Code..." + command = "AStyle " \ + "--style=allman --indent=spaces=4 --indent-switches --indent-preproc-define --indent-preproc-block " \ + "--pad-oper --pad-comma --unpad-paren --pad-header " \ + "--align-pointer=type --align-reference=name " \ + "--add-brackets --mode=c --suffix=none " \ + "#{style_what}" + execute(command, false) + report "Styling C:PASS" + end + + def execute(command_string, ok_to_fail = false) + report command_string if $verbose + output = `#{command_string}`.chomp + report(output) if $verbose && !output.nil? && !output.empty? + raise "Command failed. (Returned #{$?.exitstatus})" if !$?.nil? && !$?.exitstatus.zero? && !ok_to_fail + output + end + + def report_summary + summary = UnityTestSummary.new + summary.root = __dir__ + results_glob = File.join('build','*.test*') + results_glob.tr!('\\', '/') + results = Dir[results_glob] + summary.targets = results + report summary.run + end + + def save_test_results(test_base, output) + test_results = File.join('build',test_base) + if output.match(/OK$/m).nil? + test_results += '.testfail' + else + report output unless $verbose # Verbose already prints this line, as does a failure + test_results += '.testpass' + end + File.open(test_results, 'w') { |f| f.print output } + end + + def test_fixtures() + report "\nRunning Fixture Addon" + + # Get a list of all source files needed + src_files = Dir[File.join('..','extras','fixture','src','*.c')] + src_files += Dir[File.join('..','extras','fixture','test','*.c')] + src_files += Dir[File.join('..','extras','fixture','test','main','*.c')] + src_files += Dir[File.join('..','extras','memory','src','*.c')] + src_files << File.join('..','src','unity.c') + + # Build object files + $extra_paths = [File.join('..','extras','fixture','src'), File.join('..','extras','memory','src')] + obj_list = src_files.map { |f| compile(f, ['UNITY_SKIP_DEFAULT_RUNNER', 'UNITY_FIXTURE_NO_EXTRAS']) } + + # Link the test executable + test_base = File.basename('framework_test', C_EXTENSION) + link_it(test_base, obj_list) + + # Run and collect output + output = runtest(test_base + " -v -r") + save_test_results(test_base, output) + end + + def test_memory() + { 'w_malloc' => [], + 'wo_malloc' => ['UNITY_EXCLUDE_STDLIB_MALLOC'] + }.each_pair do |name, defs| + report "\nRunning Memory Addon #{name}" + + # Get a list of all source files needed + src_files = Dir[File.join('..','extras','memory','src','*.c')] + src_files += Dir[File.join('..','extras','memory','test','*.c')] + src_files += Dir[File.join('..','extras','memory','test','main','*.c')] + src_files << File.join('..','src','unity.c') + + # Build object files + $extra_paths = [File.join('..','extras','memory','src')] + obj_list = src_files.map { |f| compile(f, defs) } + + # Link the test executable + test_base = File.basename("memory_test_#{name}", C_EXTENSION) + link_it(test_base, obj_list) + + # Run and collect output + output = runtest(test_base) + save_test_results(test_base, output) + end + end + + def run_tests(test_files) + report "\nRunning Unity system tests" + + include_dirs = local_include_dirs + + # Build and execute each unit test + test_files.each do |test| + + # Drop Out if we're skipping this type of test + if $cfg[:skip_tests] + if $cfg[:skip_tests].include?(:parameterized) && test.match(/parameterized/) + report("Skipping Parameterized Tests for this Target:IGNORE") + next + end + end + + report "\nRunning Tests in #{test}" + obj_list = [] + test_defines = [] + + # Detect dependencies and build required modules + extract_headers(test).each do |header| + # Compile corresponding source file if it exists + src_file = find_source_file(header, include_dirs) + + obj_list << compile(src_file, test_defines) unless src_file.nil? + end + + # Build the test runner (generate if configured to do so) + test_base = File.basename(test, C_EXTENSION) + runner_name = test_base + '_Runner.c' + runner_path = File.join('build',runner_name) + + options = $cfg[:unity] + options[:use_param_tests] = test =~ /parameterized/ ? true : false + UnityTestRunnerGenerator.new(options).run(test, runner_path) + obj_list << compile(runner_path, test_defines) + + # Build the test module + obj_list << compile(test, test_defines) + + # Link the test executable + link_it(test_base, obj_list) + + # Execute unit test and generate results file + output = runtest(test_base) + save_test_results(test_base, output) + end + end + + def run_make_tests() + [ "make -s", # test with all defaults + "make -s DEBUG=-m32", # test 32-bit architecture with 64-bit support + "make -s DEBUG=-m32 UNITY_SUPPORT_64=", # test 32-bit build without 64-bit types + "make -s UNITY_INCLUDE_DOUBLE= ", # test without double + "cd #{File.join("..","extras","fixture",'test')} && make -s default noStdlibMalloc", + "cd #{File.join("..","extras","fixture",'test')} && make -s C89", + "cd #{File.join("..","extras","memory",'test')} && make -s default noStdlibMalloc", + "cd #{File.join("..","extras","memory",'test')} && make -s C89", + ].each do |cmd| + report "Testing '#{cmd}'" + execute(cmd, false) + end + end +end diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/spec/generate_module_existing_file_spec.rb b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/spec/generate_module_existing_file_spec.rb new file mode 100644 index 000000000..74e7fc840 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/spec/generate_module_existing_file_spec.rb @@ -0,0 +1,158 @@ + +require '../auto/generate_module.rb' +require 'fileutils' + +def touch_src(file) + FileUtils.touch "sandbox/src/#{file}" +end + +def touch_test(file) + FileUtils.touch "sandbox/test/#{file}" +end + +def create_src_with_known_content(file) + File.open("sandbox/src/#{file}", "w") {|f| f.write("the original #{file}")} +end + +def create_test_with_known_content(file) + File.open("sandbox/test/#{file}", "w") {|f| f.write("the original #{file}")} +end + +def expect_src_content_didnt_change(file) + expect(File.read("sandbox/src/#{file}")).to eq("the original #{file}") +end + +def expect_test_content_didnt_change(file) + expect(File.read("sandbox/test/#{file}")).to eq("the original #{file}") +end + +def expect_src_file_to_exist(file) + expect(File.exist?("sandbox/src/#{file}")).to be true +end + +def expect_test_file_to_exist(file) + expect(File.exist?("sandbox/test/#{file}")).to be true +end + +describe "UnityModuleGenerator" do + + before do + # clean sandbox and setup our "project" folders + FileUtils.rm_rf "sandbox" + FileUtils.mkdir_p "sandbox" + FileUtils.mkdir_p "sandbox/src" + FileUtils.mkdir_p "sandbox/test" + + @options = { + :path_src => "sandbox/src", + :path_tst => "sandbox/test", + } + end + + context "with src pattern" do + before do + @options[:pattern] = "src" + end + + it "fails when all files already exist" do + # create an existing triad of files + touch_src "meh.c" + touch_src "meh.h" + touch_test "Testmeh.c" + expect { + UnityModuleGenerator.new(@options).generate("meh") + }.to raise_error("ERROR: File meh already exists. Exiting.") + end + + it "creates the test file if the source and header files exist" do + # Create the existing files. + touch_src "meh.c" + touch_src "meh.h" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_test_file_to_exist "Testmeh.c" + end + + it "does not alter existing files" do + # Create some files with known content. + create_src_with_known_content "meh.c" + create_src_with_known_content "meh.h" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_src_content_didnt_change "meh.c" + expect_src_content_didnt_change "meh.c" + end + + it "does not alter existing test files" do + # Create some files with known content. + create_test_with_known_content "Testmeh.c" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_test_content_didnt_change "Testmeh.c" + end + + end + + context "with mch pattern" do + before do + @options[:pattern] = "mch" + end + + it "fails when all files exist" do + touch_src "meh_model.c" + touch_src "meh_conductor.c" + touch_src "meh_hardware.c" + touch_src "meh_model.h" + touch_src "meh_conductor.h" + touch_src "meh_hardware.h" + touch_test "Testmeh_model.c" + touch_test "Testmeh_conductor.c" + touch_test "Testmeh_hardware.c" + expect { + UnityModuleGenerator.new(@options).generate("meh") + }.to raise_error("ERROR: File meh_model already exists. Exiting.") + end + + it "creates files that don't exist" do + touch_src "meh_model.c" + touch_src "meh_conductor.c" + touch_src "meh_hardware.c" + touch_src "meh_model.h" + touch_src "meh_conductor.h" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_src_file_to_exist "meh_hardware.h" + expect_test_file_to_exist "Testmeh_model.c" + expect_test_file_to_exist "Testmeh_conductor.c" + expect_test_file_to_exist "Testmeh_hardware.c" + end + + it "does not alter existing source files" do + create_src_with_known_content "meh_model.c" + create_src_with_known_content "meh_model.c" + create_src_with_known_content "meh_model.c" + create_src_with_known_content "meh_model.h" + create_src_with_known_content "meh_model.c" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_src_content_didnt_change "meh_model.c" + expect_src_content_didnt_change "meh_model.c" + expect_src_content_didnt_change "meh_model.c" + expect_src_content_didnt_change "meh_model.c" + end + + it "does not alter existing test files" do + create_test_with_known_content "Testmeh_model.c" + + UnityModuleGenerator.new(@options).generate("meh") + + expect_test_content_didnt_change "Testmeh_model.c" + end + + end +end diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/ansi.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/ansi.yml new file mode 100644 index 000000000..81af4c7f5 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/ansi.yml @@ -0,0 +1,44 @@ +--- +colour: true +:unity: + :plugins: [] +:skip_tests: +- :parameterized +:tools: + :test_compiler: + :name: compiler + :executable: gcc + :arguments: + - "-c" + - "-m64" + - "-Wall" + - "-Wno-address" + - "-ansi" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: gcc + :arguments: + - "${1}" + - "-lm" + - "-m64" + - "-o ${2}" +:extension: + :object: ".o" + :executable: ".exe" +:paths: + :test: + - src/ + - "../src/" + - testdata/ + - tests/ +:defines: + :test: + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_EXCLUDE_TESTING_NEW_COMMENTS + - UNITY_SUPPORT_64 diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/clang_file.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/clang_file.yml new file mode 100644 index 000000000..964e8145c --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/clang_file.yml @@ -0,0 +1,72 @@ +--- +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: clang + :arguments: + - "-c" + - "-Wall" + - "-Wextra" + - "-Werror" + - "-Wcast-qual" + - "-Wconversion" + - "-Wdisabled-optimization" + - "-Wformat=2" + - "-Winit-self" + - "-Winline" + - "-Winvalid-pch" + - "-Wmissing-include-dirs" + - "-Wnonnull" + - "-Wpacked" + - "-Wpointer-arith" + - "-Wswitch-default" + - "-Wstrict-aliasing" + - "-Wstrict-overflow=5" + - "-Wuninitialized" + - "-Wunused" + - "-Wreturn-type" + - "-Wshadow" + - "-Wundef" + - "-Wwrite-strings" + - "-Wno-nested-externs" + - "-Wno-unused-parameter" + - "-Wno-variadic-macros" + - "-Wbad-function-cast" + - "-fms-extensions" + - "-fno-omit-frame-pointer" + - "-ffloat-store" + - "-fno-common" + - "-fstrict-aliasing" + - "-std=gnu99" + - "-pedantic" + - "-O0" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: clang + :arguments: + - "${1}" + - "-lm" + - "-m64" + - "-o ${2}" +:extension: + :object: ".o" + :executable: ".exe" +:paths: + :test: + - src/ + - "../src/" + - testdata/ + - tests/ +:defines: + :test: + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_64 + - UNITY_OUTPUT_RESULTS_FILE diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/clang_strict.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/clang_strict.yml new file mode 100644 index 000000000..04d568064 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/clang_strict.yml @@ -0,0 +1,71 @@ +--- +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: clang + :arguments: + - "-c" + - "-Wall" + - "-Wextra" + - "-Werror" + - "-Wcast-qual" + - "-Wconversion" + - "-Wdisabled-optimization" + - "-Wformat=2" + - "-Winit-self" + - "-Winline" + - "-Winvalid-pch" + - "-Wmissing-include-dirs" + - "-Wnonnull" + - "-Wpacked" + - "-Wpointer-arith" + - "-Wswitch-default" + - "-Wstrict-aliasing" + - "-Wstrict-overflow=5" + - "-Wuninitialized" + - "-Wunused" + - "-Wreturn-type" + - "-Wshadow" + - "-Wundef" + - "-Wwrite-strings" + - "-Wno-nested-externs" + - "-Wno-unused-parameter" + - "-Wno-variadic-macros" + - "-Wbad-function-cast" + - "-fms-extensions" + - "-fno-omit-frame-pointer" + - "-fno-common" + - "-fstrict-aliasing" + - "-std=gnu99" + - "-pedantic" + - "-O0" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: clang + :arguments: + - "${1}" + - "-lm" + - "-m64" + - "-o ${2}" +:extension: + :object: ".o" + :executable: ".exe" +:paths: + :test: + - src/ + - "../src/" + - testdata/ + - tests/ +:defines: + :test: + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_SUPPORT_64 diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_32.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_32.yml new file mode 100644 index 000000000..ba388cf72 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_32.yml @@ -0,0 +1,45 @@ +--- +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: gcc + :arguments: + - "-c" + - "-m32" + - "-Wall" + - "-Wno-address" + - "-std=c99" + - "-pedantic" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: gcc + :arguments: + - "${1}" + - "-lm" + - "-m32" + - "-o ${2}" +:extension: + :object: ".o" + :executable: ".exe" +:paths: + :test: + - src/ + - "../src/" + - testdata/ + - tests/ +:defines: + :test: + - UNITY_EXCLUDE_STDINT_H + - UNITY_EXCLUDE_LIMITS_H + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_INT_WIDTH=32 + - UNITY_LONG_WIDTH=32 diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_64.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_64.yml new file mode 100644 index 000000000..ed9eb4a80 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_64.yml @@ -0,0 +1,46 @@ +--- +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: gcc + :arguments: + - "-c" + - "-m64" + - "-Wall" + - "-Wno-address" + - "-std=c99" + - "-pedantic" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: gcc + :arguments: + - "${1}" + - "-lm" + - "-m64" + - "-o ${2}" +:extension: + :object: ".o" + :executable: ".exe" +:paths: + :test: + - src/ + - "../src/" + - testdata/ + - tests/ +:defines: + :test: + - UNITY_EXCLUDE_STDINT_H + - UNITY_EXCLUDE_LIMITS_H + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_SUPPORT_64 + - UNITY_INT_WIDTH=32 + - UNITY_LONG_WIDTH=64 diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_auto_limits.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_auto_limits.yml new file mode 100644 index 000000000..9cfda8d4a --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_auto_limits.yml @@ -0,0 +1,43 @@ +--- +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: gcc + :arguments: + - "-c" + - "-m64" + - "-Wall" + - "-Wno-address" + - "-std=c99" + - "-pedantic" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: gcc + :arguments: + - "${1}" + - "-lm" + - "-m64" + - "-o ${2}" +:extension: + :object: ".o" + :executable: ".exe" +:paths: + :test: + - src/ + - "../src/" + - testdata/ + - tests/ +:defines: + :test: + - UNITY_EXCLUDE_STDINT_H + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_SUPPORT_64 diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_auto_stdint.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_auto_stdint.yml new file mode 100644 index 000000000..66602ef71 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_auto_stdint.yml @@ -0,0 +1,55 @@ +--- +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: gcc + :arguments: + - "-c" + - "-m64" + - "-Wall" + - "-Wno-address" + - "-std=c99" + - "-pedantic" + - "-Wextra" + - "-Werror" + - "-Wpointer-arith" + - "-Wcast-align" + - "-Wwrite-strings" + - "-Wswitch-default" + - "-Wunreachable-code" + - "-Winit-self" + - "-Wmissing-field-initializers" + - "-Wno-unknown-pragmas" + - "-Wstrict-prototypes" + - "-Wundef" + - "-Wold-style-definition" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: gcc + :arguments: + - "${1}" + - "-lm" + - "-m64" + - "-o ${2}" +:extension: + :object: ".o" + :executable: ".exe" +:paths: + :test: + - src/ + - "../src/" + - testdata/ + - tests/ +:defines: + :test: + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_SUPPORT_64 diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_manual_math.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_manual_math.yml new file mode 100644 index 000000000..b1b5b82e5 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/gcc_manual_math.yml @@ -0,0 +1,43 @@ +--- +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: gcc + :arguments: + - "-c" + - "-m64" + - "-Wall" + - "-Wno-address" + - "-std=c99" + - "-pedantic" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: gcc + :arguments: + - "${1}" + - "-lm" + - "-m64" + - "-o ${2}" +:extension: + :object: ".o" + :executable: ".exe" +:paths: + :test: + - src/ + - "../src/" + - testdata/ + - tests/ +:defines: + :test: + - UNITY_EXCLUDE_MATH_H + - UNITY_INCLUDE_DOUBLE + - UNITY_SUPPORT_TEST_CASES + - UNITY_SUPPORT_64 diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/hitech_picc18.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/hitech_picc18.yml new file mode 100644 index 000000000..b984edbd8 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/hitech_picc18.yml @@ -0,0 +1,91 @@ +--- +:cmock: + :plugins: [] + :includes: + - Types.h + :suite_teardown: | + if (num_failures) + _FAILED_TEST(); + else + _PASSED_TESTS(); + return 0; +colour: true +:tools: + :test_compiler: + :name: compiler + :executable: cd build && picc18 + :arguments: + - "--chip=18F87J10" + - "--ide=hitide" + - "--q" + - "--asmlist" + - "--codeoffset=0" + - "--emi=wordwrite" + - "--warn=0" + - "--errors=10" + - "--char=unsigned" + - "-Bl" + - "-G" + - "--cp=16" + - "--double=24" + - "-N255" + - "--opt=none" + - "-c" + - "-M" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - " ${2}" + :test_linker: + :name: linker + :executable: cd build && picc18 + :arguments: + - "${1}" + - "--chip=18F87J10" + - "--ide=hitide" + - "--cp=24" + - "--double=24" + - "-Lw" + - "--summary=mem,file" + - "--summary=+psect" + - "--summary=+hex" + - "--output=+intel" + - "--output=+mcof" + - "--runtime=+init" + - "--runtime=+clear" + - "--runtime=+clib" + - "--runtime=+keep" + - "-G" + - "-MIWasTheLastToBuild.map" + - "--warn=0" + - "-Bl" + - "-O ${2}" + :test_fixture: + :name: simulator + :executable: 'java -client -jar ' + :arguments: + - - C:\Program Files\HI-TECH Software\HI-TIDE\3.15\lib\ + - simpic18.jar + - 18F87J10 + - "${1}" +:extension: + :object: ".obj" + :executable: ".hex" +:paths: + :test: + - c:/Projects/NexGen/Prototypes/CMockTest/src/ + - c:/Projects/NexGen/Prototypes/CMockTest/mocks/ + - c:/CMock/src/ + - c:/CMock/examples/src/ + - c:/CMock/vendor/unity/src/ + - c:/CMock/vendor/unity/examples/helper/ + - tests\ +:defines: + :test: + - UNITY_INT_WIDTH=16 + - UNITY_POINTER_WIDTH=16 + - CMOCK_MEM_STATIC + - CMOCK_MEM_SIZE=3000 + - UNITY_SUPPORT_TEST_CASES + - _PICC18 diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_arm_v4.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_arm_v4.yml new file mode 100644 index 000000000..9a1a2761e --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_arm_v4.yml @@ -0,0 +1,98 @@ +--- +tools_root: C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - arm\bin\iccarm.exe + :arguments: + - "--dlib_config" + - - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - arm\lib\dl4tptinl8n.h + - "-z3" + - "--no_cse" + - "--no_unroll" + - "--no_inline" + - "--no_code_motion" + - "--no_tbaa" + - "--no_clustering" + - "--no_scheduling" + - "--debug" + - "--cpu_mode thumb" + - "--endian little" + - "--cpu ARM7TDMI" + - "--stack_align 4" + - "--interwork" + - "-e" + - "--silent" + - "--warnings_are_errors" + - "--fpu None" + - "--diag_suppress Pa050" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - common\bin\xlink.exe + :arguments: + - "${1}" + - "-rt" + - - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - arm\lib\dl4tptinl8n.r79 + - "-D_L_EXTMEM_START=0" + - "-D_L_EXTMEM_SIZE=0" + - "-D_L_HEAP_SIZE=120" + - "-D_L_STACK_SIZE=32" + - "-e_small_write=_formatted_write" + - "-s" + - __program_start + - "-f" + - - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - "\\arm\\config\\lnkarm.xcl" + - "-o ${2}" + :test_fixture: + :name: simulator + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - common\bin\CSpyBat.exe + :arguments: + - "--silent" + - - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - arm\bin\armproc.dll + - - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - arm\bin\armsim.dll + - "${1}" + - "--plugin" + - - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - arm\bin\armbat.dll + - "--backend" + - "-B" + - "-p" + - - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - arm\config\ioat91sam7X256.ddf + - "-d" + - sim +:extension: + :object: ".r79" + :executable: ".d79" +:paths: + :test: + - - C:\Program Files\IAR Systems\Embedded Workbench 4.0 Kickstart\ + - arm\inc\ + - src\ + - "..\\src\\" + - testdata/ + - tests\ + - vendor\unity\src\ +:defines: + :test: + - UNITY_SUPPORT_64 + - UNITY_SUPPORT_TEST_CASES diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_arm_v5.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_arm_v5.yml new file mode 100644 index 000000000..d4b115f14 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_arm_v5.yml @@ -0,0 +1,92 @@ +--- +tools_root: C:\Program Files\IAR Systems\Embedded Workbench 5.3\ +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\bin\iccarm.exe + :arguments: + - "--dlib_config" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\inc\DLib_Config_Normal.h + - "--no_cse" + - "--no_unroll" + - "--no_inline" + - "--no_code_motion" + - "--no_tbaa" + - "--no_clustering" + - "--no_scheduling" + - "--debug" + - "--cpu_mode thumb" + - "--endian=little" + - "--cpu=ARM7TDMI" + - "--interwork" + - "--warnings_are_errors" + - "--fpu=None" + - "--diag_suppress=Pa050" + - "--diag_suppress=Pe111" + - "-e" + - "-On" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\bin\ilinkarm.exe + :arguments: + - "${1}" + - "--redirect _Printf=_PrintfLarge" + - "--redirect _Scanf=_ScanfSmall" + - "--semihosting" + - "--entry __iar_program_start" + - "--config" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\config\generic.icf + - "-o ${2}" + :test_fixture: + :name: simulator + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - common\bin\CSpyBat.exe + :arguments: + - "--silent" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\bin\armproc.dll + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\bin\armsim.dll + - "${1}" + - "--plugin" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\bin\armbat.dll + - "--backend" + - "-B" + - "-p" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\config\debugger\atmel\ioat91sam7X256.ddf + - "-d" + - sim +:extension: + :object: ".r79" + :executable: ".out" +:paths: + :test: + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\inc\ + - src\ + - "..\\src\\" + - testdata/ + - tests\ + - vendor\unity\src\ + - iar\iar_v5\incIAR\ +:defines: + :test: + - UNITY_SUPPORT_64 + - UNITY_SUPPORT_TEST_CASES diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_arm_v5_3.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_arm_v5_3.yml new file mode 100644 index 000000000..d4b115f14 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_arm_v5_3.yml @@ -0,0 +1,92 @@ +--- +tools_root: C:\Program Files\IAR Systems\Embedded Workbench 5.3\ +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\bin\iccarm.exe + :arguments: + - "--dlib_config" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\inc\DLib_Config_Normal.h + - "--no_cse" + - "--no_unroll" + - "--no_inline" + - "--no_code_motion" + - "--no_tbaa" + - "--no_clustering" + - "--no_scheduling" + - "--debug" + - "--cpu_mode thumb" + - "--endian=little" + - "--cpu=ARM7TDMI" + - "--interwork" + - "--warnings_are_errors" + - "--fpu=None" + - "--diag_suppress=Pa050" + - "--diag_suppress=Pe111" + - "-e" + - "-On" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\bin\ilinkarm.exe + :arguments: + - "${1}" + - "--redirect _Printf=_PrintfLarge" + - "--redirect _Scanf=_ScanfSmall" + - "--semihosting" + - "--entry __iar_program_start" + - "--config" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\config\generic.icf + - "-o ${2}" + :test_fixture: + :name: simulator + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - common\bin\CSpyBat.exe + :arguments: + - "--silent" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\bin\armproc.dll + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\bin\armsim.dll + - "${1}" + - "--plugin" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\bin\armbat.dll + - "--backend" + - "-B" + - "-p" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\config\debugger\atmel\ioat91sam7X256.ddf + - "-d" + - sim +:extension: + :object: ".r79" + :executable: ".out" +:paths: + :test: + - - C:\Program Files\IAR Systems\Embedded Workbench 5.3\ + - arm\inc\ + - src\ + - "..\\src\\" + - testdata/ + - tests\ + - vendor\unity\src\ + - iar\iar_v5\incIAR\ +:defines: + :test: + - UNITY_SUPPORT_64 + - UNITY_SUPPORT_TEST_CASES diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_armcortex_LM3S9B92_v5_4.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_armcortex_LM3S9B92_v5_4.yml new file mode 100644 index 000000000..1703fe27c --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_armcortex_LM3S9B92_v5_4.yml @@ -0,0 +1,90 @@ +--- +tools_root: C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: + - C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ + - arm\bin\iccarm.exe + :arguments: + - "--diag_suppress=Pa050" + - "--debug" + - "--endian=little" + - "--cpu=Cortex-M3" + - "--no_path_in_file_macros" + - "-e" + - "--fpu=None" + - "--dlib_config" + - - C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ + - arm\inc\DLib_Config_Normal.h + - "--interwork" + - "--warnings_are_errors" + - "-Oh" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: + - C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ + - arm\bin\ilinkarm.exe + :arguments: + - "${1}" + - "--redirect _Printf=_PrintfLarge" + - "--redirect _Scanf=_ScanfSmall" + - "--semihosting" + - "--entry __iar_program_start" + - "--config" + - - C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ + - arm\config\generic.icf + - "-o ${2}" + :test_fixture: + :name: simulator + :executable: + - C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ + - common\bin\CSpyBat.exe + :arguments: + - - C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ + - arm\bin\armproc.dll + - - C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ + - arm\bin\armsim2.dll + - "${1}" + - "--plugin" + - - C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ + - arm\bin\armbat.dll + - "--backend" + - "-B" + - "--endian=little" + - "--cpu=Cortex-M3" + - "--fpu=None" + - "-p" + - - C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ + - arm\config\debugger\TexasInstruments\iolm3sxxxx.ddf + - "--semihosting" + - "--device=LM3SxBxx" +:extension: + :object: ".r79" + :executable: ".out" +:paths: + :test: + - - C:\Program Files (x86)\IAR Systems\Embedded Workbench 5.4 Kickstart\ + - arm\inc\ + - src\ + - "..\\src\\" + - testdata/ + - tests\ + - vendor\unity\src\ + - iar\iar_v5\incIAR\ +:defines: + :test: + - ewarm + - PART_LM3S9B92 + - TARGET_IS_TEMPEST_RB1 + - USE_ROM_DRIVERS + - UART_BUFFERED + - UNITY_SUPPORT_64 diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_cortexm3_v5.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_cortexm3_v5.yml new file mode 100644 index 000000000..8b0978ffa --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_cortexm3_v5.yml @@ -0,0 +1,94 @@ +--- +tools_root: C:\Program Files\IAR Systems\Embedded Workbench 5.4\ +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 5.4\ + - arm\bin\iccarm.exe + :arguments: + - "--dlib_config" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.4\ + - arm\inc\DLib_Config_Normal.h + - "--no_cse" + - "--no_unroll" + - "--no_inline" + - "--no_code_motion" + - "--no_tbaa" + - "--no_clustering" + - "--no_scheduling" + - "--debug" + - "--cpu_mode thumb" + - "--endian=little" + - "--cpu=Cortex-M3" + - "--interwork" + - "--warnings_are_errors" + - "--fpu=None" + - "--diag_suppress=Pa050" + - "--diag_suppress=Pe111" + - "-e" + - "-On" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 5.4\ + - arm\bin\ilinkarm.exe + :arguments: + - "${1}" + - "--redirect _Printf=_PrintfLarge" + - "--redirect _Scanf=_ScanfSmall" + - "--semihosting" + - "--entry __iar_program_start" + - "--config" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.4\ + - arm\config\generic_cortex.icf + - "-o ${2}" + :test_fixture: + :name: simulator + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 5.4\ + - common\bin\CSpyBat.exe + :arguments: + - "--silent" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.4\ + - arm\bin\armproc.dll + - - C:\Program Files\IAR Systems\Embedded Workbench 5.4\ + - arm\bin\armsim.dll + - "${1}" + - "--plugin" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.4\ + - arm\bin\armbat.dll + - "--backend" + - "-B" + - "-p" + - - C:\Program Files\IAR Systems\Embedded Workbench 5.4\ + - arm\config\debugger\ST\iostm32f107xx.ddf + - "--cpu=Cortex-M3" + - "-d" + - sim +:extension: + :object: ".r79" + :executable: ".out" +:paths: + :test: + - - C:\Program Files\IAR Systems\Embedded Workbench 5.4\ + - arm\inc\ + - src\ + - "..\\src\\" + - testdata/ + - tests\ + - vendor\unity\src\ + - iar\iar_v5\incIAR\ +:defines: + :test: + - IAR + - UNITY_SUPPORT_64 + - UNITY_SUPPORT_TEST_CASES diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_msp430.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_msp430.yml new file mode 100644 index 000000000..65872535f --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_msp430.yml @@ -0,0 +1,112 @@ +--- +tools_root: C:\Program Files\IAR Systems\Embedded Workbench 5.3 MSP430\ +core_root: &1 +- C:\Program Files\IAR Systems\Embedded Workbench 5.3 MSP430\ +- 430\ +core_bin: &2 +- *1 +- bin\ +core_config: &4 +- *1 +- config\ +core_lib: &3 +- *1 +- lib\ +core_inc: &5 +- *1 +- inc\ +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: + - *2 + - icc430.exe + :arguments: + - "--dlib_config" + - - *3 + - dlib\dl430fn.h + - "--no_cse" + - "--no_unroll" + - "--no_inline" + - "--no_code_motion" + - "--no_tbaa" + - "--debug" + - "-e" + - "-Ol" + - "--multiplier=16" + - "--double=32" + - "--diag_suppress Pa050" + - "--diag_suppress Pe111" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: + - *2 + - xlink.exe + :arguments: + - "${1}" + - "-rt" + - - *3 + - dlib\dl430fn.r43 + - "-e_PrintfTiny=_Printf" + - "-e_ScanfSmall=_Scanf" + - "-s __program_start" + - "-D_STACK_SIZE=50" + - "-D_DATA16_HEAP_SIZE=50" + - "-D_DATA20_HEAP_SIZE=50" + - "-f" + - - *4 + - lnk430f5438.xcl + - "-f" + - - *4 + - multiplier.xcl + - "-o ${2}" + :test_fixture: + :name: simulator + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 5.3 MSP430\ + - common\bin\CSpyBat.exe + :arguments: + - "--silent" + - - *2 + - 430proc.dll + - - *2 + - 430sim.dll + - "${1}" + - "--plugin" + - - *2 + - 430bat.dll + - "--backend -B" + - "--cpu MSP430F5438" + - "-p" + - - *4 + - MSP430F5438.ddf + - "-d sim" +:extension: + :object: ".r43" + :executable: ".d79" +:paths: + :test: + - *5 + - - *5 + - dlib + - - *3 + - dlib + - src\ + - "../src/" + - testdata/ + - tests\ + - vendor\unity\src +:defines: + :test: + - __MSP430F149__ + - INT_WIDTH=16 + - UNITY_EXCLUDE_FLOAT + - UNITY_SUPPORT_TEST_CASES diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_sh2a_v6.yml b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_sh2a_v6.yml new file mode 100644 index 000000000..b4371cd0a --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/targets/iar_sh2a_v6.yml @@ -0,0 +1,99 @@ +--- +tools_root: C:\Program Files\IAR Systems\Embedded Workbench 6.0\ +colour: true +:unity: + :plugins: [] +:tools: + :test_compiler: + :name: compiler + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - sh\bin\iccsh.exe + :arguments: + - "-e" + - "--char_is_signed" + - "-Ol" + - "--no_cse" + - "--no_unroll" + - "--no_inline" + - "--no_code_motion" + - "--no_tbaa" + - "--no_scheduling" + - "--no_clustering" + - "--debug" + - "--dlib_config" + - - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - sh\inc\DLib_Product.h + - "--double=32" + - "--code_model=huge" + - "--data_model=huge" + - "--core=sh2afpu" + - "--warnings_affect_exit_code" + - "--warnings_are_errors" + - "--mfc" + - "--use_unix_directory_separators" + - "--diag_suppress=Pe161" + - '-I"$": COLLECTION_PATHS_TEST_TOOLCHAIN_INCLUDE' + - '-I"$": COLLECTION_PATHS_TEST_SUPPORT_SOURCE_INCLUDE_VENDOR' + - "-D$: COLLECTION_DEFINES_TEST_AND_VENDOR" + - "${1}" + - "-o ${2}" + :test_linker: + :name: linker + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - sh\bin\ilinksh.exe + :arguments: + - "${1}" + - "--redirect __Printf=__PrintfSmall" + - "--redirect __Scanf=__ScanfSmall" + - "--config" + - - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - sh\config\generic.icf + - "--config_def _CSTACK_SIZE=0x800" + - "--config_def _HEAP_SIZE=0x800" + - "--config_def _INT_TABLE=0x10" + - "--entry __iar_program_start" + - "--debug_lib" + - "-o ${2}" + :test_fixture: + :name: simulator + :executable: + - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - common\bin\CSpyBat.exe + :arguments: + - "--silent" + - - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - sh\bin\shproc.dll + - - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - sh\bin\shsim.dll + - "${1}" + - "--plugin" + - - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - sh\bin\shbat.dll + - "--backend" + - "-B" + - "--core sh2afpu" + - "-p" + - - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - sh\config\debugger\io7264.ddf + - "-d" + - sim +:extension: + :object: ".o" + :executable: ".out" +:paths: + :test: + - - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - sh\inc\ + - - C:\Program Files\IAR Systems\Embedded Workbench 6.0\ + - sh\inc\c + - src\ + - "..\\src\\" + - testdata/ + - tests\ + - vendor\unity\src\ +:defines: + :test: + - UNITY_SUPPORT_64 + - UNITY_SUPPORT_TEST_CASES diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/CException.h b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/CException.h new file mode 100644 index 000000000..3872fa75f --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/CException.h @@ -0,0 +1,11 @@ +#ifndef CEXCEPTION_H +#define CEXCEPTION_H + +#define CEXCEPTION_BEING_USED 1 + +#define CEXCEPTION_NONE 0 +#define CEXCEPTION_T int e = 1; (void) +#define Try if (e) +#define Catch(a) if (!a) + +#endif diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/Defs.h b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/Defs.h new file mode 100644 index 000000000..b1dc83e9b --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/Defs.h @@ -0,0 +1,8 @@ +#ifndef DEF_H +#define DEF_H + +#define EXTERN_DECL + +extern int CounterSuiteSetup; + +#endif diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/cmock.h b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/cmock.h new file mode 100644 index 000000000..33ddbfc56 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/cmock.h @@ -0,0 +1,14 @@ +#ifndef CMOCK_H +#define CMOCK_H + +int CMockMemFreeFinalCounter = 0; +int mockMock_Init_Counter = 0; +int mockMock_Verify_Counter = 0; +int mockMock_Destroy_Counter = 0; + +void CMock_Guts_MemFreeFinal(void) { CMockMemFreeFinalCounter++; } +void mockMock_Init(void) { mockMock_Init_Counter++; } +void mockMock_Verify(void) { mockMock_Verify_Counter++; } +void mockMock_Destroy(void) { mockMock_Destroy_Counter++; } + +#endif diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/mockMock.h b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/mockMock.h new file mode 100644 index 000000000..5c6829d77 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/mockMock.h @@ -0,0 +1,13 @@ +#ifndef MOCK_MOCK_H +#define MOCK_MOCK_H + +extern int mockMock_Init_Counter; +extern int mockMock_Verify_Counter; +extern int mockMock_Destroy_Counter; +extern int CMockMemFreeFinalCounter; + +void mockMock_Init(void); +void mockMock_Verify(void); +void mockMock_Destroy(void); + +#endif diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/testRunnerGenerator.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/testRunnerGenerator.c new file mode 100644 index 000000000..b5dd97f5d --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/testRunnerGenerator.c @@ -0,0 +1,189 @@ +/* This Test File Is Used To Verify Many Combinations Of Using the Generate Test Runner Script */ + +#include <stdio.h> +#include "unity.h" +#include "Defs.h" + +#ifdef USE_CEXCEPTION +#include "CException.h" +#endif + +/* Notes about prefixes: + test - normal default prefix. these are "always run" tests for this procedure + spec - normal default prefix. required to run default setup/teardown calls. + should - normal default prefix. + qwiktest - custom prefix for when tests skip all setup/teardown calls. + custtest - custom prefix for when tests use custom setup/teardown calls. + paratest - custom prefix for when we want to verify parameterized tests. + extest - custom prefix only used during cexception + suitetest- custom prefix for when we want to use custom suite setup/teardown +*/ + +/* Support for Meta Test Rig */ +#define TEST_CASE(a) + +/* Include Passthroughs for Linking Tests */ +void putcharSpy(int c) { (void)putchar(c);} +void flushSpy(void) {} + +/* Global Variables Used During These Tests */ +int CounterSetup = 0; +int CounterTeardown = 0; +int CounterSuiteSetup = 0; + +void setUp(void) +{ + CounterSetup = 1; +} + +void tearDown(void) +{ + CounterTeardown = 1; +} + +void custom_setup(void) +{ + CounterSetup = 2; +} + +void custom_teardown(void) +{ + CounterTeardown = 2; +} + +/* +void test_OldSchoolCommentsShouldBeIgnored(void) +{ + TEST_ASSERT_FAIL("Old-School Comments Should Be Ignored"); +} +*/ + +void test_ThisTestAlwaysPasses(void) +{ + TEST_PASS(); +} + +void test_ThisTestAlwaysFails(void) +{ + TEST_FAIL_MESSAGE("This Test Should Fail"); +} + +void test_ThisTestAlwaysIgnored(void) +{ + TEST_IGNORE_MESSAGE("This Test Should Be Ignored"); +} + +void qwiktest_ThisTestPassesWhenNoSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterSetup, "Setup Was Unexpectedly Run"); +} + +void qwiktest_ThisTestPassesWhenNoTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterTeardown, "Teardown Was Unexpectedly Run"); +} + +void spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterSuiteSetup, "Suite Setup Was Unexpectedly Run"); +} + +void spec_ThisTestPassesWhenNormalSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterSetup, "Normal Setup Wasn't Run"); +} + +void spec_ThisTestPassesWhenNormalTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterTeardown, "Normal Teardown Wasn't Run"); +} + +void custtest_ThisTestPassesWhenCustomSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(2, CounterSetup, "Custom Setup Wasn't Run"); +} + +void custtest_ThisTestPassesWhenCustomTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(2, CounterTeardown, "Custom Teardown Wasn't Run"); +} + +#ifndef UNITY_EXCLUDE_TESTING_NEW_COMMENTS +//void test_NewStyleCommentsShouldBeIgnored(void) +//{ +// TEST_ASSERT_FAIL("New Style Comments Should Be Ignored"); +//} +#endif + +void test_NotBeConfusedByLongComplicatedStrings(void) +{ + const char* crazyString = "GET / HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nCache-Control: no-cache\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36\r\nPostman-Token: 768c7149-c3fb-f704-71a2-63918d9195b2\r\nAccept: */*\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n"; + + TEST_ASSERT_EQUAL_STRING_MESSAGE(crazyString, crazyString, "These Strings Are The Same"); +} + +/* The next test should still appear even though we have this confusing nested comment thing going on http://looks_like_comments.com */ +void test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings(void) +{ + TEST_ASSERT_TRUE_MESSAGE(1, "1 Should be True"); + /* still should not break anything */ +} +/* nor should this */ + +void test_StillNotBeConfusedByLongComplicatedStrings(void) +{ + const char* crazyString = "GET / HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nCache-Control: no-cache\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36\r\nPostman-Token: 768c7149-c3fb-f704-71a2-63918d9195b2\r\nAccept: */*\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n"; + + TEST_ASSERT_EQUAL_STRING_MESSAGE(crazyString, crazyString, "These Strings Are Still The Same"); +} + +void should_RunTestsStartingWithShouldByDefault(void) +{ + TEST_ASSERT_TRUE_MESSAGE(1, "1 Should be True"); +} + +TEST_CASE(25) +TEST_CASE(125) +TEST_CASE(5) +void paratest_ShouldHandleParameterizedTests(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, (Num % 5), "All The Values Are Divisible By 5"); +} + +TEST_CASE(7) +void paratest_ShouldHandleParameterizedTests2(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(7, Num, "The Only Call To This Passes"); +} + +void paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid(void) +{ + TEST_PASS(); +} + +TEST_CASE(17) +void paratest_ShouldHandleParameterizedTestsThatFail(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(3, Num, "This call should fail"); +} + +#ifdef USE_CEXCEPTION +void extest_ShouldHandleCExceptionInTest(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CEXCEPTION_BEING_USED, "Should be pulling in CException"); +} +#endif + +#ifdef USE_ANOTHER_MAIN +int custom_main(void); + +int main(void) +{ + return custom_main(); +} +#endif + +void suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterSuiteSetup, "Suite Setup Should Have Run"); +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/testRunnerGeneratorSmall.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/testRunnerGeneratorSmall.c new file mode 100644 index 000000000..c8aaf747e --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/testRunnerGeneratorSmall.c @@ -0,0 +1,70 @@ +/* This Test File Is Used To Verify Many Combinations Of Using the Generate Test Runner Script */ + +#include <stdio.h> +#include "unity.h" +#include "Defs.h" + +TEST_FILE("some_file.c") + +/* Notes about prefixes: + test - normal default prefix. these are "always run" tests for this procedure + spec - normal default prefix. required to run default setup/teardown calls. +*/ + +/* Support for Meta Test Rig */ +#define TEST_CASE(a) + +/* Include Passthroughs for Linking Tests */ +void putcharSpy(int c) { (void)putchar(c);} +void flushSpy(void) {} + +/* Global Variables Used During These Tests */ +int CounterSetup = 0; +int CounterTeardown = 0; +int CounterSuiteSetup = 0; + +void setUp(void) +{ + CounterSetup = 1; +} + +void tearDown(void) +{ + CounterTeardown = 1; +} + +void custom_setup(void) +{ + CounterSetup = 2; +} + +void custom_teardown(void) +{ + CounterTeardown = 2; +} + +void test_ThisTestAlwaysPasses(void) +{ + TEST_PASS(); +} + +void test_ThisTestAlwaysFails(void) +{ + TEST_FAIL_MESSAGE("This Test Should Fail"); +} + +void test_ThisTestAlwaysIgnored(void) +{ + TEST_IGNORE_MESSAGE("This Test Should Be Ignored"); +} + +void spec_ThisTestPassesWhenNormalSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterSetup, "Normal Setup Wasn't Run"); +} + +void spec_ThisTestPassesWhenNormalTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterTeardown, "Normal Teardown Wasn't Run"); +} + diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/testRunnerGeneratorWithMocks.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/testRunnerGeneratorWithMocks.c new file mode 100644 index 000000000..aaceda446 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/testdata/testRunnerGeneratorWithMocks.c @@ -0,0 +1,197 @@ +/* This Test File Is Used To Verify Many Combinations Of Using the Generate Test Runner Script */ + +#include <stdio.h> +#include "unity.h" +#include "Defs.h" +#include "mockMock.h" + +#ifdef USE_CEXCEPTION +#include "CException.h" +#endif + +/* Notes about prefixes: + test - normal default prefix. these are "always run" tests for this procedure + spec - normal default prefix. required to run default setup/teardown calls. + should - normal default prefix. + qwiktest - custom prefix for when tests skip all setup/teardown calls. + custtest - custom prefix for when tests use custom setup/teardown calls. + paratest - custom prefix for when we want to verify parameterized tests. + extest - custom prefix only used during cexception + suitetest- custom prefix for when we want to use custom suite setup/teardown +*/ + +/* Support for Meta Test Rig */ +#define TEST_CASE(a) + +/* Include Passthroughs for Linking Tests */ +void putcharSpy(int c) { (void)putchar(c);} +void flushSpy(void) {} + +/* Global Variables Used During These Tests */ +int CounterSetup = 0; +int CounterTeardown = 0; +int CounterSuiteSetup = 0; + +void setUp(void) +{ + CounterSetup = 1; +} + +void tearDown(void) +{ + CounterTeardown = 1; +} + +void custom_setup(void) +{ + CounterSetup = 2; +} + +void custom_teardown(void) +{ + CounterTeardown = 2; +} + +/* +void test_OldSchoolCommentsShouldBeIgnored(void) +{ + TEST_ASSERT_FAIL("Old-School Comments Should Be Ignored"); +} +*/ + +void test_ThisTestAlwaysPasses(void) +{ + TEST_PASS(); +} + +void test_ThisTestAlwaysFails(void) +{ + TEST_FAIL_MESSAGE("This Test Should Fail"); +} + +void test_ThisTestAlwaysIgnored(void) +{ + TEST_IGNORE_MESSAGE("This Test Should Be Ignored"); +} + +void qwiktest_ThisTestPassesWhenNoSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterSetup, "Setup Was Unexpectedly Run"); +} + +void qwiktest_ThisTestPassesWhenNoTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterTeardown, "Teardown Was Unexpectedly Run"); +} + +void spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, CounterSuiteSetup, "Suite Setup Was Unexpectedly Run"); +} + +void spec_ThisTestPassesWhenNormalSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterSetup, "Normal Setup Wasn't Run"); +} + +void spec_ThisTestPassesWhenNormalTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterTeardown, "Normal Teardown Wasn't Run"); +} + +void custtest_ThisTestPassesWhenCustomSetupRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(2, CounterSetup, "Custom Setup Wasn't Run"); +} + +void custtest_ThisTestPassesWhenCustomTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(2, CounterTeardown, "Custom Teardown Wasn't Run"); +} + +#ifndef UNITY_EXCLUDE_TESTING_NEW_COMMENTS +//void test_NewStyleCommentsShouldBeIgnored(void) +//{ +// TEST_ASSERT_FAIL("New Style Comments Should Be Ignored"); +//} +#endif + +void test_NotBeConfusedByLongComplicatedStrings(void) +{ + const char* crazyString = "GET / HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nCache-Control: no-cache\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36\r\nPostman-Token: 768c7149-c3fb-f704-71a2-63918d9195b2\r\nAccept: */*\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n"; + + TEST_ASSERT_EQUAL_STRING_MESSAGE(crazyString, crazyString, "These Strings Are The Same"); +} + +void test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings(void) +{ + TEST_ASSERT_TRUE_MESSAGE(1, "1 Should be True"); +} + +void test_StillNotBeConfusedByLongComplicatedStrings(void) +{ + const char* crazyString = "GET / HTTP/1.1\r\nHost: 127.0.0.1:8081\r\nConnection: keep-alive\r\nCache-Control: no-cache\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/46.0.2490.80 Safari/537.36\r\nPostman-Token: 768c7149-c3fb-f704-71a2-63918d9195b2\r\nAccept: */*\r\nAccept-Encoding: gzip, deflate, sdch\r\nAccept-Language: en-GB,en-US;q=0.8,en;q=0.6\r\n\r\n"; + + TEST_ASSERT_EQUAL_STRING_MESSAGE(crazyString, crazyString, "These Strings Are Still The Same"); +} + +void should_RunTestsStartingWithShouldByDefault(void) +{ + TEST_ASSERT_TRUE_MESSAGE(1, "1 Should be True"); +} + +TEST_CASE(25) +TEST_CASE(125) +TEST_CASE(5) +void paratest_ShouldHandleParameterizedTests(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(0, (Num % 5), "All The Values Are Divisible By 5"); +} + +TEST_CASE(7) +void paratest_ShouldHandleParameterizedTests2(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(7, Num, "The Only Call To This Passes"); +} + +void paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid(void) +{ + TEST_PASS(); +} + +TEST_CASE(17) +void paratest_ShouldHandleParameterizedTestsThatFail(int Num) +{ + TEST_ASSERT_EQUAL_MESSAGE(3, Num, "This call should fail"); +} + +#ifdef USE_CEXCEPTION +void extest_ShouldHandleCExceptionInTest(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CEXCEPTION_BEING_USED, "Should be pulling in CException"); +} +#endif + +#ifdef USE_ANOTHER_MAIN +int custom_main(void); + +int main(void) +{ + return custom_main(); +} +#endif + +void suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan(void) +{ + TEST_ASSERT_EQUAL_MESSAGE(1, CounterSuiteSetup, "Suite Setup Should Have Run"); +} + +void test_ShouldCallMockInitAndVerifyFunctionsForEachTest(void) +{ + int passesOrIgnores = (int)(Unity.NumberOfTests - Unity.TestFailures); + TEST_ASSERT_EQUAL_MESSAGE(Unity.NumberOfTests, mockMock_Init_Counter, "Mock Init Should Be Called Once Per Test Started"); + TEST_ASSERT_EQUAL_MESSAGE(passesOrIgnores, mockMock_Verify_Counter, "Mock Verify Should Be Called Once Per Test Passed"); + TEST_ASSERT_EQUAL_MESSAGE(Unity.NumberOfTests - 1, mockMock_Destroy_Counter, "Mock Destroy Should Be Called Once Per Test Completed"); + TEST_ASSERT_EQUAL_MESSAGE(0, CMockMemFreeFinalCounter, "Mock MemFreeFinal Should Not Be Called Until End"); +} + diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/self_assessment_utils.h b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/self_assessment_utils.h new file mode 100644 index 000000000..c8cb595db --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/self_assessment_utils.h @@ -0,0 +1,144 @@ +#ifdef TEST_INSTANCES + +#include <string.h> +#include <stdint.h> + +/* Dividing by these constants produces +/- infinity. + * The rationale is given in UnityAssertFloatIsInf's body. + */ +#ifndef UNITY_EXCLUDE_FLOAT +static const UNITY_FLOAT f_zero = 0.0f; +#endif + +#ifndef UNITY_EXCLUDE_DOUBLE +static const UNITY_DOUBLE d_zero = 0.0; +#endif + +/* Macros for Catching An Expected Failure or Ignore */ +#define EXPECT_ABORT_BEGIN \ + startPutcharSpy(); \ + if (TEST_PROTECT()) \ + { + +#define VERIFY_FAILS_END \ + } \ + endPutcharSpy(); /* start/end Spy to suppress output of failure message */ \ + Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1; \ + if (Unity.CurrentTestFailed == 1) { \ + SetToOneMeanWeAlreadyCheckedThisGuy = 1; \ + UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \ + UNITY_OUTPUT_CHAR(':'); \ + UnityPrint(Unity.CurrentTestName); \ + UnityPrint(":FAIL: [[[[ Test Should Have Failed But Did Not ]]]]"); \ + UNITY_OUTPUT_CHAR('\n'); \ + } + +#define VERIFY_IGNORES_END \ + } \ + endPutcharSpy(); /* start/end Spy to suppress output of ignore message */ \ + Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1; \ + Unity.CurrentTestIgnored = 0; \ + if (Unity.CurrentTestFailed == 1) { \ + SetToOneMeanWeAlreadyCheckedThisGuy = 1; \ + UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \ + UNITY_OUTPUT_CHAR(':'); \ + UnityPrint(Unity.CurrentTestName); \ + UnityPrint(":FAIL: [[[[ Test Should Have Ignored But Did Not ]]]]"); \ + UNITY_OUTPUT_CHAR('\n'); \ + } + +/* Tricky series of macros to set USING_OUTPUT_SPY */ +#define USING_SPY_AS(a) EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0) +#define ASSIGN_VALUE(a) VAL_##a +#define VAL_putcharSpy 0, 1 +#define EXPAND_AND_USE_2ND(a, b) SECOND_PARAM(a, b, throwaway) +#define SECOND_PARAM(a, b, ...) b +#if USING_SPY_AS(UNITY_OUTPUT_CHAR) + #define USING_OUTPUT_SPY /* true only if UNITY_OUTPUT_CHAR = putcharSpy */ +#endif + +#ifdef USING_OUTPUT_SPY +#include <stdio.h> +#define SPY_BUFFER_MAX 40 +static char putcharSpyBuffer[SPY_BUFFER_MAX]; +#endif +static int indexSpyBuffer; +static int putcharSpyEnabled; + +void startPutcharSpy(void) +{ + indexSpyBuffer = 0; + putcharSpyEnabled = 1; +} + +void endPutcharSpy(void) +{ + putcharSpyEnabled = 0; +} + +char* getBufferPutcharSpy(void) +{ +#ifdef USING_OUTPUT_SPY + putcharSpyBuffer[indexSpyBuffer] = '\0'; + return putcharSpyBuffer; +#else + return NULL; +#endif +} + +void putcharSpy(int c) +{ +#ifdef USING_OUTPUT_SPY + if (putcharSpyEnabled) + { + if (indexSpyBuffer < SPY_BUFFER_MAX - 1) + putcharSpyBuffer[indexSpyBuffer++] = (char)c; + } else + putchar((char)c); +#else + (void)c; +#endif +} + +/* This is for counting the calls to the flushSpy */ +static int flushSpyEnabled; +static int flushSpyCalls = 0; + +void startFlushSpy(void) +{ + flushSpyCalls = 0; + flushSpyEnabled = 1; +} + +void endFlushSpy(void) +{ + flushSpyCalls = 0; + flushSpyEnabled = 0; +} + +int getFlushSpyCalls(void) +{ + return flushSpyCalls; +} + +void flushSpy(void) +{ + if (flushSpyEnabled){ flushSpyCalls++; } +} + +#define TEST_ASSERT_EQUAL_PRINT_NUMBERS(expected, actual) { \ + startPutcharSpy(); UnityPrintNumber((actual)); endPutcharSpy(); \ + TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \ + } + +#define TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS(expected, actual) { \ + startPutcharSpy(); UnityPrintNumberUnsigned((actual)); endPutcharSpy(); \ + TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \ + } + +#define TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, actual) { \ + startPutcharSpy(); UnityPrintFloat((actual)); endPutcharSpy(); \ + TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \ + } + +#endif diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_generate_test_runner.rb b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_generate_test_runner.rb new file mode 100644 index 000000000..809b4494c --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_generate_test_runner.rb @@ -0,0 +1,1260 @@ +# ========================================== +# CMock Project - Automatic Mock Generation for C +# Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams +# [Released under MIT License. Please refer to license.txt for details] +# ========================================== + +require '../auto/generate_test_runner.rb' + +$generate_test_runner_tests = 0 +$generate_test_runner_failures = 0 + +OUT_FILE = 'build/testsample_' + +RUNNER_TESTS = [ + { :name => 'DefaultsThroughOptions', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => nil, #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'DefaultsThroughCommandLine', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => "", #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'DefaultsThroughYAMLFile', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => "", #defaults + :yaml => {}, #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ShorterFilterOfJustTest', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "test", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ShorterFilterOfJustShould', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "should", + }, + :expected => { + :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ShorterFilterOfJustSpec', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "spec", + }, + :expected => { + :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'InjectIncludes', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :includes => ['Defs.h'], + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ParameterizedThroughOptions', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "paratest", + :use_param_tests => true, + }, + :features => [ :parameterized ], + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'ParameterizedThroughCommandLine', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"paratest\" --use_param_tests=1", + :features => [ :parameterized ], + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'ParameterizedThroughCommandLineAndYaml', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => "--use_param_tests=1", + :yaml => { + :test_prefix => "paratest" + }, + :features => [ :parameterized ], + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'CException', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'USE_CEXCEPTION'], + :options => { + :test_prefix => "extest", + :plugins => [ :cexception ], + }, + :expected => { + :to_pass => [ 'extest_ShouldHandleCExceptionInTest' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughOptions', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "custtest|test", + :setup_name => "custom_setup", + :teardown_name => "custom_teardown", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughCommandLine', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"custtest|test\" --setup_name=\"custom_setup\" --teardown_name=\"custom_teardown\"", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughYaml', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"custtest|test\"", + :yaml => { + :setup_name => "custom_setup", + :teardown_name => "custom_teardown", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomMain', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', "USE_ANOTHER_MAIN"], + :options => { + :main_name => "custom_main", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSuiteSetupAndTeardown', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :includes => ['Defs.h'], + :options => { + :test_prefix => "suitetest|test", + :suite_setup => " CounterSuiteSetup = 1;", + :suite_teardown => " return num_failures;", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'MainExternDeclaration', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST'], + :includes => ['Defs.h'], + :options => { + :main_export_decl => "EXTERN_DECL", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + + #### WITH MOCKS ########################################## + + { :name => 'DefaultsThroughOptions', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => nil, #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'DefaultsThroughCommandLine', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => "", #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'DefaultsThroughYAMLFile', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => "", #defaults + :yaml => {}, #defaults + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ShorterFilterOfJustTest', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "test", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ShorterFilterOfJustShould', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "should", + }, + :expected => { + :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ShorterFilterOfJustSpec', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "spec", + }, + :expected => { + :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'InjectIncludes', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :includes => ['Defs.h'], + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ParameterizedThroughOptions', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "paratest", + :use_param_tests => true, + }, + :features => [ :parameterized ], + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'ParameterizedThroughCommandLine', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"paratest\" --use_param_tests=1", + :features => [ :parameterized ], + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'ParameterizedThroughCommandLineAndYaml', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => "--use_param_tests=1", + :yaml => { + :test_prefix => "paratest" + }, + :features => [ :parameterized ], + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'CException', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST', 'USE_CEXCEPTION'], + :options => { + :test_prefix => "extest", + :plugins => [ :cexception ], + }, + :expected => { + :to_pass => [ 'extest_ShouldHandleCExceptionInTest' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughOptions', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :options => { + :test_prefix => "custtest|test", + :setup_name => "custom_setup", + :teardown_name => "custom_teardown", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughCommandLine', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"custtest|test\" --setup_name=\"custom_setup\" --teardown_name=\"custom_teardown\"", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSetupAndTeardownThroughYaml', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :cmdline => " --test_prefix=\"custtest|test\"", + :yaml => { + :setup_name => "custom_setup", + :teardown_name => "custom_teardown", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'custtest_ThisTestPassesWhenCustomSetupRan', + 'custtest_ThisTestPassesWhenCustomTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomMain', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST', "USE_ANOTHER_MAIN"], + :options => { + :main_name => "custom_main", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'CustomSuiteSetupAndTeardown', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :includes => ['Defs.h'], + :options => { + :test_prefix => "suitetest|test", + :suite_setup => " CounterSuiteSetup = 1;", + :suite_teardown => " return num_failures;", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'suitetest_ThisTestPassesWhenCustomSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'MainExternDeclaration', + :testfile => 'testdata/testRunnerGeneratorWithMocks.c', + :testdefines => ['TEST'], + :includes => ['Defs.h'], + :options => { + :main_export_decl => "EXTERN_DECL", + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'test_ShouldCallMockInitAndVerifyFunctionsForEachTest', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + + + #### WITH ARGS ########################################## + + { :name => 'ArgsThroughOptions', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsThroughCommandLine', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :cmdline => "--cmdline_args=1", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsThroughYAMLFile', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :cmdline => "", + :yaml => { + :cmdline_args => true, + }, + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterJustTest', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n test_", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterJustShould', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n should_", + :expected => { + :to_pass => [ 'should_RunTestsStartingWithShouldByDefault' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsNameFilterTestAndShould', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n should_,test_", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterWithWildcardOnFile', + :testfile => 'testdata/testRunnerGeneratorSmall.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n=testRunnerGeneratorSma*", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterWithWildcardAsName', + :testfile => 'testdata/testRunnerGeneratorSmall.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGeneratorSmall:*", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterWithWildcardOnName', + :testfile => 'testdata/testRunnerGeneratorSmall.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGeneratorSmall:test_*", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterWithWildcardAndShortName', + :testfile => 'testdata/testRunnerGeneratorSmall.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGeneratorSmall:te*", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsNameFilterWithWildcardOnBoth', + :testfile => 'testdata/testRunnerGeneratorSmall.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGeneratorSm*:*", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsExcludeFilterJustTest', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-x test_", + :expected => { + :to_pass => [ 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + 'should_RunTestsStartingWithShouldByDefault', + ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeAndExcludeFilter', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + :includes => ['Defs.h'], + }, + :cmdline_args => "-n test_ -x Ignored", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeSingleTest', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n ThisTestAlwaysPasses", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeSingleTestInSpecificFile', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGenerator:ThisTestAlwaysPasses", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeTestFileWithExtension', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGenerator.c:ThisTestAlwaysPasses", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeDoubleQuotes', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n \"testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails\"", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeSingleQuotes', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n 'testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails'", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeAValidTestForADifferentFile', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n AnotherFile:ThisTestDoesNotExist", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeNoTests', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n ThisTestDoesNotExist", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsExcludeAllTests', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-x _", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeFullFile', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n testRunnerGenerator", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses', + 'spec_ThisTestPassesWhenNormalSetupRan', + 'spec_ThisTestPassesWhenNormalTeardownRan', + 'test_NotBeConfusedByLongComplicatedStrings', + 'test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings', + 'test_StillNotBeConfusedByLongComplicatedStrings', + 'should_RunTestsStartingWithShouldByDefault', + 'spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan', + ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ 'test_ThisTestAlwaysIgnored' ], + } + }, + + { :name => 'ArgsIncludeWithAlternateFlag', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-f=\"testRunnerGenerator:ThisTestAlwaysPasses,test_ThisTestAlwaysFails\"", + :expected => { + :to_pass => [ 'test_ThisTestAlwaysPasses' ], + :to_fail => [ 'test_ThisTestAlwaysFails' ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsIncludeWithParameterized', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :cmdline => "--use_param_tests=1", + :yaml => { + :cmdline_args => true, + :test_prefix => "paratest" + }, + :cmdline_args => "-n ShouldHandleParameterizedTests", + :features => [ :parameterized ], + :expected => { + :to_pass => [ 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + ], + :to_fail => [ 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' ], + :to_ignore => [ ], + } + }, + + { :name => 'ArgsList', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-l", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + :text => [ "testRunnerGenerator", + "test_ThisTestAlwaysPasses", + "test_ThisTestAlwaysFails", + "test_ThisTestAlwaysIgnored", + "spec_ThisTestPassesWhenNormalSuiteSetupAndTeardownRan", + "spec_ThisTestPassesWhenNormalSetupRan", + "spec_ThisTestPassesWhenNormalTeardownRan", + "test_NotBeConfusedByLongComplicatedStrings", + "test_NotDisappearJustBecauseTheTestBeforeAndAfterHaveCrazyStrings", + "test_StillNotBeConfusedByLongComplicatedStrings", + "should_RunTestsStartingWithShouldByDefault" + ] + } + }, + + { :name => 'ArgsListParameterized', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :test_prefix => "paratest", + :use_param_tests => true, + :cmdline_args => true, + }, + :cmdline_args => "-l", + :features => [ :parameterized ], + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + :text => [ "testRunnerGenerator", + 'paratest_ShouldHandleParameterizedTests\(25\)', + 'paratest_ShouldHandleParameterizedTests\(125\)', + 'paratest_ShouldHandleParameterizedTests\(5\)', + 'paratest_ShouldHandleParameterizedTests2\(7\)', + 'paratest_ShouldHandleNonParameterizedTestsWhenParameterizationValid', + 'paratest_ShouldHandleParameterizedTestsThatFail\(17\)' + ], + } + }, + + { :name => 'ArgsIncompleteIncludeFlags', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-n", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + :text => [ "ERROR: No Test String to Include Matches For" ], + } + }, + + { :name => 'ArgsIncompleteExcludeFlags', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-x", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + :text => [ "ERROR: No Test String to Exclude Matches For" ], + } + }, + + { :name => 'ArgsIllegalFlags', + :testfile => 'testdata/testRunnerGenerator.c', + :testdefines => ['TEST', 'UNITY_USE_COMMAND_LINE_ARGS'], + :options => { + :cmdline_args => true, + }, + :cmdline_args => "-z", + :expected => { + :to_pass => [ ], + :to_fail => [ ], + :to_ignore => [ ], + :text => [ "ERROR: Unknown Option z" ], + } + }, +] + +def runner_test(test, runner, expected, test_defines, cmdline_args, features) + # Tack on TEST define for compiling unit tests + load_configuration($cfg_file) + + # Drop Out if we're skipping this type of test + if $cfg[:skip_tests] && features + if $cfg[:skip_tests].include?(:parameterized) && features.include?(:parameterized) + report("Skipping Parameterized Tests for this Target:IGNORE") + return true + end + end + + #compile objects + obj_list = [ + compile(runner, test_defines), + compile(test, test_defines), + compile('../src/unity.c', test_defines), + ] + + # Link the test executable + test_base = File.basename(test, C_EXTENSION) + link_it(test_base, obj_list) + + # Execute unit test and generate results file + output = runtest(test_base, true, cmdline_args) + + #compare to the expected pass/fail + allgood = expected[:to_pass].inject(true) {|s,v| s && verify_match(/#{v}:PASS/, output) } + allgood = expected[:to_fail].inject(allgood) {|s,v| s && verify_match(/#{v}:FAIL/, output) } + allgood = expected[:to_ignore].inject(allgood) {|s,v| s && verify_match(/#{v}:IGNORE/, output) } + + #verify there weren't more pass/fail/etc than expected + allgood &&= verify_number( expected[:to_pass], /(:PASS)/, output) + allgood &&= verify_number( expected[:to_fail], /(:FAIL)/, output) + allgood &&= verify_number( expected[:to_ignore], /(:IGNORE)/, output) + + #if we care about any other text, check that too + if (expected[:text]) + allgood = expected[:text].inject(allgood) {|s,v| s && verify_match(/#{v}/, output) } + allgood &&= verify_number( expected[:text], /.+/, output ) + end + + report output if (!allgood && !$verbose) #report failures if not already reporting everything + return allgood +end + +def verify_match(expression, output) + if (expression =~ output) + return true + else + report " FAIL: No Match For /#{expression.to_s}/" + return false + end +end + +def verify_number(expected, expression, output) + exp = expected.length + act = output.scan(expression).length + if (exp == act) + return true + else + report " FAIL: Expected #{exp} Matches For /#{expression.to_s}/. Was #{act}" + return false + end +end + +RUNNER_TESTS.each do |testset| + basename = File.basename(testset[:testfile], C_EXTENSION) + testset_name = "Runner_#{basename}_#{testset[:name]}" + should testset_name do + runner_name = OUT_FILE + testset[:name] + '_runner.c' + + #create a yaml file first if required + yaml_option = "" + if (testset[:yaml]) + File.open("build/runner_options.yml",'w') {|f| f << { :unity => testset[:yaml] }.to_yaml } + yaml_option = "build/runner_options.yml" + end + + #run script via command line or through hash function call, as requested + if (testset[:cmdline]) + cmdstr = "ruby ../auto/generate_test_runner.rb #{yaml_option} #{testset[:cmdline]} \"#{testset[:testfile]}\" \"#{runner_name}\"" + `#{cmdstr}` + else + UnityTestRunnerGenerator.new(testset[:options]).run(testset[:testfile], runner_name) + end + + #test the script against the specified test file and check results + if (runner_test(testset[:testfile], runner_name, testset[:expected], testset[:testdefines], testset[:cmdline_args], testset[:features])) + report "#{testset_name}:PASS" + else + report "#{testset_name}:FAIL" + $generate_test_runner_failures += 1 + end + $generate_test_runner_tests += 1 + end +end + +raise "There were #{$generate_test_runner_failures.to_s} failures while testing generate_test_runner.rb" if ($generate_test_runner_failures > 0) diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_arrays.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_arrays.c new file mode 100644 index 000000000..ff90a6c42 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_arrays.c @@ -0,0 +1,2874 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include "unity.h" +#define TEST_INSTANCES +#include "self_assessment_utils.h" + +static int SetToOneToFailInTearDown; +static int SetToOneMeanWeAlreadyCheckedThisGuy; + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + endPutcharSpy(); /* Stop suppressing test output */ + if (SetToOneToFailInTearDown == 1) + { + /* These will be skipped internally if already failed/ignored */ + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + TEST_IGNORE_MESSAGE("<= Ignored in tearDown"); + } + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +void testInt64ArrayWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualSmallDelta[] = {12345001, -12344996, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + TEST_ASSERT_INT64_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, actualBigDelta, 3); +#endif +} + +void testInt64ArrayWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualSmallDelta[] = {12345001, -12344996, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); +#endif +} + +void tesUInt64ArrayNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayNotWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaPointless(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, actualBigDelta, 0); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaPointlessAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaExpectedNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaExpectedNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaActualNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaActualNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaSamePointer(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3); +#endif +} + +void testInt64ArrayWithinDeltaSamePointerAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +#endif +} + +void testIntArrayWithinDelta(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT actualSmallDelta[] = {5001, -4996, 5005}; + UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; + + TEST_ASSERT_INT_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, actualBigDelta, 3); +} + +void testIntArrayWithinDeltaAndMessage(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT actualSmallDelta[] = {5001, -4996, 5005}; + UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; + + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); +} + +void testIntArrayNotWithinDelta(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testIntArrayNotWithinDeltaAndMessage(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaPointless(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, actualBigDelta, 0); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaExpectedNull(void) +{ + UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaActualNull(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testIntArrayWithinDeltaSamePointer(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + + TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testIntArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_INT expected[] = {5000, -4995, 5005}; + + TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + +void testInt16ArrayWithinDelta(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 actualSmallDelta[] = {5001, -4996, 5005}; + UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; + + TEST_ASSERT_INT16_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, actualBigDelta, 3); +} + +void testInt16ArrayWithinDeltaAndMessage(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 actualSmallDelta[] = {5001, -4996, 5005}; + UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; + + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); +} + +void testInt16ArrayNotWithinDelta(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testInt16ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaPointless(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, actualBigDelta, 0); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaExpectedNull(void) +{ + UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaActualNull(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt16ArrayWithinDeltaSamePointer(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + + TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testInt16ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_INT16 expected[] = {5000, -4995, 5005}; + + TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + +void testInt8ArrayWithinDelta(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 actualSmallDelta[] = {21, -94, 55}; + UNITY_INT8 actualBigDelta[] = {11, -86, 45}; + + TEST_ASSERT_INT8_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, actualBigDelta, 3); +} + +void testInt8ArrayWithinDeltaAndMessage(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 actualSmallDelta[] = {21, -94, 55}; + UNITY_INT8 actualBigDelta[] = {11, -86, 45}; + + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 3, "Custom Message."); +} + +void testInt8ArrayNotWithinDelta(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testInt8ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaPointless(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, actualBigDelta, 0); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + UNITY_INT8 actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaExpectedNull(void) +{ + UNITY_INT8 actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN(11, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_INT8 actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaActualNull(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testInt8ArrayWithinDeltaSamePointer(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + + TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, expected, 3); +} + +void testInt8ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_INT8 expected[] = {20, -95, 55}; + + TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, expected, 3, "Custom Message."); +} + +void testCHARArrayWithinDelta(void) +{ + char expected[] = {20, -95, 55}; + char actualSmallDelta[] = {21, -94, 55}; + char actualBigDelta[] = {11, -86, 45}; + + TEST_ASSERT_CHAR_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_CHAR_ARRAY_WITHIN(11, expected, actualBigDelta, 3); +} + +void testCHARArrayWithinDeltaAndMessage(void) +{ + char expected[] = {20, -95, 55}; + char actualSmallDelta[] = {21, -94, 55}; + char actualBigDelta[] = {11, -86, 45}; + + TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 3, "Custom Message."); +} + +void testCHARArrayNotWithinDelta(void) +{ + char expected[] = {20, -95, 55}; + char actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_CHAR_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testCHARArrayNotWithinDeltaAndMessage(void) +{ + char expected[] = {20, -95, 55}; + char actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testCHARArrayWithinDeltaPointless(void) +{ + char expected[] = {20, -95, 55}; + char actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_CHAR_ARRAY_WITHIN(11, expected, actualBigDelta, 0); + VERIFY_FAILS_END +} + +void testCHARArrayWithinDeltaPointlessAndMessage(void) +{ + char expected[] = {20, -95, 55}; + char actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testCHARArrayWithinDeltaExpectedNull(void) +{ + char actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_CHAR_ARRAY_WITHIN(11, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testCHARArrayWithinDeltaExpectedNullAndMessage(void) +{ + char actualBigDelta[] = {11, -86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(11, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testCHARArrayWithinDeltaActualNull(void) +{ + char expected[] = {20, -95, 55}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_CHAR_ARRAY_WITHIN(11, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testCHARArrayWithinDeltaActualNullAndMessage(void) +{ + char expected[] = {20, -95, 55}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(11, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testCHARArrayWithinDeltaSamePointer(void) +{ + char expected[] = {20, -95, 55}; + + TEST_ASSERT_CHAR_ARRAY_WITHIN(11, expected, expected, 3); +} + +void testCHARArrayWithinDeltaSamePointerAndMessage(void) +{ + char expected[] = {20, -95, 55}; + + TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(11, expected, expected, 3, "Custom Message."); +} + +void testUInt64ArrayWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualSmallDelta[] = {12345001, 12344996, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, actualBigDelta, 3); +#endif +} + +void testUInt64ArrayWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualSmallDelta[] = {12345001, 12344996, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); +#endif +} + +void testUInt64ArrayNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayNotWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaPointless(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, actualBigDelta, 0); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaPointlessAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaExpectedNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaExpectedNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaActualNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaActualNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaSamePointer(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3); +#endif +} + +void testUInt64ArrayWithinDeltaSamePointerAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +#endif +} + +void testUIntArrayWithinDelta(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT actualSmallDelta[] = {125001, 124996, 125005}; + UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; + + TEST_ASSERT_UINT_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, actualBigDelta, 3); +} + +void testUIntArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT actualSmallDelta[] = {125001, 124996, 125005}; + UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; + + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); +} + +void testUIntArrayNotWithinDelta(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testUIntArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaPointless(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, actualBigDelta, 0); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaActualNull(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + + TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testUIntArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT expected[] = {125000, 124995, 125005}; + + TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + +void testUInt16ArrayWithinDelta(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 actualSmallDelta[] = {5001, 4996, 5005}; + UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; + + TEST_ASSERT_UINT16_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, actualBigDelta, 3); +} + +void testUInt16ArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 actualSmallDelta[] = {5001, 4996, 5005}; + UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; + + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); +} + +void testUInt16ArrayNotWithinDelta(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testUInt16ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaPointless(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, actualBigDelta, 0); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaActualNull(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt16ArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + + TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testUInt16ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT16 expected[] = {5000, 4995, 5005}; + + TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + +void testUInt8ArrayWithinDelta(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 actualSmallDelta[] = {21, 94, 55}; + UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; + + TEST_ASSERT_UINT8_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, actualBigDelta, 3); +} + +void testUInt8ArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 actualSmallDelta[] = {21, 94, 55}; + UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; + + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 3, "Custom Message."); +} + +void testUInt8ArrayNotWithinDelta(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testUInt8ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaPointless(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, actualBigDelta, 0); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN(11, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaActualNull(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testUInt8ArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + + TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, expected, 3); +} + +void testUInt8ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT8 expected[] = {20, 95, 55}; + + TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, expected, 3, "Custom Message."); +} + +void testHEX64ArrayWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualSmallDelta[] = {0xABCD123500000000, 0xABCD112100000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x100000000, expected, actualSmallDelta, 3); + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, actualBigDelta, 3); +#endif +} + +void testHEX64ArrayWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualSmallDelta[] = {0xABCD123500000000, 0xABCD112100000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x100000000, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, actualBigDelta, 3, "Custom Message."); +#endif +} + +void testHEX64ArrayNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x100000000, expected, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayNotWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x100000000, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaPointless(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, actualBigDelta, 0); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaPointlessAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaExpectedNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaExpectedNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaActualNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, NULL, 3); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaActualNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaSamePointer(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, expected, 3); +#endif +} + +void testHEX64ArrayWithinDeltaSamePointerAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, expected, 3, "Custom Message."); +#endif +} + +void testHEX32ArrayWithinDelta(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT actualSmallDelta[] = {0xABCD1235, 0xABCD1121, 0xABCD1277}; + UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + TEST_ASSERT_HEX32_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, actualBigDelta, 3); +} + +void testHEX32ArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT actualSmallDelta[] = {0xABCD1235, 0xABCD1121, 0xABCD1277}; + UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); +} + +void testHEX32ArrayNotWithinDelta(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX32ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaPointless(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, actualBigDelta, 0); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaActualNull(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32ArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testHEX32ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; + + TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + + +void testHEX16ArrayWithinDelta(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 actualSmallDelta[] = {0x1235, 0x1121, 0x1277}; + UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + TEST_ASSERT_HEX16_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, actualBigDelta, 3); +} + +void testHEX16ArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 actualSmallDelta[] = {0x1235, 0x1121, 0x1277}; + UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); +} + +void testHEX16ArrayNotWithinDelta(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX16ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaPointless(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, actualBigDelta, 0); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaActualNull(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX16ArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + + TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, expected, 3); +} + +void testHEX16ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; + + TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +} + +void testHEX8ArrayWithinDelta(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 actualSmallDelta[] = {0x35, 0x21, 0x77}; + UNITY_UINT8 actualBigDelta[] = {0x47, 0x48, 0x4C}; + + TEST_ASSERT_HEX8_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, actualBigDelta, 3); +} + +void testHEX8ArrayWithinDeltaAndMessage(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 actualSmallDelta[] = {0x35, 0x21, 0x77}; + UNITY_UINT8 actualBigDelta[] = {0x47, 0x48, 0x4C}; + + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, actualBigDelta, 3, "Custom Message."); +} + +void testHEX8ArrayNotWithinDelta(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX8ArrayNotWithinDeltaAndMessage(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaPointless(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, actualBigDelta, 0); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaPointlessAndMessage(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaExpectedNull(void) +{ + UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN(60, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaExpectedNullAndMessage(void) +{ + UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaActualNull(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, NULL, 3); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaActualNullAndMessage(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX8ArrayWithinDeltaSamePointer(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + + TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, expected, 3); +} + +void testHEX8ArrayWithinDeltaSamePointerAndMessage(void) +{ + UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; + + TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, expected, 3, "Custom Message."); +} + +void testEqualIntArrays(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 987, -2}; + int p2[] = {1, 8, 987, 2}; + int p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p3, 1); + TEST_ASSERT_EQUAL_INT_ARRAY(NULL, NULL, 1); +} + +void testNotEqualIntArraysNullExpected(void) +{ + int* p0 = NULL; + int p1[] = {1, 8, 987, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntArraysNullActual(void) +{ + int* p1 = NULL; + int p0[] = {1, 8, 987, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntArrays1(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 987, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntArrays2(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {2, 8, 987, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntArrays3(void) +{ + int p0[] = {1, 8, 987, -2}; + int p1[] = {1, 8, 986, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntArraysLengthZero(void) +{ + UNITY_UINT32 p0[1] = {1}; + UNITY_UINT32 p1[1] = {1}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 0); + VERIFY_FAILS_END +} + +void testEqualIntEachEqual(void) +{ + int p0[] = {1, 1, 1, 1}; + int p1[] = {987, 987, 987, 987}; + int p2[] = {-2, -2, -2, -3}; + int p3[] = {1, 5, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_INT(1, p0, 1); + TEST_ASSERT_EACH_EQUAL_INT(1, p0, 4); + TEST_ASSERT_EACH_EQUAL_INT(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_INT(-2, p2, 3); + TEST_ASSERT_EACH_EQUAL_INT(1, p3, 1); +} + +void testNotEqualIntEachEqualNullActual(void) +{ + int* p1 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT(1, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntEachEqual1(void) +{ + int p0[] = {1, 1, 1, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT(1, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntEachEqual2(void) +{ + int p0[] = {-5, -5, -1, -5}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT(-5, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualIntEachEqual3(void) +{ + int p0[] = {1, 88, 88, 88}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT(88, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualEachEqualLengthZero(void) +{ + UNITY_UINT32 p0[1] = {1}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT(0, p0, 0); + VERIFY_FAILS_END +} + +void testEqualPtrArrays(void) +{ + char A = 1; + char B = 2; + char C = 3; + char* p0[] = {&A, &B, &C}; + char* p1[] = {&A, &B, &C, &A}; + char* p2[] = {&A, &B}; + char* p3[] = {&A}; + + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 3); + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 3); + TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p2, 2); + TEST_ASSERT_EQUAL_PTR_ARRAY(p3, p0, 1); +} + +void testNotEqualPtrArraysNullExpected(void) +{ + char A = 1; + char B = 2; + char** p0 = NULL; + char* p1[] = {&A, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 2); + VERIFY_FAILS_END +} + +void testNotEqualPtrArraysNullActual(void) +{ + char A = 1; + char B = 2; + char** p0 = NULL; + char* p1[] = {&A, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p0, 2); + VERIFY_FAILS_END +} + +void testNotEqualPtrArrays1(void) +{ + char A = 1; + char B = 2; + char C = 3; + char* p0[] = {&A, &B, &C, &B}; + char* p1[] = {&A, &B, &C, &A}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualPtrArrays2(void) +{ + char A = 1; + char B = 2; + char C = 3; + char* p0[] = {&B, &B, &C, &A}; + char* p1[] = {&A, &B, &C, &A}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualPtrArrays3(void) +{ + char A = 1; + char B = 2; + char C = 3; + char* p0[] = {&A, &B, &B, &A}; + char* p1[] = {&A, &B, &C, &A}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualPtrEachEqual(void) +{ + char A = 1; + char B = 2; + char C = 3; + char* p0[] = {&A, &A, &A}; + char* p1[] = {&A, &B, &C, &A}; + char* p2[] = {&B, &B}; + char* p3[] = {&C}; + + TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 1); + TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 3); + TEST_ASSERT_EACH_EQUAL_PTR(&A, p1, 1); + TEST_ASSERT_EACH_EQUAL_PTR(&B, p2, 2); + TEST_ASSERT_EACH_EQUAL_PTR(&C, p3, 1); +} + +void testNotEqualPtrEachEqualNullExpected(void) +{ + char A = 1; + char B = 1; + char* p0[] = {&A, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 2); + VERIFY_FAILS_END +} + +void testNotEqualPtrEachEqualNullActual(void) +{ + char A = 1; + char** p0 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 2); + VERIFY_FAILS_END +} + +void testNotEqualPtrEachEqual1(void) +{ + char A = 1; + char B = 1; + char* p0[] = {&A, &A, &A, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualPtrEachEqual2(void) +{ + char A = 1; + char B = 1; + char* p0[] = {&B, &B, &A, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_PTR(&B, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualPtrEachEqual3(void) +{ + char A = 1; + char B = 1; + char* p0[] = {&A, &B, &B, &B}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_PTR(&B, p0, 4); + VERIFY_FAILS_END +} + +void testEqualInt8Arrays(void) +{ + UNITY_INT8 p0[] = {1, 8, 117, -2}; + UNITY_INT8 p1[] = {1, 8, 117, -2}; + UNITY_INT8 p2[] = {1, 8, 117, 2}; + UNITY_INT8 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p3, 1); +} + +void testNotEqualInt8Arrays(void) +{ + UNITY_INT8 p0[] = {1, 8, 36, -2}; + UNITY_INT8 p1[] = {1, 8, 36, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualInt8EachEqual(void) +{ + UNITY_INT8 p0[] = {1, 1, 1, 1}; + UNITY_INT8 p1[] = {117, 117, 117, -2}; + UNITY_INT8 p2[] = {-1, -1, 117, 2}; + UNITY_INT8 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 1); + TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 4); + TEST_ASSERT_EACH_EQUAL_INT8(117, p1, 3); + TEST_ASSERT_EACH_EQUAL_INT8(-1, p2, 2); + TEST_ASSERT_EACH_EQUAL_INT8(1, p3, 1); +} + +void testNotEqualInt8EachEqual(void) +{ + UNITY_INT8 p0[] = {1, 8, 36, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 2); + VERIFY_FAILS_END +} + +void testEqualCHARArrays(void) +{ + char p0[] = {1, 8, 117, -2}; + char p1[] = {1, 8, 117, -2}; + char p2[] = {1, 8, 117, 2}; + char p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p3, 1); +} + +void testNotEqualCHARArrays(void) +{ + char p0[] = {1, 8, 36, -2}; + char p1[] = {1, 8, 36, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualCHAREachEqual(void) +{ + char p0[] = {1, 1, 1, 1}; + char p1[] = {117, 117, 117, -2}; + char p2[] = {-1, -1, 117, 2}; + char p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EACH_EQUAL_CHAR(1, p0, 1); + TEST_ASSERT_EACH_EQUAL_CHAR(1, p0, 4); + TEST_ASSERT_EACH_EQUAL_CHAR(117, p1, 3); + TEST_ASSERT_EACH_EQUAL_CHAR(-1, p2, 2); + TEST_ASSERT_EACH_EQUAL_CHAR(1, p3, 1); +} + +void testNotEqualCHAREachEqual(void) +{ + char p0[] = {1, 8, 36, -2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_CHAR(1, p0, 2); + VERIFY_FAILS_END +} + +void testEqualUIntArrays(void) +{ + unsigned int p0[] = {1, 8, 987, 65132u}; + unsigned int p1[] = {1, 8, 987, 65132u}; + unsigned int p2[] = {1, 8, 987, 2}; + unsigned int p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p3, 1); +} + +void testNotEqualUIntArrays1(void) +{ + unsigned int p0[] = {1, 8, 987, 65132u}; + unsigned int p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUIntArrays2(void) +{ + unsigned int p0[] = {1, 8, 987, 65132u}; + unsigned int p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUIntArrays3(void) +{ + unsigned int p0[] = {1, 8, 987, 65132u}; + unsigned int p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualUIntEachEqual(void) +{ + unsigned int p0[] = {1, 1, 1, 1}; + unsigned int p1[] = {65132u, 65132u, 65132u, 65132u}; + unsigned int p2[] = {8, 8, 987, 2}; + unsigned int p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 1); + TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 4); + TEST_ASSERT_EACH_EQUAL_UINT(65132u, p1, 4); + TEST_ASSERT_EACH_EQUAL_UINT(8, p2, 2); + TEST_ASSERT_EACH_EQUAL_UINT(1, p3, 1); +} + +void testNotEqualUIntEachEqual1(void) +{ + unsigned int p0[] = {1, 65132u, 65132u, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUIntEachEqual2(void) +{ + unsigned int p0[] = {987, 8, 987, 987}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT(987, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUIntEachEqual3(void) +{ + unsigned int p0[] = {1, 1, 1, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 4); + VERIFY_FAILS_END +} + +void testEqualInt16Arrays(void) +{ + UNITY_INT16 p0[] = {1, 8, 117, 3}; + UNITY_INT16 p1[] = {1, 8, 117, 3}; + UNITY_INT16 p2[] = {1, 8, 117, 2}; + UNITY_INT16 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p3, 1); +} + +void testNotEqualInt16Arrays(void) +{ + UNITY_INT16 p0[] = {1, 8, 127, 3}; + UNITY_INT16 p1[] = {1, 8, 127, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualInt16EachEqual(void) +{ + UNITY_INT16 p0[] = {1, 1, 1, 1}; + UNITY_INT16 p1[] = {32111, 32111, 32111, 3}; + UNITY_INT16 p2[] = {-1, -1, -1, 2}; + UNITY_INT16 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EACH_EQUAL_INT16(1, p0, 1); + TEST_ASSERT_EACH_EQUAL_INT16(1, p0, 4); + TEST_ASSERT_EACH_EQUAL_INT16(32111, p1, 3); + TEST_ASSERT_EACH_EQUAL_INT16(-1, p2, 3); + TEST_ASSERT_EACH_EQUAL_INT16(1, p3, 1); +} + +void testNotEqualInt16EachEqual(void) +{ + UNITY_INT16 p0[] = {127, 127, 127, 3}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT16(127, p0, 4); + VERIFY_FAILS_END +} + +void testEqualInt32Arrays(void) +{ + UNITY_INT32 p0[] = {1, 8, 117, 3}; + UNITY_INT32 p1[] = {1, 8, 117, 3}; + UNITY_INT32 p2[] = {1, 8, 117, 2}; + UNITY_INT32 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p3, 1); +} + +void testNotEqualInt32Arrays(void) +{ + UNITY_INT32 p0[] = {1, 8, 127, 3}; + UNITY_INT32 p1[] = {1, 8, 127, 2}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualInt32EachEqual(void) +{ + UNITY_INT32 p0[] = {8, 8, 8, 8}; + UNITY_INT32 p1[] = {65537, 65537, 65537, 65537}; + UNITY_INT32 p2[] = {-3, -3, -3, 2}; + UNITY_INT32 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EACH_EQUAL_INT32(8, p0, 1); + TEST_ASSERT_EACH_EQUAL_INT32(8, p0, 4); + TEST_ASSERT_EACH_EQUAL_INT32(65537, p1, 4); + TEST_ASSERT_EACH_EQUAL_INT32(-3, p2, 3); + TEST_ASSERT_EACH_EQUAL_INT32(1, p3, 1); +} + +void testNotEqualInt32EachEqual(void) +{ + UNITY_INT32 p0[] = {127, 8, 127, 127}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_INT32(127, p0, 4); + VERIFY_FAILS_END +} + +void testEqualUINT8Arrays(void) +{ + UNITY_UINT8 p0[] = {1, 8, 100, 127}; + UNITY_UINT8 p1[] = {1, 8, 100, 127}; + UNITY_UINT8 p2[] = {1, 8, 100, 2}; + UNITY_UINT8 p3[] = {1, 50, 60, 70}; + + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p3, 1); +} + +void testNotEqualUINT8Arrays1(void) +{ + unsigned char p0[] = {1, 8, 100, 127u}; + unsigned char p1[] = {1, 8, 100, 255u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT8Arrays2(void) +{ + unsigned char p0[] = {1, 8, 100, 127u}; + unsigned char p1[] = {1, 8, 100, 255u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT8Arrays3(void) +{ + unsigned char p0[] = {1, 8, 100, 127u}; + unsigned char p1[] = {1, 8, 100, 255u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + + +void testEqualUINT16Arrays(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 987, 65132u}; + unsigned short p2[] = {1, 8, 987, 2}; + unsigned short p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p3, 1); +} + +void testNotEqualUINT16Arrays1(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT16Arrays2(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT16Arrays3(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualUINT32Arrays(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p2[] = {1, 8, 987, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p3, 1); +} + +void testNotEqualUINT32Arrays1(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT32Arrays2(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT32Arrays3(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualHEXArrays(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p2[] = {1, 8, 987, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1); +} + +void testNotEqualHEXArrays1(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEXArrays2(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEXArrays3(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualHEX32Arrays(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p2[] = {1, 8, 987, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1); +} + +void testNotEqualHEX32Arrays1(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX32Arrays2(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX32Arrays3(void) +{ + UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT32 p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualHEX16Arrays(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 987, 65132u}; + unsigned short p2[] = {1, 8, 987, 2}; + unsigned short p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p3, 1); +} + +void testNotEqualHEX16Arrays1(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX16Arrays2(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX16Arrays3(void) +{ + unsigned short p0[] = {1, 8, 987, 65132u}; + unsigned short p1[] = {1, 8, 986, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualHEX8Arrays(void) +{ + unsigned char p0[] = {1, 8, 254u, 123}; + unsigned char p1[] = {1, 8, 254u, 123}; + unsigned char p2[] = {1, 8, 254u, 2}; + unsigned char p3[] = {1, 23, 25, 26}; + + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p3, 1); +} + +void testNotEqualHEX8Arrays1(void) +{ + unsigned char p0[] = {1, 8, 254u, 253u}; + unsigned char p1[] = {1, 8, 254u, 252u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX8Arrays2(void) +{ + unsigned char p0[] = {1, 8, 254u, 253u}; + unsigned char p1[] = {2, 8, 254u, 253u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX8Arrays3(void) +{ + unsigned char p0[] = {1, 8, 254u, 253u}; + unsigned char p1[] = {1, 8, 255u, 253u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +} + +void testEqualUINT8EachEqual(void) +{ + UNITY_UINT8 p0[] = {127u, 127u, 127u, 127u}; + UNITY_UINT8 p1[] = {1u, 1u, 1u, 1u}; + UNITY_UINT8 p2[] = {128u, 128u, 128u, 2u}; + UNITY_UINT8 p3[] = {1u, 50u, 60u, 70u}; + + TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 1); + TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 4); + TEST_ASSERT_EACH_EQUAL_UINT8(1u, p1, 4); + TEST_ASSERT_EACH_EQUAL_UINT8(128u, p2, 3); + TEST_ASSERT_EACH_EQUAL_UINT8(1u, p3, 1); +} + +void testNotEqualUINT8EachEqual1(void) +{ + unsigned char p0[] = {127u, 127u, 128u, 127u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT8EachEqual2(void) +{ + unsigned char p0[] = {1, 1, 1, 127u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT8(1, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT8EachEqual3(void) +{ + unsigned char p0[] = {54u, 55u, 55u, 55u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT8(55u, p0, 4); + VERIFY_FAILS_END +} + +void testEqualUINT16EachEqual(void) +{ + unsigned short p0[] = {65132u, 65132u, 65132u, 65132u}; + unsigned short p1[] = {987, 987, 987, 987}; + unsigned short p2[] = {1, 1, 1, 2}; + unsigned short p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 1); + TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); + TEST_ASSERT_EACH_EQUAL_UINT16(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_UINT16(1, p2, 3); + TEST_ASSERT_EACH_EQUAL_UINT16(1, p3, 1); +} + +void testNotEqualUINT16EachEqual1(void) +{ + unsigned short p0[] = {1, 65132u, 65132u, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT16EachEqual2(void) +{ + unsigned short p0[] = {65132u, 65132u, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT16EachEqual3(void) +{ + unsigned short p0[] = {65132u, 65132u, 65132u, 65133u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testEqualUINT32EachEqual(void) +{ + UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u}; + UNITY_UINT32 p1[] = {987, 987, 987, 987}; + UNITY_UINT32 p2[] = {8, 8, 8, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 1); + TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 4); + TEST_ASSERT_EACH_EQUAL_UINT32(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_UINT32(8, p2, 3); + TEST_ASSERT_EACH_EQUAL_UINT32(1, p3, 1); +} + +void testNotEqualUINT32EachEqual1(void) +{ + UNITY_UINT32 p0[] = {65132u, 65132u, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT32EachEqual2(void) +{ + UNITY_UINT32 p0[] = {1, 987, 987, 987}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT32(987, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualUINT32EachEqual3(void) +{ + UNITY_UINT32 p0[] = {1, 1, 1, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_UINT32(1, p0, 4); + VERIFY_FAILS_END +} + +void testEqualHEXEachEqual(void) +{ + UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u}; + UNITY_UINT32 p1[] = {987, 987, 987, 987}; + UNITY_UINT32 p2[] = {8, 8, 8, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_HEX(65132u, p0, 1); + TEST_ASSERT_EACH_EQUAL_HEX(65132u, p0, 4); + TEST_ASSERT_EACH_EQUAL_HEX(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_HEX(8, p2, 3); + TEST_ASSERT_EACH_EQUAL_HEX(1, p3, 1); +} + +void testNotEqualHEXEachEqual1(void) +{ + UNITY_UINT32 p0[] = {1, 65132u, 65132u, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEXEachEqual2(void) +{ + UNITY_UINT32 p0[] = {987, 987, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX32(987, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEXEachEqual3(void) +{ + UNITY_UINT32 p0[] = {8, 8, 987, 8}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX(8, p0, 4); + VERIFY_FAILS_END +} + +void testEqualHEX32EachEqual(void) +{ + UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u}; + UNITY_UINT32 p1[] = {987, 987, 987, 987}; + UNITY_UINT32 p2[] = {8, 8, 8, 2}; + UNITY_UINT32 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 1); + TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4); + TEST_ASSERT_EACH_EQUAL_HEX32(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_HEX32(8, p2, 3); + TEST_ASSERT_EACH_EQUAL_HEX32(1, p3, 1); +} + +void testNotEqualHEX32EachEqual1(void) +{ + UNITY_UINT32 p0[] = {65132u, 8, 65132u, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX32EachEqual2(void) +{ + UNITY_UINT32 p0[] = {1, 987, 987, 987}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX32(987, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX32EachEqual3(void) +{ + UNITY_UINT32 p0[] = {8, 8, 8, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX32(8, p0, 4); + VERIFY_FAILS_END +} + +void testEqualHEX16EachEqual(void) +{ + UNITY_UINT16 p0[] = {65132u, 65132u, 65132u, 65132u}; + UNITY_UINT16 p1[] = {987, 987, 987, 987}; + UNITY_UINT16 p2[] = {8, 8, 8, 2}; + UNITY_UINT16 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 1); + TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 4); + TEST_ASSERT_EACH_EQUAL_HEX16(987, p1, 4); + TEST_ASSERT_EACH_EQUAL_HEX16(8, p2, 3); + TEST_ASSERT_EACH_EQUAL_HEX16(1, p3, 1); +} + +void testNotEqualHEX16EachEqual1(void) +{ + unsigned short p0[] = {65132u, 65132u, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX16EachEqual2(void) +{ + unsigned short p0[] = {1, 987, 987, 987}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX16(987, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX16EachEqual3(void) +{ + unsigned short p0[] = {8, 8, 8, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX16(8, p0, 4); + VERIFY_FAILS_END +} + +void testEqualHEX8EachEqual(void) +{ + unsigned char p0[] = {254u, 254u, 254u, 254u}; + unsigned char p1[] = {123, 123, 123, 123}; + unsigned char p2[] = {8, 8, 8, 2}; + unsigned char p3[] = {1, 23, 25, 26}; + + TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 1); + TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 4); + TEST_ASSERT_EACH_EQUAL_HEX8(123, p1, 4); + TEST_ASSERT_EACH_EQUAL_HEX8(8, p2, 3); + TEST_ASSERT_EACH_EQUAL_HEX8(1, p3, 1); +} + +void testNotEqualHEX8EachEqual1(void) +{ + unsigned char p0[] = {253u, 253u, 254u, 253u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX8(253u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX8EachEqual2(void) +{ + unsigned char p0[] = {254u, 254u, 254u, 253u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 4); + VERIFY_FAILS_END +} + +void testNotEqualHEX8EachEqual3(void) +{ + unsigned char p0[] = {1, 8, 8, 8}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_HEX8(8, p0, 4); + VERIFY_FAILS_END +} + +void testEqualHEX64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p1[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p2[] = {1, 8, 987, 2}; + UNITY_UINT64 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p3, 1); +#endif +} + +void testEqualUint64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p1[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p2[] = {1, 8, 987, 2}; + UNITY_UINT64 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p3, 1); +#endif +} + +void testEqualInt64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 p0[] = {1, 8, 987, -65132}; + UNITY_INT64 p1[] = {1, 8, 987, -65132}; + UNITY_INT64 p2[] = {1, 8, 987, -2}; + UNITY_INT64 p3[] = {1, 500, 600, 700}; + + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p3, 1); +#endif +} + + +void testNotEqualHEX64Arrays1(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualHEX64Arrays2(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p1[] = {2, 8, 987, 65132u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualUint64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; + UNITY_UINT64 p1[] = {1, 8, 987, 65131u}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualInt64Arrays(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 p0[] = {1, 8, 987, -65132}; + UNITY_INT64 p1[] = {1, 8, 987, -65131}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_core.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_core.c new file mode 100644 index 000000000..d324e8619 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_core.c @@ -0,0 +1,371 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include "unity.h" +#define TEST_INSTANCES +#include "self_assessment_utils.h" + +static int SetToOneToFailInTearDown; +static int SetToOneMeanWeAlreadyCheckedThisGuy; + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + endPutcharSpy(); /* Stop suppressing test output */ + if (SetToOneToFailInTearDown == 1) + { + /* These will be skipped internally if already failed/ignored */ + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + TEST_IGNORE_MESSAGE("<= Ignored in tearDown"); + } + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +void testUnitySizeInitializationReminder(void) +{ + /* This test ensures that sizeof(struct UNITY_STORAGE_T) doesn't change. If this + * test breaks, go look at the initialization of the Unity global variable + * in unity.c and make sure we're filling in the proper fields. */ + const char* message = "Unexpected size for UNITY_STORAGE_T struct. Please check that " + "the initialization of the Unity symbol in unity.c is " + "still correct."; + + /* Define a structure with all the same fields as `struct UNITY_STORAGE_T`. */ +#ifdef UNITY_EXCLUDE_DETAILS + struct { + const char* TestFile; + const char* CurrentTestName; + UNITY_LINE_TYPE CurrentTestLineNumber; + UNITY_COUNTER_TYPE NumberOfTests; + UNITY_COUNTER_TYPE TestFailures; + UNITY_COUNTER_TYPE TestIgnores; + UNITY_COUNTER_TYPE CurrentTestFailed; + UNITY_COUNTER_TYPE CurrentTestIgnored; +#ifdef UNITY_INCLUDE_EXEC_TIME + UNITY_TIME_TYPE CurrentTestStartTime; + UNITY_TIME_TYPE CurrentTestStopTime; +#endif +#ifndef UNITY_EXCLUDE_SETJMP_H + jmp_buf AbortFrame; +#endif + } _Expected_Unity; +#else + struct { + const char* TestFile; + const char* CurrentTestName; + const char* CurrentDetails1; + const char* CurrentDetails2; + UNITY_LINE_TYPE CurrentTestLineNumber; + UNITY_COUNTER_TYPE NumberOfTests; + UNITY_COUNTER_TYPE TestFailures; + UNITY_COUNTER_TYPE TestIgnores; + UNITY_COUNTER_TYPE CurrentTestFailed; + UNITY_COUNTER_TYPE CurrentTestIgnored; +#ifdef UNITY_INCLUDE_EXEC_TIME + UNITY_COUNTER_TYPE CurrentTestStartTime; + UNITY_COUNTER_TYPE CurrentTestStopTime; +#endif +#ifndef UNITY_EXCLUDE_SETJMP_H + jmp_buf AbortFrame; +#endif + } _Expected_Unity; +#endif + + /* Compare our fake structure's size to the actual structure's size. They + * should be the same. + * + * This accounts for alignment, padding, and packing issues that might come + * up between different architectures. */ + TEST_ASSERT_EQUAL_MESSAGE(sizeof(_Expected_Unity), sizeof(Unity), message); +} + +void testPassShouldEndImmediatelyWithPass(void) +{ + TEST_PASS(); + TEST_FAIL_MESSAGE("We should have passed already and finished this test"); +} + +void testPassShouldEndImmediatelyWithPassAndMessage(void) +{ + TEST_PASS_MESSAGE("Woohoo! This Automatically Passes!"); + TEST_FAIL_MESSAGE("We should have passed already and finished this test"); +} + +void testMessageShouldDisplayMessageWithoutEndingAndGoOnToPass(void) +{ + TEST_MESSAGE("This is just a message"); + TEST_MESSAGE("This is another message"); + TEST_PASS(); +} + +void testMessageShouldDisplayMessageWithoutEndingAndGoOnToFail(void) +{ + TEST_MESSAGE("This is yet another message"); + + EXPECT_ABORT_BEGIN + TEST_FAIL(); + VERIFY_FAILS_END +} + +void testTrue(void) +{ + TEST_ASSERT(1); + + TEST_ASSERT_TRUE(1); +} + +void testFalse(void) +{ + TEST_ASSERT_FALSE(0); + + TEST_ASSERT_UNLESS(0); +} + +void testSingleStatement(void) +{ + for(int i = 0; i < 2; i++) + { + /* TEST_ASSERT_TRUE should expand to a single C statement, minus + * the semicolon. This if-else will fail to compile otherwise. */ + if(i > 0) + TEST_ASSERT_TRUE(i); + else + TEST_ASSERT_FALSE(i); + } +} + +void testPreviousPass(void) +{ + TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures); +} + +void testNotVanilla(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT(0); + VERIFY_FAILS_END +} + +void testNotTrue(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_TRUE(0); + VERIFY_FAILS_END +} + +void testNotFalse(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_FALSE(1); + VERIFY_FAILS_END +} + +void testNotUnless(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UNLESS(1); + VERIFY_FAILS_END +} + +void testNotNotEqual(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL(10, 10); + VERIFY_FAILS_END +} + +void testFail(void) +{ + EXPECT_ABORT_BEGIN + TEST_FAIL_MESSAGE("Expected for testing"); + VERIFY_FAILS_END +} + +void testIsNull(void) +{ + char* ptr1 = NULL; + const char* ptr2 = "hello"; + + TEST_ASSERT_NULL(ptr1); + TEST_ASSERT_NOT_NULL(ptr2); +} + +void testIsNullShouldFailIfNot(void) +{ + const char* ptr1 = "hello"; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_NULL(ptr1); + VERIFY_FAILS_END +} + +void testNotNullShouldFailIfNULL(void) +{ + char* ptr1 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_NULL(ptr1); + VERIFY_FAILS_END +} + +void testIsEmpty(void) +{ + const char* ptr1 = "\0"; + const char* ptr2 = "hello"; + + TEST_ASSERT_EMPTY(ptr1); + TEST_ASSERT_NOT_EMPTY(ptr2); +} + +void testIsEmptyShouldFailIfNot(void) +{ + const char* ptr1 = "hello"; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EMPTY(ptr1); + VERIFY_FAILS_END +} + +void testNotEmptyShouldFailIfEmpty(void) +{ + const char* ptr1 = "\0"; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EMPTY(ptr1); + VERIFY_FAILS_END +} + +void testIgnore(void) +{ + EXPECT_ABORT_BEGIN + TEST_IGNORE(); + TEST_FAIL_MESSAGE("This should not be reached"); + VERIFY_IGNORES_END +} + +void testIgnoreMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_IGNORE_MESSAGE("This is an expected TEST_IGNORE_MESSAGE string!"); + TEST_FAIL_MESSAGE("This should not be reached"); + VERIFY_IGNORES_END +} + +void testProtection(void) +{ + volatile int mask = 0; + + if (TEST_PROTECT()) + { + mask |= 1; + TEST_ABORT(); + } + else + { + Unity.CurrentTestFailed = 0; + mask |= 2; + } + + TEST_ASSERT_EQUAL(3, mask); +} + +void testIgnoredAndThenFailInTearDown(void) +{ + SetToOneToFailInTearDown = 1; + TEST_IGNORE(); +} + +void testFailureCountIncrementsAndIsReturnedAtEnd(void) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + UNITY_UINT savedFailures = Unity.TestFailures; + Unity.CurrentTestFailed = 1; + startPutcharSpy(); /* Suppress output */ + startFlushSpy(); + TEST_ASSERT_EQUAL(0, getFlushSpyCalls()); + UnityConcludeTest(); + endPutcharSpy(); + TEST_ASSERT_EQUAL(savedFailures + 1, Unity.TestFailures); +#if defined(UNITY_OUTPUT_FLUSH) && defined(UNITY_OUTPUT_FLUSH_HEADER_DECLARATION) + TEST_ASSERT_EQUAL(1, getFlushSpyCalls()); +#else + TEST_ASSERT_EQUAL(0, getFlushSpyCalls()); +#endif + endFlushSpy(); + + startPutcharSpy(); /* Suppress output */ + int failures = UnityEnd(); + Unity.TestFailures--; + endPutcharSpy(); + TEST_ASSERT_EQUAL(savedFailures + 1, failures); +#endif +} + +/* ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DETAIL SUPPORT ================== */ + +void testThatDetailsCanBeHandleOneDetail(void) +{ +#ifdef UNITY_EXCLUDE_DETAILS + TEST_IGNORE(); +#else + UNITY_SET_DETAIL("Detail1"); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT_MESSAGE(5, 6, "Should Fail And Say Detail1"); + VERIFY_FAILS_END +#endif +} + +void testThatDetailsCanHandleTestFail(void) +{ +#ifdef UNITY_EXCLUDE_DETAILS + TEST_IGNORE(); +#else + UNITY_SET_DETAILS("Detail1","Detail2"); + + EXPECT_ABORT_BEGIN + TEST_FAIL_MESSAGE("Should Fail And Say Detail1 and Detail2"); + VERIFY_FAILS_END +#endif +} + +void testThatDetailsCanBeHandleTwoDetails(void) +{ +#ifdef UNITY_EXCLUDE_DETAILS + TEST_IGNORE(); +#else + UNITY_SET_DETAILS("Detail1","Detail2"); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8_MESSAGE(7, 8, "Should Fail And Say Detail1 and Detail2"); + VERIFY_FAILS_END +#endif +} + +void testThatDetailsCanBeHandleSingleDetailClearingTwoDetails(void) +{ +#ifdef UNITY_EXCLUDE_DETAILS + TEST_IGNORE(); +#else + UNITY_SET_DETAILS("Detail1","Detail2"); + UNITY_SET_DETAIL("DetailNew"); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_MESSAGE("MEH", "GUH", "Should Fail And Say DetailNew"); + VERIFY_FAILS_END +#endif +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_doubles.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_doubles.c new file mode 100644 index 000000000..1bdedbc33 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_doubles.c @@ -0,0 +1,773 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include "unity.h" +#define TEST_INSTANCES +#include "self_assessment_utils.h" + +static int SetToOneToFailInTearDown; +static int SetToOneMeanWeAlreadyCheckedThisGuy; + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + endPutcharSpy(); /* Stop suppressing test output */ + if (SetToOneToFailInTearDown == 1) + { + /* These will be skipped internally if already failed/ignored */ + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + TEST_IGNORE_MESSAGE("<= Ignored in tearDown"); + } + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +void testDoublesWithinDelta(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_WITHIN(0.00003, 187245.03485, 187245.03488); + TEST_ASSERT_DOUBLE_WITHIN(1.0, 187245.0, 187246.0); + TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2549, 9273.2049); + TEST_ASSERT_DOUBLE_WITHIN(0.007, -726.93725, -726.94424); +#endif +} + +void testDoublesNotWithinDelta(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2649, 9273.2049); + VERIFY_FAILS_END +#endif +} + + +void testDoublesEqual(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_DOUBLE(187245123456.0, 187245123456.0); + TEST_ASSERT_EQUAL_DOUBLE(187241234567.5, 187241234567.6); + TEST_ASSERT_EQUAL_DOUBLE(9273.2512345649, 9273.25123455699); + TEST_ASSERT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374); +#endif +} + +void testDoublesNotEqual(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(9273.9649, 9273.0049); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualNegative1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(-9273.9649, -9273.0049); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualNegative2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(-9273.0049, -9273.9649); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualActualNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(85.963, 0.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualExpectedNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 85.963); + VERIFY_FAILS_END +#endif +} + +void testDoublesEqualBothNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero); +#endif +} + +void testDoublesNotEqualInfNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualNaNInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualActualInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(321.642, 1.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoublesNotEqualExpectedInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 321.642); + VERIFY_FAILS_END +#endif +} + +void testDoublesEqualBothInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero); +#endif +} + +void testDoublesNotEqualPlusMinusInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsPosInf1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_INF(2.0 / d_zero); +#endif +} + +void testDoubleIsPosInf2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNegInf1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_NEG_INF(-3.0 / d_zero); +#endif +} + +void testDoubleIsNegInf2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(-3.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNotPosInf1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_INF(2.0); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNotPosInf2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0); +#endif +} + +void testDoubleIsNotNegInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NEG_INF(-999.876); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNan1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_NAN(0.0 / d_zero); +#endif +} + +void testDoubleIsNan2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NOT_NAN(0.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNotNan1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NAN(234.9); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNotNan2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_NOT_NAN(234.9); +#endif +} + +void testDoubleInfIsNotNan(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NAN(1.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleNanIsNotInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_INF(0.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsDeterminate1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_DETERMINATE(0.0); + TEST_ASSERT_DOUBLE_IS_DETERMINATE(123.3); + TEST_ASSERT_DOUBLE_IS_DETERMINATE(-88.3); +#endif +} + +void testDoubleIsDeterminate2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-88.3); + VERIFY_FAILS_END +#endif +} + +void testDoubleIsNotDeterminate1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(1.0 / d_zero); + TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-1.0 / d_zero); + TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(0.0 / d_zero); +#endif +} + +void testDoubleIsNotDeterminate2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_IS_DETERMINATE(-1.0 / d_zero); + VERIFY_FAILS_END +#endif +} + +void testDoubleTraitFailsOnInvalidTrait(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + UnityAssertDoubleSpecial(1.0, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT); + VERIFY_FAILS_END +#endif +} + +void testEqualDoubleArrays(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, -8.0, 25.4, -0.123}; + double p1[] = {1.0, -8.0, 25.4, -0.123}; + double p2[] = {1.0, -8.0, 25.4, -0.2}; + double p3[] = {1.0, -23.0, 25.0, -0.26}; + + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p3, 1); + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(NULL, NULL, 1); +#endif +} + +void testNotEqualDoubleArraysExpectedNull(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double* p0 = NULL; + double p1[] = {1.0, 8.0, 25.4, 0.252}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArraysActualNull(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 8.0, 25.4, 0.253}; + double* p1 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArrays1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 8.0, 25.4, 0.25666666667}; + double p1[] = {1.0, 8.0, 25.4, 0.25666666666}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArrays2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 8.0, 25.4, 0.253}; + double p1[] = {2.0, 8.0, 25.4, 0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArrays3(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 8.0, 25.4, 0.253}; + double p1[] = {1.0, 8.0, 25.5, 0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArraysNegative1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-1.0, -8.0, -25.4, -0.2566666667}; + double p1[] = {-1.0, -8.0, -25.4, -0.2566666666}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArraysNegative2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-1.0, -8.0, -25.4, -0.253}; + double p1[] = {-2.0, -8.0, -25.4, -0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleArraysNegative3(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-1.0, -8.0, -25.4, -0.253}; + double p1[] = {-1.0, -8.0, -25.5, -0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testEqualDoubleArraysNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 0.0 / d_zero, 25.4, 0.253}; + double p1[] = {1.0, 0.0 / d_zero, 25.4, 0.253}; + + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); +#endif +} + +void testEqualDoubleArraysInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 1.0 / d_zero, 25.4, 0.253}; + double p1[] = {1.0, 1.0 / d_zero, 25.4, 0.253}; + + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); +#endif +} + +void testNotEqualDoubleArraysLengthZero(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[1] = {0.0}; + double p1[1] = {0.0}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 0); + VERIFY_FAILS_END +#endif +} + +void testEqualDoubleEachEqual(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 1.0, 1.0, 1.0}; + double p1[] = {-0.123, -0.123, -0.123, -0.123}; + double p2[] = {25.4, 25.4, 25.4, -0.2}; + double p3[] = {1.0, -23.0, 25.0, -0.26}; + + TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 1); + TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4); + TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.123, p1, 4); + TEST_ASSERT_EACH_EQUAL_DOUBLE(25.4, p2, 3); + TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p3, 1); +#endif +} + +void testNotEqualDoubleEachEqualActualNull(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double* p0 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(5, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqual1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {0.253, 8.0, 0.253, 0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(0.253, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqual2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {8.0, 8.0, 8.0, 0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(8.0, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqual3(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, 1.0, 1.0, 0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqualNegative1(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-1.0, -0.253, -0.253, -0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.253, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqualNegative2(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-25.4, -8.0, -25.4, -25.4}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(-25.4, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualDoubleEachEqualNegative3(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-8.0, -8.0, -8.0, -0.253}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(-8.0, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testEqualDoubleEachEqualNaN(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero}; + + TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0 / d_zero, p0, 4); +#endif +} + +void testEqualDoubleEachEqualInf(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0 / d_zero, 1.0 / d_zero, 25.4, 0.253}; + + TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0 / d_zero, p0, 2); +#endif +} + +void testNotEqualDoubleEachEqualLengthZero(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[1] = {0.0}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0, p0, 0); + VERIFY_FAILS_END +#endif +} + +void testDoublePrinting(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499); + TEST_ASSERT_EQUAL_PRINT_FLOATING("5.0000005e-07", 0.00000050000005); + TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469499", 0.100469499); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 0.9999999995); /*Rounding to int place*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25); + TEST_ASSERT_EQUAL_PRINT_FLOATING("7.99999999", 7.99999999); /*Not rounding*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000002", 16.0000002); + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000004", 16.0000004); + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000006", 16.0000006); + TEST_ASSERT_EQUAL_PRINT_FLOATING("999999999", 999999999.0); /*Last full print integer*/ + + TEST_ASSERT_EQUAL_PRINT_FLOATING("0", -0.0); /* -0 no supported on all targets */ + TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-5.0000005e-07", -0.00000050000005); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469499", -0.100469499); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -0.9999999995); /*Rounding to int place*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.99999999", -7.99999999); /*Not rounding*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000002", -16.0000002); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000004", -16.0000004); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000006", -16.0000006); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-999999999", -999999999.0); /*Last full print integer*/ + + TEST_ASSERT_EQUAL_PRINT_FLOATING("0.1004695", 0.10046949999999999); + TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967295.9); + TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967296.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 9999999995.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199254740990.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("7e+100", 7.0e+100); + TEST_ASSERT_EQUAL_PRINT_FLOATING("3e+200", 3.0e+200); + TEST_ASSERT_EQUAL_PRINT_FLOATING("9.23456789e+300", 9.23456789e+300); + + TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.1004695", -0.10046949999999999); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967295.9); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967296.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-7e+100", -7.0e+100); +#endif +} + +void testDoublePrintingRoundTiesToEven(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + #ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00000001e+10", 10000000050.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199245000000.0); + #else /* Default to Round ties to even */ + TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000050.0); + TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719924e+15", 9007199245000000.0); + #endif +#endif +} + +void testDoublePrintingInfinityAndNaN(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0 / d_zero); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0 / d_zero); + + TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0 / d_zero); +#endif +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_floats.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_floats.c new file mode 100644 index 000000000..e89bec20e --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_floats.c @@ -0,0 +1,884 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include "unity.h" +#define TEST_INSTANCES +#include "self_assessment_utils.h" + +static int SetToOneToFailInTearDown; +static int SetToOneMeanWeAlreadyCheckedThisGuy; + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + endPutcharSpy(); /* Stop suppressing test output */ + if (SetToOneToFailInTearDown == 1) + { + /* These will be skipped internally if already failed/ignored */ + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + TEST_IGNORE_MESSAGE("<= Ignored in tearDown"); + } + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +void testFloatsWithinDelta(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f); + TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f); + TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f); + TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f); +#endif +} + +void testFloatsNotWithinDelta(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f); + VERIFY_FAILS_END +#endif +} + +void testFloatsEqual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f); + TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f); + TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f); + TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f); +#endif +} + +void testFloatsNotEqual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualNegative1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualNegative2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualActualNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(85.963f, 0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualExpectedNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 85.963f); + VERIFY_FAILS_END +#endif +} + +void testFloatsEqualBothNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); +#endif +} + +void testFloatsNotEqualInfNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualNaNInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualActualInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(321.642f, 1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotEqualExpectedInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 321.642f); + VERIFY_FAILS_END +#endif +} + +void testFloatsEqualBothInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); +#endif +} + +void testFloatsNotEqualPlusMinusInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatIsPosInf1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_INF(2.0f / f_zero); +#endif +} + +void testFloatIsPosInf2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNegInf1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_NEG_INF(-3.0f / f_zero); +#endif +} + +void testFloatIsNegInf2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(-3.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNotPosInf1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_INF(2.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNotPosInf2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f); +#endif +} + +void testFloatIsNotNegInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NEG_INF(-999.876f); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNan1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_NAN(0.0f / f_zero); +#endif +} + +void testFloatIsNan2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NOT_NAN(0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNotNan1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NAN(234.9f); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNotNan2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_NOT_NAN(234.9f); +#endif +} + +void testFloatInfIsNotNan(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NAN(1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatNanIsNotInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_INF(0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatIsDeterminate1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_DETERMINATE(0.0f); + TEST_ASSERT_FLOAT_IS_DETERMINATE(123.3f); + TEST_ASSERT_FLOAT_IS_DETERMINATE(-88.3f); +#endif +} + +void testFloatIsDeterminate2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-88.3f); + VERIFY_FAILS_END +#endif +} + +void testFloatIsNotDeterminate1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(1.0f / f_zero); + TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-1.0f / f_zero); + TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(0.0f / f_zero); +#endif +} + +void testFloatIsNotDeterminate2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_IS_DETERMINATE(-1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatTraitFailsOnInvalidTrait(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + UnityAssertFloatSpecial(1.0f, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT); + VERIFY_FAILS_END +#endif +} + +void testEqualFloatArrays(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, -8.0f, 25.4f, -0.123f}; + float p1[] = {1.0f, -8.0f, 25.4f, -0.123f}; + float p2[] = {1.0f, -8.0f, 25.4f, -0.2f}; + float p3[] = {1.0f, -23.0f, 25.0f, -0.26f}; + + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 1); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 4); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p2, 3); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p3, 1); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(NULL, NULL, 1); +#endif +} + +void testNotEqualFloatArraysExpectedNull(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float* p0 = NULL; + float p1[] = {1.0f, 8.0f, 25.4f, 0.252f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArraysActualNull(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; + float* p1 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArrays1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; + float p1[] = {1.0f, 8.0f, 25.4f, 0.252f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArrays2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; + float p1[] = {2.0f, 8.0f, 25.4f, 0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArrays3(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; + float p1[] = {1.0f, 8.0f, 25.5f, 0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArraysNegative1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; + float p1[] = {-1.0f, -8.0f, -25.4f, -0.252f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArraysNegative2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; + float p1[] = {-2.0f, -8.0f, -25.4f, -0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatArraysNegative3(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; + float p1[] = {-1.0f, -8.0f, -25.5f, -0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); + VERIFY_FAILS_END +#endif +} + +void testEqualFloatArraysNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f}; + float p1[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f}; + + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); +#endif +} + +void testEqualFloatArraysInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f}; + float p1[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f}; + + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); +#endif +} + +void testNotEqualFloatArraysLengthZero(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[1] = {0.0f}; + float p1[1] = {0.0f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 0); + VERIFY_FAILS_END +#endif +} + +void testEqualFloatEachEqual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 1.0f, 1.0f, 1.0f}; + float p1[] = {-0.123f, -0.123f, -0.123f, -0.123f}; + float p2[] = {25.4f, 25.4f, 25.4f, -0.2f}; + float p3[] = {1.0f, -23.0f, 25.0f, -0.26f}; + + TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 1); + TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4); + TEST_ASSERT_EACH_EQUAL_FLOAT(-0.123f, p1, 4); + TEST_ASSERT_EACH_EQUAL_FLOAT(25.4f, p2, 3); + TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p3, 1); +#endif +} + +void testNotEqualFloatEachEqualActualNull(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float* p0 = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(5, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqual1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {0.253f, 8.0f, 0.253f, 0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(0.253f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqual2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {8.0f, 8.0f, 8.0f, 0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(8.0f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqual3(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, 1.0f, 1.0f, 0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqualNegative1(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-1.0f, -0.253f, -0.253f, -0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(-0.253f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqualNegative2(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-25.4f, -8.0f, -25.4f, -25.4f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(-25.4f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testNotEqualFloatEachEqualNegative3(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {-8.0f, -8.0f, -8.0f, -0.253f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(-8.0f, p0, 4); + VERIFY_FAILS_END +#endif +} + +void testEqualFloatEachEqualNaN(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero}; + + TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f / f_zero, p0, 4); +#endif +} + +void testEqualFloatEachEqualInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f / f_zero, 1.0f / f_zero, 25.4f, 0.253f}; + + TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f / f_zero, p0, 2); +#endif +} + +void testNotEqualFloatEachEqualLengthZero(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[1] = {0.0f}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f, p0, 0); + VERIFY_FAILS_END +#endif +} + +void testFloatPrinting(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_INCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("0.1004695", 0.100469499f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("2", 1.9999995f); /*Rounding to int place*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("7.999999", 7.999999f); /*Not rounding*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00002", 16.00002f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00004", 16.00004f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00006", 16.00006f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("9999999", 9999999.0f); /*Last full print integer*/ + + TEST_ASSERT_EQUAL_PRINT_FLOATING("-0", -0.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.1004695", -0.100469499f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-2", -1.9999995f); /*Rounding to int place*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.999999", -7.999999f); /*Not rounding*/ + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00002", -16.00002f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00004", -16.00004f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00006", -16.00006f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-9999999", -9999999.0f); /*Last full print integer*/ + + /* Fails, prints "4.294968e+09" due to FP math imprecision + * TEST_ASSERT_EQUAL_PRINT_FLOATING("4.294967e+09", 4294967296.0f); */ + TEST_ASSERT_EQUAL_PRINT_FLOATING("5e+09", 5000000000.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("8e+09", 8.0e+09f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("8.309999e+09", 8309999104.0f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 1.0e+10f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000000.0f); + /* Some compilers have trouble with inexact float constants, a float cast works generally */ + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.000055e+10", (float)1.000055e+10f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.1e+38", (float)1.10000005e+38f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("1.635299e+10", 1.63529943e+10f); + /* Fails, prints "3.402824e+38" due to FP math imprecision + * TEST_ASSERT_EQUAL_PRINT_FLOATING("3.402823e+38", 3.40282346638e38f); */ + + TEST_ASSERT_EQUAL_PRINT_FLOATING("-1e+10", -1.0e+10f); + /* Fails, prints "-3.402824e+38" due to FP math imprecision + * TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.402823e+38", -3.40282346638e38f); */ +#endif +} + +void testFloatPrintingRoundTiesToEven(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_INCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + #ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO + TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0004882813", 0.00048828125f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("488281.3", 488281.25f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("5.000001e-07", 0.00000050000005f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-5.000001e-07", -0.00000050000005f); + #else /* Default to Round ties to even */ + TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0004882812", 0.00048828125f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("488281.2", 488281.25f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("5e-07", 0.00000050000005f); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-5e-07", -0.00000050000005f); + #endif +#endif +} + +void testFloatPrintingInfinityAndNaN(void) +{ +#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0f / f_zero); + TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0f / f_zero); + + TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0f / f_zero); +#endif +} + +#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY) +#ifdef UNITY_INCLUDE_DOUBLE +static void printFloatValue(float f) +{ + char expected[18]; + + startPutcharSpy(); + UnityPrintFloat(f); + + sprintf(expected, "%.9g", f); + /* We print all NaN's as "nan", not "-nan" */ + if (strcmp(expected, "-nan") == 0) strcpy(expected, "nan"); + + if (strcmp(expected, getBufferPutcharSpy())) + { + /* Fail with diagnostic printing */ + TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f); + } +} +#else +static void printFloatValue(float f) +{ + char expected[18]; + char expected_lower[18]; + char expected_lower2[18]; + char expected_lower3[18]; + char expected_higher[18]; + char expected_higher2[18]; + char expected_higher3[18]; + + startPutcharSpy(); + UnityPrintFloat(f); + + sprintf(expected, "%.7g", f); + /* We print all NaN's as "nan", not "-nan" */ + if (strcmp(expected, "-nan") == 0) strcpy(expected, "nan"); + + strcpy(expected_lower, expected); + strcpy(expected_lower2, expected); + strcpy(expected_lower3, expected); + strcpy(expected_higher, expected); + strcpy(expected_higher2, expected); + strcpy(expected_higher3, expected); + + /* Allow for rounding differences in the last digit */ + double lower = (double)f * 0.99999995; + double higher = (double)f * 1.00000005; + + if(isfinite(lower)) sprintf(expected_lower, "%.7g", lower); + if(isfinite(higher)) sprintf(expected_higher, "%.7g", higher); + + /* Outside [1,10000000] allow for relative error of +/-2.5e-7 */ + if (f < 1.0 || f > 10000000) + { + double lower2 = (double)f * 0.99999985; + double lower3 = (double)f * 0.99999975; + double higher2 = (double)f * 1.00000015; + double higher3 = (double)f * 1.00000025; + + if (isfinite(lower2)) sprintf(expected_lower2, "%.7g", lower2); + if (isfinite(lower3)) sprintf(expected_lower3, "%.7g", lower3); + if (isfinite(higher2)) sprintf(expected_higher2, "%.7g", higher2); + if (isfinite(higher3)) sprintf(expected_higher3, "%.7g", higher3); + } + + if (strcmp(expected, getBufferPutcharSpy()) != 0 && + strcmp(expected_lower, getBufferPutcharSpy()) != 0 && + strcmp(expected_lower2, getBufferPutcharSpy()) != 0 && + strcmp(expected_lower3, getBufferPutcharSpy()) != 0 && + strcmp(expected_higher, getBufferPutcharSpy()) != 0 && + strcmp(expected_higher2, getBufferPutcharSpy()) != 0 && + strcmp(expected_higher3, getBufferPutcharSpy()) != 0) + { + /* Fail with diagnostic printing */ + TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f); + } +} +#endif +#endif + +void testFloatPrintingRandomSamples(void) +{ +#if !defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) || !defined(USING_OUTPUT_SPY) + TEST_IGNORE(); +#else + union { float f_value; uint32_t int_value; } u; + + /* These values are not covered by the MINSTD generator */ + u.int_value = 0x00000000; printFloatValue(u.f_value); + u.int_value = 0x80000000; printFloatValue(u.f_value); + u.int_value = 0x7fffffff; printFloatValue(u.f_value); + u.int_value = 0xffffffff; printFloatValue(u.f_value); + + uint32_t a = 1; + for(int num_tested = 0; num_tested < 1000000; num_tested++) + { + /* MINSTD pseudo-random number generator */ + a = (uint32_t)(((uint64_t)a * 48271u) % 2147483647u); + + /* MINSTD does not set the highest bit; test both possibilities */ + u.int_value = a; printFloatValue(u.f_value); + u.int_value = a | 0x80000000; printFloatValue(u.f_value); + } +#endif +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_integers.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_integers.c new file mode 100644 index 000000000..7bdfa1442 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_integers.c @@ -0,0 +1,2847 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include "unity.h" +#define TEST_INSTANCES +#include "self_assessment_utils.h" + +static int SetToOneToFailInTearDown; +static int SetToOneMeanWeAlreadyCheckedThisGuy; + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + endPutcharSpy(); /* Stop suppressing test output */ + if (SetToOneToFailInTearDown == 1) + { + /* These will be skipped internally if already failed/ignored */ + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + TEST_IGNORE_MESSAGE("<= Ignored in tearDown"); + } + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +void testNotEqualInts(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT(3982, 3983); + VERIFY_FAILS_END +} + +void testNotEqualInt8s(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT8(-127, -126); + VERIFY_FAILS_END +} + +void testNotEqualChars(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_CHAR('A', 'a'); + VERIFY_FAILS_END +} + +void testNotEqualInt16s(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT16(-16383, -16382); + VERIFY_FAILS_END +} + +void testNotEqualInt32s(void) +{ + EXPECT_ABORT_BEGIN + /*use largest 32 bit negative to test printability*/ + /*note: (-2147483647 - 1) is used instead of -2147483648 because of C90 casting rules */ + TEST_ASSERT_EQUAL_INT32(-2147483647, (-2147483647 - 1)); + VERIFY_FAILS_END +} + +void testNotEqualBits(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_BITS(0xFF00, 0x5555, 0x5A55); + VERIFY_FAILS_END +} + +void testNotEqualUInts(void) +{ + UNITY_UINT16 v0, v1; + + v0 = 9000; + v1 = 9001; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualUInt8s(void) +{ + UNITY_UINT8 v0, v1; + + v0 = 254; + v1 = 255; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT8(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualUInt16s(void) +{ + UNITY_UINT16 v0, v1; + + v0 = 65535u; + v1 = 65534u; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT16(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualUInt32s(void) +{ + UNITY_UINT32 v0, v1; + + v0 = 4294967295u; + v1 = 4294967294u; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT32(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex8s(void) +{ + UNITY_UINT8 v0, v1; + + v0 = 0x23; + v1 = 0x22; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex8sIfSigned(void) +{ + UNITY_INT8 v0, v1; + + v0 = -2; + v1 = 2; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX8(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex16s(void) +{ + UNITY_UINT16 v0, v1; + + v0 = 0x1234; + v1 = 0x1235; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex16sIfSigned(void) +{ + UNITY_INT16 v0, v1; + + v0 = -1024; + v1 = -1028; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX16(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex32s(void) +{ + UNITY_UINT32 v0, v1; + + v0 = 900000; + v1 = 900001; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32(v0, v1); + VERIFY_FAILS_END +} + +void testNotEqualHex32sIfSigned(void) +{ + UNITY_INT32 v0, v1; + + v0 = -900000; + v1 = 900001; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX32(v0, v1); + VERIFY_FAILS_END +} + +void testEqualInts(void) +{ + int v0, v1; + int *p0, *p1; + + v0 = 19467; + v1 = 19467; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT(1837, 1837); + TEST_ASSERT_EQUAL_INT(-27365, -27365); + TEST_ASSERT_EQUAL_INT(v0, v1); + TEST_ASSERT_EQUAL_INT(19467, v1); + TEST_ASSERT_EQUAL_INT(v0, 19467); + TEST_ASSERT_EQUAL_INT(*p0, v1); + TEST_ASSERT_EQUAL_INT(*p0, *p1); + TEST_ASSERT_EQUAL_INT(*p0, 19467); +} + +void testEqualInt8s(void) +{ + UNITY_INT8 v0, v1; + UNITY_INT8 *p0, *p1; + + v0 = 0x22; + v1 = 0x22; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT8(0x22, 0x22); + TEST_ASSERT_EQUAL_INT8(v0, v1); + TEST_ASSERT_EQUAL_INT8(0x22, v1); + TEST_ASSERT_EQUAL_INT8(v0, 0x22); + TEST_ASSERT_EQUAL_INT8(*p0, v1); + TEST_ASSERT_EQUAL_INT8(*p0, *p1); + TEST_ASSERT_EQUAL_INT8(*p0, 0x22); +} + +void testEqualInt8sWhenThereAreDifferencesOutside8Bits(void) +{ + TEST_ASSERT_EQUAL_INT8(0x321,0x421); + TEST_ASSERT_EQUAL_INT8(0xFF21,0x0021); +} + +void testEqualChars(void) +{ + char v0, v1; + char *p0, *p1; + + v0 = 'A'; + v1 = 'A'; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_CHAR('A', 'A'); + TEST_ASSERT_EQUAL_CHAR(v0, v1); + TEST_ASSERT_EQUAL_CHAR('A', v1); + TEST_ASSERT_EQUAL_CHAR(v0, 'A'); + TEST_ASSERT_EQUAL_CHAR(*p0, v1); + TEST_ASSERT_EQUAL_CHAR(*p0, *p1); + TEST_ASSERT_EQUAL_CHAR(*p0, 'A'); +} + +void testEqualCharsWhenThereAreDifferencesOutside8Bits(void) +{ + TEST_ASSERT_EQUAL_CHAR(0x321,0x421); + TEST_ASSERT_EQUAL_CHAR(0xFF21,0x0021); +} + + +void testEqualInt16s(void) +{ + UNITY_INT16 v0, v1; + UNITY_INT16 *p0, *p1; + + v0 = 0x7876; + v1 = 0x7876; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT16(0x7876, 0x7876); + TEST_ASSERT_EQUAL_INT16(v0, v1); + TEST_ASSERT_EQUAL_INT16(0x7876, v1); + TEST_ASSERT_EQUAL_INT16(v0, 0x7876); + TEST_ASSERT_EQUAL_INT16(*p0, v1); + TEST_ASSERT_EQUAL_INT16(*p0, *p1); + TEST_ASSERT_EQUAL_INT16(*p0, 0x7876); +} + +void testEqualInt16sNegatives(void) +{ + UNITY_INT16 v0, v1; + UNITY_INT16 *p0, *p1; + + v0 = -7876; + v1 = -7876; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT16(-7876, -7876); + TEST_ASSERT_EQUAL_INT16(v0, v1); + TEST_ASSERT_EQUAL_INT16(-7876, v1); + TEST_ASSERT_EQUAL_INT16(v0, -7876); + TEST_ASSERT_EQUAL_INT16(*p0, v1); + TEST_ASSERT_EQUAL_INT16(*p0, *p1); + TEST_ASSERT_EQUAL_INT16(*p0, -7876); +} + +void testEqualInt16sWhenThereAreDifferencesOutside16Bits(void) +{ + TEST_ASSERT_EQUAL_INT16(0x54321,0x64321); + TEST_ASSERT_EQUAL_INT16(0xFFFF4321,0x00004321); +} + +void testEqualInt32s(void) +{ + UNITY_INT32 v0, v1; + UNITY_INT32 *p0, *p1; + + v0 = 0x78760000; + v1 = 0x78760000; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT32(0x78760000, 0x78760000); + TEST_ASSERT_EQUAL_INT32(v0, v1); + TEST_ASSERT_EQUAL_INT32(0x78760000, v1); + TEST_ASSERT_EQUAL_INT32(v0, 0x78760000); + TEST_ASSERT_EQUAL_INT32(*p0, v1); + TEST_ASSERT_EQUAL_INT32(*p0, *p1); + TEST_ASSERT_EQUAL_INT32(*p0, 0x78760000); +} + +void testEqualInt32sNegatives(void) +{ + UNITY_INT32 v0, v1; + UNITY_INT32 *p0, *p1; + + v0 = -123456789; + v1 = -123456789; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT32(-123456789, -123456789); + TEST_ASSERT_EQUAL_INT32(v0, v1); + TEST_ASSERT_EQUAL_INT32(-123456789, v1); + TEST_ASSERT_EQUAL_INT32(v0, -123456789); + TEST_ASSERT_EQUAL_INT32(*p0, v1); + TEST_ASSERT_EQUAL_INT32(*p0, *p1); + TEST_ASSERT_EQUAL_INT32(*p0, -123456789); +} + + +void testEqualUints(void) +{ + unsigned int v0, v1; + unsigned int *p0, *p1; + + v0 = 19467; + v1 = 19467; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT(1837, 1837); + TEST_ASSERT_EQUAL_UINT(v0, v1); + TEST_ASSERT_EQUAL_UINT(19467, v1); + TEST_ASSERT_EQUAL_UINT(v0, 19467); + TEST_ASSERT_EQUAL_UINT(*p0, v1); + TEST_ASSERT_EQUAL_UINT(*p0, *p1); + TEST_ASSERT_EQUAL_UINT(*p0, 19467); + TEST_ASSERT_EQUAL_UINT(60872u, 60872u); +} + + +void testEqualUint8s(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0x22; + v1 = 0x22; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT8(0x22, 0x22); + TEST_ASSERT_EQUAL_UINT8(v0, v1); + TEST_ASSERT_EQUAL_UINT8(0x22, v1); + TEST_ASSERT_EQUAL_UINT8(v0, 0x22); + TEST_ASSERT_EQUAL_UINT8(*p0, v1); + TEST_ASSERT_EQUAL_UINT8(*p0, *p1); + TEST_ASSERT_EQUAL_UINT8(*p0, 0x22); +} + +void testEqualUint8sWhenThereAreDifferencesOutside8Bits(void) +{ + TEST_ASSERT_EQUAL_UINT8(0x321,0x421); + TEST_ASSERT_EQUAL_UINT8(0xFF21,0x0021); +} + +void testEqualUint16s(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0x9876; + v1 = 0x9876; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT16(0x9876, 0x9876); + TEST_ASSERT_EQUAL_UINT16(v0, v1); + TEST_ASSERT_EQUAL_UINT16(0x9876, v1); + TEST_ASSERT_EQUAL_UINT16(v0, 0x9876); + TEST_ASSERT_EQUAL_UINT16(*p0, v1); + TEST_ASSERT_EQUAL_UINT16(*p0, *p1); + TEST_ASSERT_EQUAL_UINT16(*p0, 0x9876); +} + +void testEqualUint16sWhenThereAreDifferencesOutside16Bits(void) +{ + TEST_ASSERT_EQUAL_UINT16(0x54321,0x64321); + TEST_ASSERT_EQUAL_UINT16(0xFFFF4321,0x00004321); +} + +void testEqualUint32s(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0x98760000; + v1 = 0x98760000; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT32(0x98760000, 0x98760000); + TEST_ASSERT_EQUAL_UINT32(v0, v1); + TEST_ASSERT_EQUAL_UINT32(0x98760000, v1); + TEST_ASSERT_EQUAL_UINT32(v0, 0x98760000); + TEST_ASSERT_EQUAL_UINT32(*p0, v1); + TEST_ASSERT_EQUAL_UINT32(*p0, *p1); + TEST_ASSERT_EQUAL_UINT32(*p0, 0x98760000); +} + +void testNotEqual(void) +{ + TEST_ASSERT_NOT_EQUAL(0, 1); + TEST_ASSERT_NOT_EQUAL(1, 0); + TEST_ASSERT_NOT_EQUAL(100, 101); + TEST_ASSERT_NOT_EQUAL(0, -1); + TEST_ASSERT_NOT_EQUAL(65535, -65535); + TEST_ASSERT_NOT_EQUAL(75, 900); + TEST_ASSERT_NOT_EQUAL(-100, -101); +} + +void testEqualHex8s(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0x22; + v1 = 0x22; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_HEX8(0x22, 0x22); + TEST_ASSERT_EQUAL_HEX8(v0, v1); + TEST_ASSERT_EQUAL_HEX8(0x22, v1); + TEST_ASSERT_EQUAL_HEX8(v0, 0x22); + TEST_ASSERT_EQUAL_HEX8(*p0, v1); + TEST_ASSERT_EQUAL_HEX8(*p0, *p1); + TEST_ASSERT_EQUAL_HEX8(*p0, 0x22); +} + +void testEqualHex8sWhenThereAreDifferencesOutside8Bits(void) +{ + TEST_ASSERT_EQUAL_HEX8(0x321,0x421); + TEST_ASSERT_EQUAL_HEX8(0xFF21,0x0021); +} + +void testEqualHex8sNegatives(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0xDD; + v1 = 0xDD; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_HEX8(0xDD, 0xDD); + TEST_ASSERT_EQUAL_HEX8(v0, v1); + TEST_ASSERT_EQUAL_HEX8(0xDD, v1); + TEST_ASSERT_EQUAL_HEX8(v0, 0xDD); + TEST_ASSERT_EQUAL_HEX8(*p0, v1); + TEST_ASSERT_EQUAL_HEX8(*p0, *p1); + TEST_ASSERT_EQUAL_HEX8(*p0, 0xDD); +} + +void testEqualHex16s(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0x9876; + v1 = 0x9876; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_HEX16(0x9876, 0x9876); + TEST_ASSERT_EQUAL_HEX16(v0, v1); + TEST_ASSERT_EQUAL_HEX16(0x9876, v1); + TEST_ASSERT_EQUAL_HEX16(v0, 0x9876); + TEST_ASSERT_EQUAL_HEX16(*p0, v1); + TEST_ASSERT_EQUAL_HEX16(*p0, *p1); + TEST_ASSERT_EQUAL_HEX16(*p0, 0x9876); +} + +void testEqualHex16sWhenThereAreDifferencesOutside16Bits(void) +{ + TEST_ASSERT_EQUAL_HEX16(0x54321,0x64321); + TEST_ASSERT_EQUAL_HEX16(0xFFFF4321,0x00004321); +} + +void testEqualHex32s(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0x98765432ul; + v1 = 0x98765432ul; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_HEX32(0x98765432ul, 0x98765432ul); + TEST_ASSERT_EQUAL_HEX32(v0, v1); + TEST_ASSERT_EQUAL_HEX32(0x98765432ul, v1); + TEST_ASSERT_EQUAL_HEX32(v0, 0x98765432ul); + TEST_ASSERT_EQUAL_HEX32(*p0, v1); + TEST_ASSERT_EQUAL_HEX32(*p0, *p1); + TEST_ASSERT_EQUAL_HEX32(*p0, 0x98765432ul); +} + +void testEqualBits(void) +{ + UNITY_UINT32 v0 = 0xFF55AA00; + UNITY_UINT32 v1 = 0x55550000; + + TEST_ASSERT_BITS(v1, v0, 0x55550000); + TEST_ASSERT_BITS(v1, v0, 0xFF55CC00); + TEST_ASSERT_BITS(0xFFFFFFFF, v0, 0xFF55AA00); + TEST_ASSERT_BITS(0xFFFFFFFF, v0, v0); + TEST_ASSERT_BITS(0xF0F0F0F0, v0, 0xFC5DAE0F); + TEST_ASSERT_BITS_HIGH(v1, v0); + TEST_ASSERT_BITS_LOW(0x000055FF, v0); + TEST_ASSERT_BIT_HIGH(30, v0); + TEST_ASSERT_BIT_LOW(5, v0); +} + +void testNotEqualBitHigh(void) +{ + UNITY_UINT32 v0 = 0x7F55AA00; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BIT_HIGH(31, v0); + VERIFY_FAILS_END +} + +void testNotEqualBitLow(void) +{ + UNITY_UINT32 v0 = 0xFF55AA00; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BIT_LOW(30, v0); + VERIFY_FAILS_END +} + +void testNotEqualBitsHigh(void) +{ + UNITY_UINT32 v0 = 0xFF55AA00; + UNITY_UINT32 v1 = 0x55550000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BITS_HIGH(v0, v1); + VERIFY_FAILS_END + +} + +void testNotEqualBitsLow(void) +{ + UNITY_UINT32 v0 = 0xFF55AA00; + UNITY_UINT32 v1 = 0x55550000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_BITS_LOW(v0, v1); + VERIFY_FAILS_END +} + + +void testEqualShorts(void) +{ + short v0, v1; + short *p0, *p1; + + v0 = 19467; + v1 = 19467; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT(1837, 1837); + TEST_ASSERT_EQUAL_INT(-2987, -2987); + TEST_ASSERT_EQUAL_INT(v0, v1); + TEST_ASSERT_EQUAL_INT(19467, v1); + TEST_ASSERT_EQUAL_INT(v0, 19467); + TEST_ASSERT_EQUAL_INT(*p0, v1); + TEST_ASSERT_EQUAL_INT(*p0, *p1); + TEST_ASSERT_EQUAL_INT(*p0, 19467); +} + +void testEqualUShorts(void) +{ + unsigned short v0, v1; + unsigned short *p0, *p1; + + v0 = 19467; + v1 = 19467; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT(1837, 1837); + TEST_ASSERT_EQUAL_UINT(2987, 2987); + TEST_ASSERT_EQUAL_UINT(v0, v1); + TEST_ASSERT_EQUAL_UINT(19467, v1); + TEST_ASSERT_EQUAL_UINT(v0, 19467); + TEST_ASSERT_EQUAL_UINT(*p0, v1); + TEST_ASSERT_EQUAL_UINT(*p0, *p1); + TEST_ASSERT_EQUAL_UINT(*p0, 19467); +} + +void testEqualUInts(void) +{ + unsigned char v0, v1; + unsigned char *p0, *p1; + + v0 = 109; + v1 = 109; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT(42, 42); + TEST_ASSERT_EQUAL_UINT(-116, -116); + TEST_ASSERT_EQUAL_UINT(v0, v1); + TEST_ASSERT_EQUAL_UINT(109, v1); + TEST_ASSERT_EQUAL_UINT(v0, 109); + TEST_ASSERT_EQUAL_UINT(*p0, v1); + TEST_ASSERT_EQUAL_UINT(*p0, *p1); + TEST_ASSERT_EQUAL_UINT(*p0, 109); +} + +void testEqualUChars(void) +{ + unsigned char v0, v1; + unsigned char *p0, *p1; + + v0 = 251; + v1 = 251; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT(42, 42); + TEST_ASSERT_EQUAL_INT(v0, v1); + TEST_ASSERT_EQUAL_INT(251, v1); + TEST_ASSERT_EQUAL_INT(v0, 251); + TEST_ASSERT_EQUAL_INT(*p0, v1); + TEST_ASSERT_EQUAL_INT(*p0, *p1); + TEST_ASSERT_EQUAL_INT(*p0, 251); +} + +void testEqualPointers(void) +{ + int v0, v1; + int *p0, *p1, *p2; + + v0 = 19467; + v1 = 18271; + p0 = &v0; + p1 = &v1; + p2 = &v1; + + TEST_ASSERT_EQUAL_PTR(p0, &v0); + TEST_ASSERT_EQUAL_PTR(&v1, p1); + TEST_ASSERT_EQUAL_PTR(p2, p1); + TEST_ASSERT_EQUAL_PTR(&v0, &v0); +} + +void testNotEqualPointers(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_PTR(0x12345678, 0x12345677); + VERIFY_FAILS_END +} + +void testIntsWithinDelta(void) +{ + TEST_ASSERT_INT_WITHIN(1, 5000, 5001); + TEST_ASSERT_INT_WITHIN(5, 5000, 4996); + TEST_ASSERT_INT_WITHIN(5, 5000, 5005); + TEST_ASSERT_INT_WITHIN(500, 50, -440); + + TEST_ASSERT_INT_WITHIN(2, -1, -1); + TEST_ASSERT_INT_WITHIN(5, 1, -1); + TEST_ASSERT_INT_WITHIN(5, -1, 1); +} + +void testIntsWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_INT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); + TEST_ASSERT_INT_WITHIN_MESSAGE(500, 50, -440, "Custom Message."); + + TEST_ASSERT_INT_WITHIN_MESSAGE(2, -1, -1, "Custom Message."); + TEST_ASSERT_INT_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); + TEST_ASSERT_INT_WITHIN_MESSAGE(5, -1, 1, "Custom Message."); +} + +void testIntsNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_WITHIN(5, 5000, 5006); + VERIFY_FAILS_END +} + +void testIntsNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5006, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntsWithinDelta(void) +{ + TEST_ASSERT_UINT_WITHIN(1, 5000, 5001); + TEST_ASSERT_UINT_WITHIN(5, 5000, 4996); + TEST_ASSERT_UINT_WITHIN(5, 5000, 5005); +} + +void testUIntsWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); +} + +void testUIntsNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN(1, 2147483647u, 2147483649u); + VERIFY_FAILS_END +} + +void testUIntsNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirst(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN(5, 1, -1); + VERIFY_FAILS_END +} + +void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirstAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); + VERIFY_FAILS_END +} + +void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirst(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN(5, -1, 1); + VERIFY_FAILS_END +} + +void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirstAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT_WITHIN_MESSAGE(5, -1, 1, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32sWithinDelta(void) +{ + TEST_ASSERT_HEX32_WITHIN(1, 5000, 5001); + TEST_ASSERT_HEX32_WITHIN(5, 5000, 4996); + TEST_ASSERT_HEX32_WITHIN(5, 5000, 5005); +} + +void testHEX32sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); +} + +void testHEX32sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_WITHIN(1, 2147483647u, 2147483649u); + VERIFY_FAILS_END +} + +void testHEX32sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPass(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_WITHIN(5, 1, -1); + VERIFY_FAILS_END +} + +void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX16sWithinDelta(void) +{ + TEST_ASSERT_HEX16_WITHIN(1, 5000, 5001); + TEST_ASSERT_HEX16_WITHIN(5, 5000, 4996); + TEST_ASSERT_HEX16_WITHIN(5, 5000, 5005); +} + +void testHEX16sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_HEX16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); +} + +void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) +{ + TEST_ASSERT_HEX16_WITHIN(5, 0x54321, 0x44321); +} + +void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) +{ + TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); +} + +void testHEX16sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_WITHIN(2, 65535, 0); + VERIFY_FAILS_END +} + +void testHEX16sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testHEX8sWithinDelta(void) +{ + TEST_ASSERT_HEX8_WITHIN(1, 254, 255); + TEST_ASSERT_HEX8_WITHIN(5, 251, 255); + TEST_ASSERT_HEX8_WITHIN(5, 1, 4); +} + +void testHEX8sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_HEX8_WITHIN_MESSAGE(1, 254, 255, "Custom Message."); + TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 251, 255, "Custom Message."); + TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); +} + +void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) +{ + TEST_ASSERT_HEX8_WITHIN(5, 0x123, 0xF23); +} + +void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) +{ + TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); +} + +void testHEX8sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_WITHIN(2, 255, 0); + VERIFY_FAILS_END +} + +void testHEX8sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX8_WITHIN_MESSAGE(2, 255, 0, "Custom Message."); + VERIFY_FAILS_END +} + +/*-----------------*/ + +void testUINT32sWithinDelta(void) +{ + TEST_ASSERT_UINT32_WITHIN(1, 5000, 5001); + TEST_ASSERT_UINT32_WITHIN(5, 5000, 4996); + TEST_ASSERT_UINT32_WITHIN(5, 5000, 5005); +} + +void testUINT32sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); +} + +void testUINT32sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT32_WITHIN(1, 2147483647u, 2147483649u); + VERIFY_FAILS_END +} + +void testUINT32sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); + VERIFY_FAILS_END +} + +void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPass(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT32_WITHIN(5, 1, -1); + VERIFY_FAILS_END +} + +void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); + VERIFY_FAILS_END +} + +void testUINT16sWithinDelta(void) +{ + TEST_ASSERT_UINT16_WITHIN(1, 5000, 5001); + TEST_ASSERT_UINT16_WITHIN(5, 5000, 4996); + TEST_ASSERT_UINT16_WITHIN(5, 5000, 5005); +} + +void testUINT16sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_UINT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); + TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); + TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); +} + +void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) +{ + TEST_ASSERT_UINT16_WITHIN(5, 0x54321, 0x44321); +} + +void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) +{ + TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); +} + +void testUINT16sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_WITHIN(2, 65535, 0); + VERIFY_FAILS_END +} + +void testUINT16sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testUINT8sWithinDelta(void) +{ + TEST_ASSERT_UINT8_WITHIN(1, 254, 255); + TEST_ASSERT_UINT8_WITHIN(5, 251, 255); + TEST_ASSERT_UINT8_WITHIN(5, 1, 4); +} + +void testUINT8sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_UINT8_WITHIN_MESSAGE(1, 254, 255, "Custom Message."); + TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 251, 255, "Custom Message."); + TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); +} + +void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) +{ + TEST_ASSERT_UINT8_WITHIN(5, 0x123, 0xF23); +} + +void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) +{ + TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); +} + +void testUINT8sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_WITHIN(2, 255, 0); + VERIFY_FAILS_END +} + +void testUINT8sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT8_WITHIN_MESSAGE(2, 255, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testINT32sWithinDelta(void) +{ + TEST_ASSERT_INT32_WITHIN(1, 5000, 5001); + TEST_ASSERT_INT32_WITHIN(5, 1, -2); + TEST_ASSERT_INT32_WITHIN(5, -2, 1); +} + +void testINT32sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_INT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); +} + +void testINT32sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT32_WITHIN(1, -3, 1); + VERIFY_FAILS_END +} + +void testINT32sNotWithinDeltaAndDifferenceOverflows(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT32_WITHIN(1, -1, 0x7FFFFFFF); + VERIFY_FAILS_END +} +void testINT32sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT32_WITHIN_MESSAGE(1, -2, 1, "Custom Message."); + VERIFY_FAILS_END +} + +void testINT16sWithinDelta(void) +{ + TEST_ASSERT_INT16_WITHIN(1, 5000, 5001); + TEST_ASSERT_INT16_WITHIN(5, 2, -2); + TEST_ASSERT_INT16_WITHIN(5, -2, 2); +} + +void testINT16sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_INT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); +} + +void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) +{ + TEST_ASSERT_INT16_WITHIN(5, 0x54321, 0x44321); +} + +void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) +{ + TEST_ASSERT_INT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); +} + +void testINT16sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_WITHIN(2, 4, -2); + VERIFY_FAILS_END +} + +void testINT16sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT16_WITHIN_MESSAGE(2, 3, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testINT8sWithinDelta(void) +{ + TEST_ASSERT_INT8_WITHIN(1, 127, 126); + TEST_ASSERT_INT8_WITHIN(5, -2, 2); + TEST_ASSERT_INT8_WITHIN(5, 2, -2); +} + +void testINT8sWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); +} + +void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) +{ + TEST_ASSERT_INT8_WITHIN(5, 0x123, 0xF23); +} + +void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) +{ + TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); +} + +void testINT8sNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_WITHIN(2, -3, 0); + VERIFY_FAILS_END +} + +void testINT8sNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT8_WITHIN_MESSAGE(2, -4, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testCHARsWithinDelta(void) +{ + TEST_ASSERT_CHAR_WITHIN(1, 'M', 'L'); + TEST_ASSERT_CHAR_WITHIN(5, -2, 2); + TEST_ASSERT_CHAR_WITHIN(5, 2, -2); +} + +void testCHARsWithinDeltaAndCustomMessage(void) +{ + TEST_ASSERT_CHAR_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); +} + +void testCHARsWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) +{ + TEST_ASSERT_CHAR_WITHIN(5, 0x123, 0xF23); +} + +void testCHARsWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) +{ + TEST_ASSERT_CHAR_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); +} + +void testCHARsNotWithinDelta(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_CHAR_WITHIN(2, -3, 0); + VERIFY_FAILS_END +} + +void testCHARsNotWithinDeltaAndCustomMessage(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_CHAR_WITHIN_MESSAGE(2, -4, 0, "Custom Message."); + VERIFY_FAILS_END +} + +void testNotEqualINT(void) +{ + UNITY_INT v0, v1; + UNITY_INT *p0, *p1; + + v0 = 302; + v1 = 3334; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_INT(v0, v1); + TEST_ASSERT_NOT_EQUAL_INT(*p0, v1); + TEST_ASSERT_NOT_EQUAL_INT(v0, *p1); + TEST_ASSERT_NOT_EQUAL_INT(*p1, *p0); +} + +void testNotNotEqualINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_INT(302, 302); + VERIFY_FAILS_END +} + +void testNotEqualINT8(void) +{ + UNITY_INT8 v0, v1; + UNITY_INT8 *p0, *p1; + + v0 = -128; + v1 = 127; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_INT8(v0, v1); + TEST_ASSERT_NOT_EQUAL_INT8(*p0, v1); + TEST_ASSERT_NOT_EQUAL_INT8(v0, *p1); + TEST_ASSERT_NOT_EQUAL_INT8(*p1, *p0); +} + +void testNotNotEqualINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_INT8(-128, -128); + VERIFY_FAILS_END +} + +void testNotEqualCHAR(void) +{ + char v0, v1; + char *p0, *p1; + + v0 = -128; + v1 = 127; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_CHAR(v0, v1); + TEST_ASSERT_NOT_EQUAL_CHAR(*p0, v1); + TEST_ASSERT_NOT_EQUAL_CHAR(v0, *p1); + TEST_ASSERT_NOT_EQUAL_CHAR(*p1, *p0); +} + +void testNotNotEqualCHAR(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_CHAR(127, 127); + VERIFY_FAILS_END +} + +void testNotEqualINT16(void) +{ + UNITY_INT16 v0, v1; + UNITY_INT16 *p0, *p1; + + v0 = -32768; + v1 = 32767; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_INT16(v0, v1); + TEST_ASSERT_NOT_EQUAL_INT16(*p0, v1); + TEST_ASSERT_NOT_EQUAL_INT16(v0, *p1); + TEST_ASSERT_NOT_EQUAL_INT16(*p1, *p0); +} + +void testNotNotEqualINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_INT16(-32768, -32768); + VERIFY_FAILS_END +} + +void testNotEqualINT32(void) +{ + UNITY_INT32 v0, v1; + UNITY_INT32 *p0, *p1; + + v0 = -214783648; + v1 = 214783647; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_INT32(v0, v1); + TEST_ASSERT_NOT_EQUAL_INT32(*p0, v1); + TEST_ASSERT_NOT_EQUAL_INT32(v0, *p1); + TEST_ASSERT_NOT_EQUAL_INT32(*p1, *p0); +} + +void testNotNotEqualINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_INT32(-214783648, -214783648); + VERIFY_FAILS_END +} + +void testNotEqualUINT(void) +{ + UNITY_UINT v0, v1; + UNITY_UINT *p0, *p1; + + v0 = 0; + v1 = 1; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_UINT(v0, v1); + TEST_ASSERT_NOT_EQUAL_UINT(*p0, v1); + TEST_ASSERT_NOT_EQUAL_UINT(v0, *p1); + TEST_ASSERT_NOT_EQUAL_UINT(*p1, *p0); +} + +void testNotNotEqualUINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_UINT(1, 1); + VERIFY_FAILS_END +} + +void testNotEqualUINT8(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0; + v1 = 255; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_UINT8(v0, v1); + TEST_ASSERT_NOT_EQUAL_UINT8(*p0, v1); + TEST_ASSERT_NOT_EQUAL_UINT8(v0, *p1); + TEST_ASSERT_NOT_EQUAL_UINT8(*p1, *p0); +} + +void testNotNotEqualUINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_UINT8(255, 255); + VERIFY_FAILS_END +} + +void testNotEqualUINT16(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0; + v1 = 65535; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_UINT16(v0, v1); + TEST_ASSERT_NOT_EQUAL_UINT16(*p0, v1); + TEST_ASSERT_NOT_EQUAL_UINT16(v0, *p1); + TEST_ASSERT_NOT_EQUAL_UINT16(*p1, *p0); +} + +void testNotNotEqualUINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_UINT16(65535, 65535); + VERIFY_FAILS_END +} + +void testNotEqualUINT32(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0u; + v1 = 4294967295u; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_UINT32(v0, v1); + TEST_ASSERT_NOT_EQUAL_UINT32(*p0, v1); + TEST_ASSERT_NOT_EQUAL_UINT32(v0, *p1); + TEST_ASSERT_NOT_EQUAL_UINT32(*p1, *p0); +} + +void testNotNotEqualUINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_UINT32(4294967295u, 4294967295u); + VERIFY_FAILS_END +} + +void testNotEqualHEX8(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0x00; + v1 = 0xFF; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_HEX8(v0, v1); + TEST_ASSERT_NOT_EQUAL_HEX8(*p0, v1); + TEST_ASSERT_NOT_EQUAL_HEX8(v0, *p1); + TEST_ASSERT_NOT_EQUAL_HEX8(*p1, *p0); +} + +void testNotNotEqualHEX8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_HEX8(0xFF, 0xFF); + VERIFY_FAILS_END +} + +void testNotEqualHEX16(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0x0000; + v1 = 0xFFFF; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_HEX16(v0, v1); + TEST_ASSERT_NOT_EQUAL_HEX16(*p0, v1); + TEST_ASSERT_NOT_EQUAL_HEX16(v0, *p1); + TEST_ASSERT_NOT_EQUAL_HEX16(*p1, *p0); +} + +void testNotNotEqualHEX16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_HEX16(0xFFFF, 0xFFFF); + VERIFY_FAILS_END +} + +void testNotEqualHEX32(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0x00000000; + v1 = 0xFFFFFFFF; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_NOT_EQUAL_HEX32(v0, v1); + TEST_ASSERT_NOT_EQUAL_HEX32(*p0, v1); + TEST_ASSERT_NOT_EQUAL_HEX32(v0, *p1); + TEST_ASSERT_NOT_EQUAL_HEX32(*p1, *p0); +} + +void testNotNotEqualHEX32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_HEX32(0xFFFFFFFF, 0xFFFFFFFF); + VERIFY_FAILS_END +} + +/*-----------------*/ + +void testGreaterThan(void) +{ + UNITY_INT v0, v1; + UNITY_INT *p0, *p1; + + v0 = 0; + v1 = 1; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN(v0, v1); + TEST_ASSERT_GREATER_THAN(*p0, v1); + TEST_ASSERT_GREATER_THAN(v0, *p1); + TEST_ASSERT_GREATER_THAN(*p0, *p1); +} + +void testNotGreaterThan(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN(0, -1); + VERIFY_FAILS_END +} + +void testGreaterThanINT(void) +{ + UNITY_INT v0, v1; + UNITY_INT *p0, *p1; + + v0 = 302; + v1 = 3334; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_INT(v0, v1); + TEST_ASSERT_GREATER_THAN_INT(*p0, v1); + TEST_ASSERT_GREATER_THAN_INT(v0, *p1); + TEST_ASSERT_GREATER_THAN_INT(*p0, *p1); +} + +void testNotGreaterThanINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_INT(3334, 302); + VERIFY_FAILS_END +} + +void testGreaterThanINT8(void) +{ + UNITY_INT8 v0, v1; + UNITY_INT8 *p0, *p1; + + v0 = -128; + v1 = 127; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_INT8(v0, v1); + TEST_ASSERT_GREATER_THAN_INT8(*p0, v1); + TEST_ASSERT_GREATER_THAN_INT8(v0, *p1); + TEST_ASSERT_GREATER_THAN_INT8(*p0, *p1); +} + +void testNotGreaterThanINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_INT8(127, -128); + VERIFY_FAILS_END +} + +void testGreaterThanCHAR(void) +{ + char v0, v1; + char *p0, *p1; + + v0 = -128; + v1 = 127; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_CHAR(v0, v1); + TEST_ASSERT_GREATER_THAN_CHAR(*p0, v1); + TEST_ASSERT_GREATER_THAN_CHAR(v0, *p1); + TEST_ASSERT_GREATER_THAN_CHAR(*p0, *p1); +} + +void testNotGreaterThanCHAR(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_CHAR(127, -128); + VERIFY_FAILS_END +} + +void testGreaterThanINT16(void) +{ + UNITY_INT16 v0, v1; + UNITY_INT16 *p0, *p1; + + v0 = -32768; + v1 = 32767; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_INT16(v0, v1); + TEST_ASSERT_GREATER_THAN_INT16(*p0, v1); + TEST_ASSERT_GREATER_THAN_INT16(v0, *p1); + TEST_ASSERT_GREATER_THAN_INT16(*p0, *p1); +} + +void testNotGreaterThanINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_INT16(32768, -32768); + VERIFY_FAILS_END +} + +void testGreaterThanINT32(void) +{ + UNITY_INT32 v0, v1; + UNITY_INT32 *p0, *p1; + + v0 = -214783648; + v1 = 214783647; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_INT32(v0, v1); + TEST_ASSERT_GREATER_THAN_INT32(*p0, v1); + TEST_ASSERT_GREATER_THAN_INT32(v0, *p1); + TEST_ASSERT_GREATER_THAN_INT32(*p0, *p1); +} + +void testNotGreaterThanINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_INT32(214783647, -214783648); + VERIFY_FAILS_END +} + +void testGreaterThanUINT(void) +{ + UNITY_UINT v0, v1; + UNITY_UINT *p0, *p1; + + v0 = 0; + v1 = 1; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_UINT(v0, v1); + TEST_ASSERT_GREATER_THAN_UINT(*p0, v1); + TEST_ASSERT_GREATER_THAN_UINT(v0, *p1); + TEST_ASSERT_GREATER_THAN_UINT(*p0, *p1); +} + +void testNotGreaterThanUINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_UINT(1, 0); + VERIFY_FAILS_END +} + +void testGreaterThanUINT8(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0; + v1 = 255; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_UINT8(v0, v1); + TEST_ASSERT_GREATER_THAN_UINT8(*p0, v1); + TEST_ASSERT_GREATER_THAN_UINT8(v0, *p1); + TEST_ASSERT_GREATER_THAN_UINT8(*p0, *p1); +} + +void testNotGreaterThanUINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_UINT8(255, 0); + VERIFY_FAILS_END +} + +void testGreaterThanUINT16(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0; + v1 = 65535; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_UINT16(v0, v1); + TEST_ASSERT_GREATER_THAN_UINT16(*p0, v1); + TEST_ASSERT_GREATER_THAN_UINT16(v0, *p1); + TEST_ASSERT_GREATER_THAN_UINT16(*p0, *p1); +} + +void testNotGreaterThanUINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_UINT16(65535, 0); + VERIFY_FAILS_END +} + +void testGreaterThanUINT32(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0u; + v1 = 4294967295u; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_UINT32(v0, v1); + TEST_ASSERT_GREATER_THAN_UINT32(*p0, v1); + TEST_ASSERT_GREATER_THAN_UINT32(v0, *p1); + TEST_ASSERT_GREATER_THAN_UINT32(*p0, *p1); +} + +void testNotGreaterThanUINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_UINT32(4294967295u, 0); + VERIFY_FAILS_END +} + +void testGreaterThanHEX8(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0x00; + v1 = 0xFF; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_HEX8(v0, v1); + TEST_ASSERT_GREATER_THAN_HEX8(*p0, v1); + TEST_ASSERT_GREATER_THAN_HEX8(v0, *p1); + TEST_ASSERT_GREATER_THAN_HEX8(*p0, *p1); +} + +void testNotGreaterThanHEX8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_HEX8(0xFF, 0x00); + VERIFY_FAILS_END +} + +void testGreaterThanHEX16(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0x0000; + v1 = 0xFFFF; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_HEX16(v0, v1); + TEST_ASSERT_GREATER_THAN_HEX16(*p0, v1); + TEST_ASSERT_GREATER_THAN_HEX16(v0, *p1); + TEST_ASSERT_GREATER_THAN_HEX16(*p0, *p1); +} + +void testNotGreaterThanHEX16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_HEX16(0xFFFF, 0x00); + VERIFY_FAILS_END +} + +void testGreaterThanHEX32(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0x00000000; + v1 = 0xFFFFFFFF; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_GREATER_THAN_HEX32(v0, v1); + TEST_ASSERT_GREATER_THAN_HEX32(*p0, v1); + TEST_ASSERT_GREATER_THAN_HEX32(v0, *p1); + TEST_ASSERT_GREATER_THAN_HEX32(*p0, *p1); +} + +void testNotGreaterThanHEX32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_HEX32(0xFFFFFFFF, 0x00); + VERIFY_FAILS_END +} + +void testGreaterOrEqual(void) +{ + UNITY_INT v0, v1, v2; + UNITY_INT *p0, *p1, *p2; + + v0 = 0; + v1 = 1; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL(*p0, *p2); +} + +void testNotGreaterOrEqual(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL(0, -1); + VERIFY_FAILS_END +} + +void testGreaterOrEqualINT(void) +{ + UNITY_INT v0, v1, v2; + UNITY_INT *p0, *p1, *p2; + + v0 = 302; + v1 = 3334; + v2 = 302; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, *p2); +} + +void testNotGreaterOrEqualINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_INT(3334, 302); + VERIFY_FAILS_END +} + +void testGreaterOrEqualINT8(void) +{ + UNITY_INT8 v0, v1, v2; + UNITY_INT8 *p0, *p1, *p2; + + v0 = -128; + v1 = 127; + v2 = -128; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, *p2); +} + +void testNotGreaterOrEqualINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_INT8(127, -128); + VERIFY_FAILS_END +} + +void testGreaterOrEqualCHAR(void) +{ + char v0, v1, v2; + char *p0, *p1, *p2; + + v0 = -128; + v1 = 127; + v2 = -128; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_CHAR(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_CHAR(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_CHAR(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_CHAR(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_CHAR(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_CHAR(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_CHAR(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_CHAR(*p0, *p2); +} + +void testNotGreaterOrEqualCHAR(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_CHAR(127, -128); + VERIFY_FAILS_END +} + +void testGreaterOrEqualINT16(void) +{ + UNITY_INT16 v0, v1, v2; + UNITY_INT16 *p0, *p1, *p2; + + v0 = -32768; + v1 = 32767; + v2 = -32768; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, *p2); +} + +void testNotGreaterOrEqualINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_INT16(32767, -32768); + VERIFY_FAILS_END +} + +void testGreaterOrEqualINT32(void) +{ + UNITY_INT32 v0, v1, v2; + UNITY_INT32 *p0, *p1, *p2; + + v0 = -214783648; + v1 = 214783647; + v2 = -214783648; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, *p2); +} + +void testNotGreaterOrEqualINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_INT32(214783647, -214783648); + VERIFY_FAILS_END +} + +void testGreaterOrEqualUINT(void) +{ + UNITY_UINT v0, v1, v2; + UNITY_UINT *p0, *p1, *p2; + + v0 = 0; + v1 = 1; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, *p2); +} + +void testNotGreaterOrEqualUINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_UINT(1, 0); + VERIFY_FAILS_END +} + +void testGreaterOrEqualUINT8(void) +{ + UNITY_UINT8 v0, v1, v2; + UNITY_UINT8 *p0, *p1, *p2; + + v0 = 0; + v1 = 255; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, *p2); +} + +void testNotGreaterOrEqualUINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_UINT8(255, 0); + VERIFY_FAILS_END +} + +void testGreaterOrEqualUINT16(void) +{ + UNITY_UINT16 v0, v1, v2; + UNITY_UINT16 *p0, *p1, *p2; + + v0 = 0; + v1 = 65535; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, *p2); +} + +void testNotGreaterOrEqualUINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_UINT16(65535, 0); + VERIFY_FAILS_END +} + +void testGreaterOrEqualUINT32(void) +{ + UNITY_UINT32 v0, v1, v2; + UNITY_UINT32 *p0, *p1, *p2; + + v0 = 0; + v1 = 4294967295u; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, *p2); +} + +void testNotGreaterOrEqualUINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_UINT32(4294967295u, 0); + VERIFY_FAILS_END +} + +void testGreaterOrEqualHEX8(void) +{ + UNITY_UINT8 v0, v1, v2; + UNITY_UINT8 *p0, *p1, *p2; + + v0 = 0x00; + v1 = 0xFF; + v2 = 0x00; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, *p2); +} + +void testNotGreaterOrEqualHEX8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_HEX8(0xFF, 0x00); + VERIFY_FAILS_END +} + +void testGreaterOrEqualHEX16(void) +{ + UNITY_UINT16 v0, v1, v2; + UNITY_UINT16 *p0, *p1, *p2; + + v0 = 0x0000; + v1 = 0xFFFF; + v2 = 0x0000; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, *p2); +} + +void testNotGreaterOrEqualHEX16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_HEX16(0xFFFF, 0x00); + VERIFY_FAILS_END +} + +void testGreaterOrEqualHEX32(void) +{ + UNITY_UINT32 v0, v1, v2; + UNITY_UINT32 *p0, *p1, *p2; + + v0 = 0x00000000; + v1 = 0xFFFFFFFF; + v2 = 0x00000000; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, v1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, *p1); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, v2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, *p2); + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, *p2); +} + +void testNotGreaterOrEqualHEX32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_HEX32(0xFFFFFFFF, 0x00); + VERIFY_FAILS_END +} + +/*-----------------*/ + +void testLessThan(void) +{ + UNITY_INT v0, v1; + UNITY_INT *p0, *p1; + + v0 = 0; + v1 = -1; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN(v0, v1); + TEST_ASSERT_LESS_THAN(*p0, v1); + TEST_ASSERT_LESS_THAN(v0, *p1); + TEST_ASSERT_LESS_THAN(*p0, *p1); +} + +void testNotLessThan(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN(0, 1); + VERIFY_FAILS_END +} + +void testLessThanINT(void) +{ + UNITY_INT v0, v1; + UNITY_INT *p0, *p1; + + v0 = 3334; + v1 = 302; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_INT(v0, v1); + TEST_ASSERT_LESS_THAN_INT(*p0, v1); + TEST_ASSERT_LESS_THAN_INT(v0, *p1); + TEST_ASSERT_LESS_THAN_INT(*p0, *p1); +} + +void testNotLessThanINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_INT(302, 3334); + VERIFY_FAILS_END +} + +void testLessThanINT8(void) +{ + UNITY_INT8 v0, v1; + UNITY_INT8 *p0, *p1; + + v0 = 127; + v1 = -128; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_INT8(v0, v1); + TEST_ASSERT_LESS_THAN_INT8(*p0, v1); + TEST_ASSERT_LESS_THAN_INT8(v0, *p1); + TEST_ASSERT_LESS_THAN_INT8(*p0, *p1); +} + +void testNotLessThanINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_INT8(-128, 127); + VERIFY_FAILS_END +} + +void testLessThanCHAR(void) +{ + char v0, v1; + char *p0, *p1; + + v0 = 127; + v1 = -128; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_CHAR(v0, v1); + TEST_ASSERT_LESS_THAN_CHAR(*p0, v1); + TEST_ASSERT_LESS_THAN_CHAR(v0, *p1); + TEST_ASSERT_LESS_THAN_CHAR(*p0, *p1); +} + +void testNotLessThanCHAR(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_CHAR(-128, 127); + VERIFY_FAILS_END +} + +void testLessThanINT16(void) +{ + UNITY_INT16 v0, v1; + UNITY_INT16 *p0, *p1; + + v0 = 32767; + v1 = -32768; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_INT16(v0, v1); + TEST_ASSERT_LESS_THAN_INT16(*p0, v1); + TEST_ASSERT_LESS_THAN_INT16(v0, *p1); + TEST_ASSERT_LESS_THAN_INT16(*p0, *p1); +} + +void testNotLessThanINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_INT16(-32768, 32767); + VERIFY_FAILS_END +} + +void testLessThanINT32(void) +{ + UNITY_INT32 v0, v1; + UNITY_INT32 *p0, *p1; + + v0 = 214783647; + v1 = -214783648; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_INT32(v0, v1); + TEST_ASSERT_LESS_THAN_INT32(*p0, v1); + TEST_ASSERT_LESS_THAN_INT32(v0, *p1); + TEST_ASSERT_LESS_THAN_INT32(*p0, *p1); +} + +void testNotLessThanINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_INT32(-214783648, 214783647); + VERIFY_FAILS_END +} + +void testLessThanUINT(void) +{ + UNITY_UINT v0, v1; + UNITY_UINT *p0, *p1; + + v0 = 1; + v1 = 0; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_UINT(v0, v1); + TEST_ASSERT_LESS_THAN_UINT(*p0, v1); + TEST_ASSERT_LESS_THAN_UINT(v0, *p1); + TEST_ASSERT_LESS_THAN_UINT(*p0, *p1); +} + +void testNotLessThanUINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_UINT(0, 1); + VERIFY_FAILS_END +} + +void testLessThanUINT8(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 255; + v1 = 0; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_UINT8(v0, v1); + TEST_ASSERT_LESS_THAN_UINT8(*p0, v1); + TEST_ASSERT_LESS_THAN_UINT8(v0, *p1); + TEST_ASSERT_LESS_THAN_UINT8(*p0, *p1); +} + +void testNotLessThanUINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_UINT8(0, 255); + VERIFY_FAILS_END +} + +void testLessThanUINT16(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 65535; + v1 = 0; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_UINT16(v0, v1); + TEST_ASSERT_LESS_THAN_UINT16(*p0, v1); + TEST_ASSERT_LESS_THAN_UINT16(v0, *p1); + TEST_ASSERT_LESS_THAN_UINT16(*p0, *p1); +} + +void testNotLessThanUINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_UINT16(0, 65535); + VERIFY_FAILS_END +} + +void testLessThanUINT32(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 4294967295u; + v1 = 0; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_UINT32(v0, v1); + TEST_ASSERT_LESS_THAN_UINT32(*p0, v1); + TEST_ASSERT_LESS_THAN_UINT32(v0, *p1); + TEST_ASSERT_LESS_THAN_UINT32(*p0, *p1); +} + +void testNotLessThanUINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_UINT32(0, 4294967295u); + VERIFY_FAILS_END +} + +void testLessThanHEX8(void) +{ + UNITY_UINT8 v0, v1; + UNITY_UINT8 *p0, *p1; + + v0 = 0xFF; + v1 = 0x00; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_HEX8(v0, v1); + TEST_ASSERT_LESS_THAN_HEX8(*p0, v1); + TEST_ASSERT_LESS_THAN_HEX8(v0, *p1); + TEST_ASSERT_LESS_THAN_HEX8(*p0, *p1); +} + +void testNotLessThanHEX8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_HEX8(0x00, 0xFF); + VERIFY_FAILS_END +} + +void testLessThanHEX16(void) +{ + UNITY_UINT16 v0, v1; + UNITY_UINT16 *p0, *p1; + + v0 = 0xFFFF; + v1 = 0x0000; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_HEX16(v0, v1); + TEST_ASSERT_LESS_THAN_HEX16(*p0, v1); + TEST_ASSERT_LESS_THAN_HEX16(v0, *p1); + TEST_ASSERT_LESS_THAN_HEX16(*p0, *p1); +} + +void testNotLessThanHEX16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_HEX16(0x0000, 0xFFFF); + VERIFY_FAILS_END +} + +void testLessThanHEX32(void) +{ + UNITY_UINT32 v0, v1; + UNITY_UINT32 *p0, *p1; + + v0 = 0xFFFFFFFF; + v1 = 0x00000000; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_LESS_THAN_HEX32(v0, v1); + TEST_ASSERT_LESS_THAN_HEX32(*p0, v1); + TEST_ASSERT_LESS_THAN_HEX32(v0, *p1); + TEST_ASSERT_LESS_THAN_HEX32(*p0, *p1); +} + +void testNotLessThanHEX32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_HEX32(0x00000000, 0xFFFFFFFF); + VERIFY_FAILS_END +} + +void testLessOrEqual(void) +{ + UNITY_INT v0, v1, v2; + UNITY_INT *p0, *p1, *p2; + + v0 = 0; + v1 = -1; + v2 = 0; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL(*p0, *p2); +} + +void testNotLessOrEqual(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL(0, 1); + VERIFY_FAILS_END +} + +void testLessOrEqualINT(void) +{ + UNITY_INT v0, v1, v2; + UNITY_INT *p0, *p1, *p2; + + v0 = 3334; + v1 = 302; + v2 = 3334; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_INT(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, *p2); +} + +void testNotLessOrEqualINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_INT(302, 3334); + VERIFY_FAILS_END +} + +void testLessOrEqualINT8(void) +{ + UNITY_INT8 v0, v1, v2; + UNITY_INT8 *p0, *p1, *p2; + + v0 = 127; + v1 = -128; + v2 = 127; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, *p2); +} + +void testNotLessOrEqualINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_INT8(-128, 127); + VERIFY_FAILS_END +} + +void testLessOrEqualCHAR(void) +{ + char v0, v1, v2; + char *p0, *p1, *p2; + + v0 = 127; + v1 = -128; + v2 = 127; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_CHAR(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_CHAR(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_CHAR(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_CHAR(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_CHAR(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_CHAR(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_CHAR(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_CHAR(*p0, *p2); +} + +void testNotLessOrEqualCHAR(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_CHAR(-128, 127); + VERIFY_FAILS_END +} + +void testLessOrEqualINT16(void) +{ + UNITY_INT16 v0, v1, v2; + UNITY_INT16 *p0, *p1, *p2; + + v0 = 32767; + v1 = -32768; + v2 = 32767; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, *p2); +} + +void testNotLessOrEqualINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_INT16(-32768, 32767); + VERIFY_FAILS_END +} + +void testLessOrEqualINT32(void) +{ + UNITY_INT32 v0, v1, v2; + UNITY_INT32 *p0, *p1, *p2; + + v0 = 214783647; + v1 = -214783648; + v2 = 214783647; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, *p2); +} + +void testNotLessOrEqualINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_INT32(-214783648, 214783647); + VERIFY_FAILS_END +} + +void testLessOrEqualUINT(void) +{ + UNITY_UINT v0, v1, v2; + UNITY_UINT *p0, *p1, *p2; + + v0 = 1; + v1 = 0; + v2 = 1; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, *p2); +} + +void testNotLessOrEqualUINT(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_UINT(0, 1); + VERIFY_FAILS_END +} + +void testLessOrEqualUINT8(void) +{ + UNITY_UINT8 v0, v1, v2; + UNITY_UINT8 *p0, *p1, *p2; + + v0 = 255; + v1 = 0; + v2 = 255; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, *p2); +} + +void testNotLessOrEqualUINT8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_UINT8(0, 255); + VERIFY_FAILS_END +} + +void testLessOrEqualUINT16(void) +{ + UNITY_UINT16 v0, v1, v2; + UNITY_UINT16 *p0, *p1, *p2; + + v0 = 65535; + v1 = 0; + v2 = 65535; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, *p2); +} + +void testNotLessOrEqualUINT16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_UINT16(0, 65535); + VERIFY_FAILS_END +} + +void testLessOrEqualUINT32(void) +{ + UNITY_UINT32 v0, v1, v2; + UNITY_UINT32 *p0, *p1, *p2; + + v0 = 4294967295u; + v1 = 0; + v2 = 4294967295u; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, *p2); +} + +void testNotLessOrEqualUINT32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_UINT32(0, 4294967295u); + VERIFY_FAILS_END +} + +void testLessOrEqualHEX8(void) +{ + UNITY_UINT8 v0, v1, v2; + UNITY_UINT8 *p0, *p1, *p2; + + v0 = 0xFF; + v1 = 0x00; + v2 = 0xFF; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, *p2); +} + +void testNotLessOrEqualHEX8(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_HEX8(0x00, 0xFF); + VERIFY_FAILS_END +} + +void testLessOrEqualHEX16(void) +{ + UNITY_UINT16 v0, v1, v2; + UNITY_UINT16 *p0, *p1, *p2; + + v0 = 0xFFFF; + v1 = 0x0000; + v2 = 0xFFFF; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, *p2); +} + +void testNotLessOrEqualHEX16(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_HEX16(0x0000, 0xFFFF); + VERIFY_FAILS_END +} + +void testLessOrEqualHEX32(void) +{ + UNITY_UINT32 v0, v1, v2; + UNITY_UINT32 *p0, *p1, *p2; + + v0 = 0xFFFFFFFF; + v1 = 0x00000000; + v2 = 0xFFFFFFFF; + p0 = &v0; + p1 = &v1; + p2 = &v2; + + TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, v1); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, *p1); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, v2); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, *p2); + TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, *p2); +} + +void testNotLessOrEqualHEX32(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_HEX32(0x00000000, 0xFFFFFFFF); + VERIFY_FAILS_END +} + +void testHexPrintsUpToMaxNumberOfNibbles(void) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + startPutcharSpy(); + UnityPrintNumberHex(0xBEE, 21); + endPutcharSpy(); +#ifdef UNITY_SUPPORT_64 + TEST_ASSERT_EQUAL_INT(16, strlen(getBufferPutcharSpy())); +#else + TEST_ASSERT_EQUAL_INT( 8, strlen(getBufferPutcharSpy())); +#endif +#endif +} + +void testPrintNumbers32(void) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE_MESSAGE("Compile with '-D UNITY_OUTPUT_CHAR=putcharSpy' to enable print testing"); +#else + TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("1", 1); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", -1); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("2000000000", 2000000000); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("-2147483648", (UNITY_INT32)0x80000000); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (UNITY_INT32)0xFFFFFFFF); +#endif +} + +void testPrintNumbersUnsigned32(void) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1", 1); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1500000000", 1500000000); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("2147483648", (UNITY_UINT32)0x80000000); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("4294967295", (UNITY_UINT32)0xFFFFFFFF); +#endif +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_integers_64.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_integers_64.c new file mode 100644 index 000000000..e12566e83 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_integers_64.c @@ -0,0 +1,773 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include "unity.h" +#define TEST_INSTANCES +#include "self_assessment_utils.h" + +static int SetToOneToFailInTearDown; +static int SetToOneMeanWeAlreadyCheckedThisGuy; + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + endPutcharSpy(); /* Stop suppressing test output */ + if (SetToOneToFailInTearDown == 1) + { + /* These will be skipped internally if already failed/ignored */ + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + TEST_IGNORE_MESSAGE("<= Ignored in tearDown"); + } + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +void testInt64ArrayWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualSmallDelta[] = {12345001, -12344996, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + TEST_ASSERT_INT64_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, actualBigDelta, 3); +#endif +} + +void testInt64ArrayWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualSmallDelta[] = {12345001, -12344996, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); +#endif +} + +void tesUInt64ArrayNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayNotWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaPointless(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, actualBigDelta, 0); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaPointlessAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaExpectedNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaExpectedNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaActualNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaActualNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testInt64ArrayWithinDeltaSamePointer(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3); +#endif +} + +void testInt64ArrayWithinDeltaSamePointerAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; + + TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +#endif +} + +void testUInt64ArrayWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualSmallDelta[] = {12345001, 12344996, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, actualBigDelta, 3); +#endif +} + +void testUInt64ArrayWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualSmallDelta[] = {12345001, 12344996, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); +#endif +} + +void testUInt64ArrayNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayNotWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaPointless(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, actualBigDelta, 0); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaPointlessAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaExpectedNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaExpectedNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaActualNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, NULL, 3); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaActualNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testUInt64ArrayWithinDeltaSamePointer(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3); +#endif +} + +void testUInt64ArrayWithinDeltaSamePointerAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; + + TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); +#endif +} + +void testHEX64ArrayWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualSmallDelta[] = {0xABCD123500000000, 0xABCD112100000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x100000000, expected, actualSmallDelta, 3); + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, actualBigDelta, 3); +#endif +} + +void testHEX64ArrayWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualSmallDelta[] = {0xABCD123500000000, 0xABCD112100000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x100000000, expected, actualSmallDelta, 3, "Custom Message."); + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, actualBigDelta, 3, "Custom Message."); +#endif +} + +void testHEX64ArrayNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x100000000, expected, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayNotWithinDeltaAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x100000000, expected, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaPointless(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, actualBigDelta, 0); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaPointlessAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, actualBigDelta, 0, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaExpectedNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, NULL, actualBigDelta, 3); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaExpectedNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, NULL, actualBigDelta, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaActualNull(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, NULL, 3); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaActualNullAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, NULL, 3, "Custom Message."); + VERIFY_FAILS_END +#endif +} + +void testHEX64ArrayWithinDeltaSamePointer(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, expected, 3); +#endif +} + +void testHEX64ArrayWithinDeltaSamePointerAndMessage(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; + + TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, expected, 3, "Custom Message."); +#endif +} + +void testEqualHex64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 v0, v1; + UNITY_UINT64 *p0, *p1; + + v0 = 0x9876543201234567; + v1 = 0x9876543201234567; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, 0x9876543201234567); + TEST_ASSERT_EQUAL_HEX64(v0, v1); + TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, v1); + TEST_ASSERT_EQUAL_HEX64(v0, 0x9876543201234567); + TEST_ASSERT_EQUAL_HEX64(*p0, v1); + TEST_ASSERT_EQUAL_HEX64(*p0, *p1); + TEST_ASSERT_EQUAL_HEX64(*p0, 0x9876543201234567); +#endif +} + +void testEqualUint64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 v0, v1; + UNITY_UINT64 *p0, *p1; + + v0 = 0x9876543201234567; + v1 = 0x9876543201234567; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, 0x9876543201234567); + TEST_ASSERT_EQUAL_UINT64(v0, v1); + TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, v1); + TEST_ASSERT_EQUAL_UINT64(v0, 0x9876543201234567); + TEST_ASSERT_EQUAL_UINT64(*p0, v1); + TEST_ASSERT_EQUAL_UINT64(*p0, *p1); + TEST_ASSERT_EQUAL_UINT64(*p0, 0x9876543201234567); +#endif +} + +void testEqualInt64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 v0, v1; + UNITY_INT64 *p0, *p1; + + v0 = (UNITY_INT64)0x9876543201234567; + v1 = (UNITY_INT64)0x9876543201234567; + p0 = &v0; + p1 = &v1; + + TEST_ASSERT_EQUAL_INT64(0x9876543201234567, 0x9876543201234567); + TEST_ASSERT_EQUAL_INT64(v0, v1); + TEST_ASSERT_EQUAL_INT64(0x9876543201234567, v1); + TEST_ASSERT_EQUAL_INT64(v0, 0x9876543201234567); + TEST_ASSERT_EQUAL_INT64(*p0, v1); + TEST_ASSERT_EQUAL_INT64(*p0, *p1); + TEST_ASSERT_EQUAL_INT64(*p0, 0x9876543201234567); +#endif +} + + +void testNotEqualHex64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 v0, v1; + + v0 = 9000000000; + v1 = 9100000000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX64(v0, v1); + VERIFY_FAILS_END +#endif +} + +void testNotEqualUint64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_UINT64 v0, v1; + + v0 = 9000000000; + v1 = 9100000000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_UINT64(v0, v1); + VERIFY_FAILS_END +#endif +} + +void testNotEqualInt64s(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 v0, v1; + + v0 = -9000000000; + v1 = 9100000000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_INT64(v0, v1); + VERIFY_FAILS_END +#endif +} + +void testNotEqualHex64sIfSigned(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + UNITY_INT64 v0, v1; + + v0 = -9000000000; + v1 = 9000000000; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_HEX64(v0, v1); + VERIFY_FAILS_END +#endif +} + +void testHEX64sWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE); + TEST_ASSERT_HEX64_WITHIN(5, 5000, 4996); + TEST_ASSERT_HEX64_WITHIN(5, 5000, 5005); +#endif +} + +void testHEX64sNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC); + VERIFY_FAILS_END +#endif +} + +void testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_HEX64_WITHIN(5, 1, -1); + VERIFY_FAILS_END +#endif +} + +void testUINT64sWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE); + TEST_ASSERT_UINT64_WITHIN(5, 5000, 4996); + TEST_ASSERT_UINT64_WITHIN(5, 5000, 5005); +#endif +} + +void testUINT64sNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC); + VERIFY_FAILS_END +#endif +} + +void testUINT64sNotWithinDeltaEvenThoughASignedIntWouldPass(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_UINT64_WITHIN(5, 1, -1); + VERIFY_FAILS_END +#endif +} + +void testINT64sWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE); + TEST_ASSERT_INT64_WITHIN(5, 5000, 4996); + TEST_ASSERT_INT64_WITHIN(5, 5000, 5005); +#endif +} + +void testINT64sNotWithinDelta(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC); + VERIFY_FAILS_END +#endif +} + +void testINT64sNotWithinDeltaAndDifferenceOverflows(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_INT64_WITHIN(1, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF); + VERIFY_FAILS_END +#endif +} + +void testPrintNumbersInt64(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + #ifndef USING_OUTPUT_SPY + TEST_IGNORE(); + #else + TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("10000000000", 10000000000); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("-9223372036854775808", (UNITY_INT)0x8000000000000000); + TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (UNITY_INT)0xFFFFFFFFFFFFFFFF); + #endif +#endif +} + +void testPrintNumbersUInt64(void) +{ +#ifndef UNITY_SUPPORT_64 + TEST_IGNORE(); +#else + #ifndef USING_OUTPUT_SPY + TEST_IGNORE(); + #else + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("70000000000", 70000000000); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("9223372036854775808", (UNITY_UINT)0x8000000000000000); + TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("18446744073709551615", (UNITY_UINT)0xFFFFFFFFFFFFFFFF); + #endif +#endif +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_memory.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_memory.c new file mode 100644 index 000000000..b3cff1319 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_memory.c @@ -0,0 +1,81 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include "unity.h" +#define TEST_INSTANCES +#include "self_assessment_utils.h" + +static int SetToOneToFailInTearDown; +static int SetToOneMeanWeAlreadyCheckedThisGuy; + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + endPutcharSpy(); /* Stop suppressing test output */ + if (SetToOneToFailInTearDown == 1) + { + /* These will be skipped internally if already failed/ignored */ + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + TEST_IGNORE_MESSAGE("<= Ignored in tearDown"); + } + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +void testEqualMemory(void) +{ + const char *testString = "whatever"; + + TEST_ASSERT_EQUAL_MEMORY(testString, testString, 8); + TEST_ASSERT_EQUAL_MEMORY("whatever", "whatever", 8); + TEST_ASSERT_EQUAL_MEMORY("whatever", testString, 8); + TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 8); + TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 2); + TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 1); +} + +void testNotEqualMemory1(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY("foo", "bar", 3); + VERIFY_FAILS_END +} + +void testNotEqualMemory2(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY("fool", "food", 4); + VERIFY_FAILS_END +} + +void testNotEqualMemory3(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY(NULL, "food", 4); + VERIFY_FAILS_END +} + +void testNotEqualMemory4(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY("fool", NULL, 4); + VERIFY_FAILS_END +} + +void testNotEqualMemoryLengthZero(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 0); + VERIFY_FAILS_END +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_parameterized.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_parameterized.c new file mode 100644 index 000000000..3129817e9 --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_parameterized.c @@ -0,0 +1,171 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include <setjmp.h> +#include <stdio.h> +#include "unity.h" + +/* Support for Meta Test Rig */ +#define TEST_CASE(...) + +/* Include Passthroughs for Linking Tests */ +void putcharSpy(int c) { (void)putchar(c);} +void flushSpy(void) {} + +#define EXPECT_ABORT_BEGIN \ + if (TEST_PROTECT()) \ + { + +#define VERIFY_FAILS_END \ + } \ + Unity.CurrentTestFailed = (Unity.CurrentTestFailed != 0) ? 0 : 1; \ + if (Unity.CurrentTestFailed == 1) { \ + SetToOneMeanWeAlreadyCheckedThisGuy = 1; \ + UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \ + UNITY_OUTPUT_CHAR(':'); \ + UnityPrint(Unity.CurrentTestName); \ + UnityPrint(":FAIL: [[[[ Test Should Have Failed But Did Not ]]]]"); \ + UNITY_OUTPUT_CHAR('\n'); \ + } + +#define VERIFY_IGNORES_END \ + } \ + Unity.CurrentTestFailed = (Unity.CurrentTestIgnored != 0) ? 0 : 1; \ + Unity.CurrentTestIgnored = 0; \ + if (Unity.CurrentTestFailed == 1) { \ + SetToOneMeanWeAlreadyCheckedThisGuy = 1; \ + UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \ + UNITY_OUTPUT_CHAR(':'); \ + UnityPrint(Unity.CurrentTestName); \ + UnityPrint(":FAIL: [[[[ Test Should Have Ignored But Did Not ]]]]"); \ + UNITY_OUTPUT_CHAR('\n'); \ + } + +static int SetToOneToFailInTearDown; +static int SetToOneMeanWeAlreadyCheckedThisGuy; +static unsigned NextExpectedStringIndex; +static unsigned NextExpectedCharIndex; + +void suiteSetUp(void) +{ + NextExpectedStringIndex = 0; + NextExpectedCharIndex = 0; +} + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + if (SetToOneToFailInTearDown == 1) + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +TEST_CASE(0) +TEST_CASE(44) +TEST_CASE((90)+9) +void test_TheseShouldAllPass(int Num) +{ + TEST_ASSERT_TRUE(Num < 100); +} + +TEST_CASE(3) +TEST_CASE(77) +TEST_CASE( (99) + 1 - (1)) +void test_TheseShouldAllFail(int Num) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_TRUE(Num > 100); + VERIFY_FAILS_END +} + +TEST_CASE(1) +TEST_CASE(44) +TEST_CASE(99) +TEST_CASE(98) +void test_TheseAreEveryOther(int Num) +{ + if (Num & 1) + { + EXPECT_ABORT_BEGIN + TEST_ASSERT_TRUE(Num > 100); + VERIFY_FAILS_END + } + else + { + TEST_ASSERT_TRUE(Num < 100); + } +} + +void test_NormalPassesStillWork(void) +{ + TEST_ASSERT_TRUE(1); +} + +void test_NormalFailsStillWork(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_TRUE(0); + VERIFY_FAILS_END +} + +TEST_CASE(0, "abc") +TEST_CASE(1, "{") +TEST_CASE(2, "}") +TEST_CASE(3, ";") +TEST_CASE(4, "\"quoted\"") +void test_StringsArePreserved(unsigned index, const char * str) +{ + static const char * const expected[] = + { + "abc", + "{", + "}", + ";", + "\"quoted\"" + }; + + /* Ensure that no test cases are skipped by tracking the next expected index */ + TEST_ASSERT_EQUAL_UINT32(NextExpectedStringIndex, index); + TEST_ASSERT_LESS_THAN(sizeof(expected) / sizeof(expected[0]), index); + TEST_ASSERT_EQUAL_STRING(expected[index], str); + + NextExpectedStringIndex++; +} + +TEST_CASE(0, 'x') +TEST_CASE(1, '{') +TEST_CASE(2, '}') +TEST_CASE(3, ';') +TEST_CASE(4, '\'') +TEST_CASE(5, '"') +void test_CharsArePreserved(unsigned index, char c) +{ + static const char expected[] = + { + 'x', + '{', + '}', + ';', + '\'', + '"' + }; + + /* Ensure that no test cases are skipped by tracking the next expected index */ + TEST_ASSERT_EQUAL_UINT32(NextExpectedCharIndex, index); + TEST_ASSERT_LESS_THAN(sizeof(expected) / sizeof(expected[0]), index); + TEST_ASSERT_EQUAL(expected[index], c); + + NextExpectedCharIndex++; +} diff --git a/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_strings.c b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_strings.c new file mode 100644 index 000000000..964c5536d --- /dev/null +++ b/FreeRTOS-Plus/Test/CMock/vendor/unity/test/tests/test_unity_strings.c @@ -0,0 +1,329 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#include "unity.h" +#define TEST_INSTANCES +#include "self_assessment_utils.h" + +static int SetToOneToFailInTearDown; +static int SetToOneMeanWeAlreadyCheckedThisGuy; + +void setUp(void) +{ + SetToOneToFailInTearDown = 0; + SetToOneMeanWeAlreadyCheckedThisGuy = 0; +} + +void tearDown(void) +{ + endPutcharSpy(); /* Stop suppressing test output */ + if (SetToOneToFailInTearDown == 1) + { + /* These will be skipped internally if already failed/ignored */ + TEST_FAIL_MESSAGE("<= Failed in tearDown"); + TEST_IGNORE_MESSAGE("<= Ignored in tearDown"); + } + if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) + { + UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); + UNITY_OUTPUT_CHAR('\n'); + } +} + +void testEqualStrings(void) +{ + const char *testString = "foo"; + + TEST_ASSERT_EQUAL_STRING(testString, testString); + TEST_ASSERT_EQUAL_STRING_MESSAGE("foo", "foo", "foo isn't foo"); + TEST_ASSERT_EQUAL_STRING("foo", testString); + TEST_ASSERT_EQUAL_STRING(testString, "foo"); + TEST_ASSERT_EQUAL_STRING("", ""); +} + +void testEqualStringsLen(void) +{ + const char *testString = "foobar"; + TEST_ASSERT_EQUAL_STRING_LEN(testString, testString, strlen(testString)); + TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE("foobar", "foobaz", 5, "fooba isn't fooba"); + TEST_ASSERT_EQUAL_STRING_LEN("foo", testString, 3); + TEST_ASSERT_EQUAL_STRING_LEN(testString, "foo", 3); + TEST_ASSERT_EQUAL_STRING_LEN("", "", 3); +} + +void testEqualStringsWithCarriageReturnsAndLineFeeds(void) +{ + const char *testString = "foo\r\nbar"; + + TEST_ASSERT_EQUAL_STRING(testString, testString); + TEST_ASSERT_EQUAL_STRING("foo\r\nbar", "foo\r\nbar"); + TEST_ASSERT_EQUAL_STRING("foo\r\nbar", testString); + TEST_ASSERT_EQUAL_STRING(testString, "foo\r\nbar"); + TEST_ASSERT_EQUAL_STRING("", ""); +} + +void testNotEqualString1(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("foo", "bar"); + VERIFY_FAILS_END +} + +void testNotEqualStringLen1(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN("foobar", "foobaz", 6); + VERIFY_FAILS_END +} + +void testNotEqualString2(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("foo", ""); + VERIFY_FAILS_END +} + +void testNotEqualStringLen2(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN("foo", "", 3); + VERIFY_FAILS_END +} + +void testNotEqualString3(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("", "bar"); + VERIFY_FAILS_END +} + +void testNotEqualStringLen3(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN("", "bar", 3); + VERIFY_FAILS_END +} + +void testNotEqualString4(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("bar\r", "bar\n"); + VERIFY_FAILS_END +} + +void testNotEqualStringLen4(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN("ba\r\x16", "ba\r\n", 4); + VERIFY_FAILS_END +} + +void testNotEqualString5(void) +{ + const char str1[] = { 0x41, 0x42, 0x03, 0x00 }; + const char str2[] = { 0x41, 0x42, 0x04, 0x00 }; + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING(str1, str2); + VERIFY_FAILS_END +} + +void testNotEqualString_ExpectedStringIsNull(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING(NULL, "bar"); + VERIFY_FAILS_END +} + +void testNotEqualStringLen_ExpectedStringIsNull(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN(NULL, "bar", 1); + VERIFY_FAILS_END +} + +void testNotEqualString_ActualStringIsNull(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("foo", NULL); + VERIFY_FAILS_END +} + +void testNotEqualStringLen_ActualStringIsNull(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_LEN("foo", NULL, 1); + VERIFY_FAILS_END +} + +void testNotEqualString_ExpectedStringIsLonger(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("foo2", "foo"); + VERIFY_FAILS_END +} + +void testNotEqualString_ActualStringIsLonger(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING("foo", "foo2"); + VERIFY_FAILS_END +} + +void testEqualStringArrays(void) +{ + const char *testStrings[] = { "foo", "boo", "woo", "moo" }; + const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; + + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, expStrings, 3); + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 3); + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 2); + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 1); +} + +void testNotEqualStringArray1(void) +{ + const char *testStrings[] = { "foo", "boo", "woo", "moo" }; + const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringArray2(void) +{ + const char *testStrings[] = { "zoo", "boo", "woo", "moo" }; + const char *expStrings[] = { "foo", "boo", "woo", "moo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringArray3(void) +{ + const char *testStrings[] = { "foo", "boo", "woo", NULL }; + const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringArray4(void) +{ + const char *testStrings[] = { "foo", "boo", "woo", "moo" }; + const char *expStrings[] = { "foo", NULL, "woo", "moo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringArray5(void) +{ + const char **testStrings = NULL; + const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringArray6(void) +{ + const char *testStrings[] = { "foo", "boo", "woo", "zoo" }; + const char **expStrings = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); + VERIFY_FAILS_END +} + +void testEqualStringArrayIfBothNulls(void) +{ + const char **testStrings = NULL; + const char **expStrings = NULL; + + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); +} + +void testNotEqualStringArrayLengthZero(void) +{ + const char *testStrings[] = {NULL}; + const char **expStrings = NULL; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 0); + VERIFY_FAILS_END +} + +void testEqualStringEachEqual(void) +{ + const char *testStrings1[] = { "foo", "foo", "foo", "foo" }; + const char *testStrings2[] = { "boo", "boo", "boo", "zoo" }; + const char *testStrings3[] = { "", "", "", "" }; + + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings1, 4); + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings1, 1); + TEST_ASSERT_EACH_EQUAL_STRING("boo", testStrings2, 3); + TEST_ASSERT_EACH_EQUAL_STRING("", testStrings3, 4); +} + +void testNotEqualStringEachEqual1(void) +{ + const char *testStrings[] = { "foo", "foo", "foo", "moo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringEachEqual2(void) +{ + const char *testStrings[] = { "boo", "foo", "foo", "foo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringEachEqual3(void) +{ + const char *testStrings[] = { "foo", "foo", "foo", NULL }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringEachEqual4(void) +{ + const char *testStrings[] = { "foo", "foo", "woo", "foo" }; + + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_STRING("foo", testStrings, 4); + VERIFY_FAILS_END +} + +void testNotEqualStringEachEqual5(void) +{ + EXPECT_ABORT_BEGIN + TEST_ASSERT_EACH_EQUAL_STRING("foo", NULL, 1); + VERIFY_FAILS_END +} + +void testCstringsEscapeSequence(void) +{ +#ifndef USING_OUTPUT_SPY + TEST_IGNORE(); +#else + startPutcharSpy(); + UnityPrint("\x16\x10"); + endPutcharSpy(); + TEST_ASSERT_EQUAL_STRING("\\x16\\x10", getBufferPutcharSpy()); +#endif +} |