From f9ab15d02ac4ab14edc6f127305112d8f4cc7a60 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=88=98=E4=BC=9F?= <2439423861@qq.com> Date: Sun, 26 Mar 2023 22:35:25 +0800 Subject: [PATCH] =?UTF-8?q?(=E6=B5=B7=E5=8D=97=E5=A4=A7=E5=AD=A6=E5=88=98?= =?UTF-8?q?=E4=BC=9F)=20[=E6=96=B0=E5=A2=9E]=20=E5=8D=95=E5=85=83=E6=B5=8B?= =?UTF-8?q?=E8=AF=95=E3=80=81=E4=BB=A3=E7=A0=81=E8=A6=86=E7=9B=96=E7=8E=87?= =?UTF-8?q?=E5=8F=8A=E5=85=B6=E4=BD=BF=E7=94=A8=E8=AF=B4=E6=98=8E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 84 +- applications/main.c | 16 +- applications/src/SConscript | 15 + applications/src/jswyll_packet.c | 37 + applications/src/jswyll_packet.h | 29 + applications/test/SConscript | 15 + applications/test/gcov/SConscript | 15 + applications/{ => test/gcov}/gcov_gcc.c | 0 applications/{ => test/gcov}/gcov_gcc.h | 0 applications/{ => test/gcov}/gcov_printf.c | 0 applications/{ => test/gcov}/gcov_public.c | 34 +- applications/{ => test/gcov}/gcov_public.h | 2 +- applications/test/test_all.c | 28 + applications/test/test_all.h | 209 ++ applications/test/test_jswyll_packet.c | 48 + applications/test/test_jswyll_packet.h | 6 + applications/test/unity/SConscript | 15 + applications/test/unity/unity.c | 2119 ++++++++++++++++++++ applications/test/unity/unity.h | 661 ++++++ applications/test/unity/unity_internals.h | 1053 ++++++++++ applications/test/unity_config.h | 10 + applications/test/write_gcda.py | 14 + figures/jswyll_test_packet_lcov.png | Bin 0 -> 64474 bytes makefile.targets | 5 +- rtconfig.py | 4 +- 25 files changed, 4377 insertions(+), 42 deletions(-) create mode 100644 applications/src/SConscript create mode 100644 applications/src/jswyll_packet.c create mode 100644 applications/src/jswyll_packet.h create mode 100644 applications/test/SConscript create mode 100644 applications/test/gcov/SConscript rename applications/{ => test/gcov}/gcov_gcc.c (100%) rename applications/{ => test/gcov}/gcov_gcc.h (100%) rename applications/{ => test/gcov}/gcov_printf.c (100%) rename applications/{ => test/gcov}/gcov_public.c (94%) rename applications/{ => test/gcov}/gcov_public.h (99%) create mode 100644 applications/test/test_all.c create mode 100644 applications/test/test_all.h create mode 100644 applications/test/test_jswyll_packet.c create mode 100644 applications/test/test_jswyll_packet.h create mode 100644 applications/test/unity/SConscript create mode 100644 applications/test/unity/unity.c create mode 100644 applications/test/unity/unity.h create mode 100644 applications/test/unity/unity_internals.h create mode 100644 applications/test/unity_config.h create mode 100644 applications/test/write_gcda.py create mode 100644 figures/jswyll_test_packet_lcov.png diff --git a/README.md b/README.md index 753065e..2622a94 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,73 @@ # QEMU VExpress A9板级支持包说明 +## 单元测试 & 代码覆盖率 + +### 相关目录结构 + +```sh +工程主目录 +├── applications/ +│ ├── src/ +│ │ ├── SConscript # 需要添加覆盖率测试参数 +│ │ ├── jswyll_packet.c # 应用代码 +│ │ └── jswyll_packet.h +│ ├── test/ +│ │ ├── gcov/ # 代码覆盖率收集 +│ │ ├── unity/ # 单元测试库，参见https://github.com/ThrowTheSwitch/Unity +│ │ ├── test_all.c # 测试总入口 +│ │ ├── test_all.h +│ │ ├── test_jswyll_packet.c # 测试jswyll_packet +│ │ ├── test_jswyll_packet.h +│ │ ├── unity_config.h # 单元测试配置 +│ │ └── write_gcda.py # 脚本，用于将打印的gcda的Hex数据写入对应的文件 +│ ├── main.c # 应用主入口 +├── build/ +│ ├── lcov/ +│ │ ├── index.html # 代码覆盖率输出结果首页 +├── rtconfig.py # 需要添加覆盖率测试参数 +``` + +### 首次使用 + +1. 下载Git；下载[lcov](https://github.com/linux-test-project/lcov/releases "Releases · linux-test-project/lcov") 版本v1.15及以上，下载、解压后将lcov文件夹下的bin/文件夹添加到PATH环境变量（重启电脑） +2. 新建文件夹，用于编写应用代码（被测试代码，例如：`applications/src`） +3. 从[applications/SConscript](applications/SConscript "applications/SConscript")将编译脚本到第1步的路径下，并将第8行修改为： + + ```python + group = DefineGroup('文件夹名', src, depend = [''], CPPPATH = CPPPATH, LOCAL_CFLAGS=' --coverage') + ``` + + > 其中`--coverage`等价于`-fprofile-arcs -ftest-coverage`这表示将这个文件夹的源码添加覆盖率测试（插桩）。 +4. 修改[rtconfig.py](rtconfig.py "rtconfig.py")的LFLAGS，`LFLAGS = DEVICE + ' -nostartfiles -Wl,--gc-sections,-Map=rtthread.map,-cref,-u,system_vectors --coverage' + ' -T %s' % LINK_SCRIPT`，使链接时将相关的代码也使用覆盖率测试。 + +5. 在除了第1步被测试以外的文件夹下编写测试代码，调用被测试代码。 + + ```c + __gcov_call_constructors(); + + test_xxx(); + + __gcov_exit(); + ``` + +6. 编译并运行代码，将生成的gcda文件的内容放在输出的提示路径上 + +7. 在工程主目录右键，选择`Git Bash Here`，输入 + + ```sh + lcov -c -d . --rc lcov_branch_coverage=1 -o build/test.coverage --gcov-tool 编译器路径/bin/arm-none-eabi-gcov && genhtml --branch-coverage build/test.coverage -o build/lcov + ``` + + > **注意：**编译器的路径应和编译代码时的版本一致。将`编译器路径/bin/`添加到系统环境变量（然后重启电脑），则上述命令可以省去`编译器路径/bin/` + +8. 用浏览器打开`build/lcov/index.html`，查看被测试代码的覆盖结果，示例代码测试结果： + +![示例代码测试结果.png](figures/jswyll_test_packet_lcov.png "示例代码测试结果") + +### 后续使用 + +修改被测试代码或测试代码后，重复上述步骤6\~8。 + ## 1 简介 - Versatile Express系统由ARM Ltd提供，作为CortexA9四核处理器的开发环境，硬件由uATX主板和CoreTile Express A9x4子板组成。有关该系统的详细信息，可以访问 [ARM官方页面][1] 。 @@ -24,14 +92,10 @@ ![image-20220626114422344](figures/image-20220626114422344.png) - - - 如果编译正确无误，会产生rtthread.elf、rtthread.bin文件。在QEMU中一般使用elf方式来运行，所以只需要使用rtthread.elf文件即可。 ![image-20220626114611158](figures/image-20220626114611158.png) - - - 当前测试使用的RT-Thread Env版本 ![image-20220626113747893](figures/image-20220626113747893.png) @@ -77,9 +141,7 @@ ![image-20220626125837849](figures/image-20220626125837849.png) - - -### 3.3 Windows ENV下运行RT-Thread +### 3.3 Windows ENV下运行RT-Thread #### 3.3.1 启动QEMU运行 @@ -114,9 +176,7 @@ msh />Terminate batch job (Y/N)? y 参考文档：[使用VS Code开发RT-Thread](https://www.rt-thread.org/document/site/#/rt-thread-version/rt-thread-standard/application-note/setup/qemu/vscode/an0021-qemu-vscode?id=%e4%bd%bf%e7%94%a8-vs-code-%e5%bc%80%e5%8f%91-rt-thread) - - -### 3.5 Linux下执行RT-Thread +### 3.5 Linux下执行RT-Thread #### 3.5.1 安装QEMU工具包 @@ -223,8 +283,6 @@ msh /> msh />QEMU: Terminated ``` - - ## 4 支持情况 | 驱动 | 支持情况 | 备注 | @@ -236,8 +294,6 @@ msh />QEMU: Terminated | Mouse | 支持 | | | EMAC | 支持 | | - - ## 5 联系人信息 维护人：[bernard][4] [recan-li][5] diff --git a/applications/main.c b/applications/main.c index 5e00781..125f28d 100644 --- a/applications/main.c +++ b/applications/main.c @@ -12,22 +12,16 @@ #include #include -#include "gcov_public.h" +#include "test_all.h" + int main(void) { + printf("unity_run_all_tests start...\n"); - __gcov_call_constructors(); - - rt_kprintf("code1_function: %d\n", 5); - rt_kprintf("code1_function: %d\n", 11); - - rt_kprintf("code2_function: %d\n", 23); - rt_kprintf("code2_function: %d\n", 44); - - __gcov_exit(); + unity_run_all_tests(); - printf("Hello RT-Thread!\n"); + printf("unity_run_all_tests end.\n"); return 0; } diff --git a/applications/src/SConscript b/applications/src/SConscript new file mode 100644 index 0000000..5662aea --- /dev/null +++ b/applications/src/SConscript @@ -0,0 +1,15 @@ +import os +from building import * + +cwd = GetCurrentDir() +src = Glob('*.c') + Glob('*.cpp') +CPPPATH = [cwd] + +group = DefineGroup('src', src, depend = [''], CPPPATH = CPPPATH, LOCAL_CFLAGS=' --coverage') + +list = os.listdir(cwd) +for item in list: + if os.path.isfile(os.path.join(cwd, item, 'SConscript')): + group = group + SConscript(os.path.join(item, 'SConscript')) + +Return('group') diff --git a/applications/src/jswyll_packet.c b/applications/src/jswyll_packet.c new file mode 100644 index 0000000..3979e32 --- /dev/null +++ b/applications/src/jswyll_packet.c @@ -0,0 +1,37 @@ +#include + +#include "jswyll_packet.h" + +/** 应答包帧头 */ +static const uint8_t PACKET_RES_HEADERS[] = {0xa5, 0x5a}; + +/** + * @brief 解析jswyll iap协议应答包 + * + * @param packet 应答包结构体 + * @param ch 每次收到的一个字节 + * @retval true 已收到完整的应答包 + * @retval false 尚未收到完整的应答包 + */ +bool jswyll_packet_parse(jswyll_packet_t *packet, char ch) +{ + packet->rx_bytes[packet->rx_index++] = ch; + if (packet->rx_index <= sizeof(PACKET_RES_HEADERS)) + { + if (ch != PACKET_RES_HEADERS[packet->rx_index - 1]) + { + packet->rx_index = 0; + } + } + else if (packet->rx_index == 4) + { + packet->rx_len = (packet->rx_bytes[3] << 8) + packet->rx_bytes[2]; + } + else if (packet->rx_index == packet->rx_len) + { + packet->rx_index = 0; + return true; + } + + return false; +} diff --git a/applications/src/jswyll_packet.h b/applications/src/jswyll_packet.h new file mode 100644 index 0000000..f2b65b1 --- /dev/null +++ b/applications/src/jswyll_packet.h @@ -0,0 +1,29 @@ +#ifndef __JSWYLL_IAP_PACKET_H__ +#define __JSWYLL_IAP_PACKET_H__ + +#include +#include + +#define JSWYLL_PACKET_BUFFER_SIZE 1024 + +typedef struct jswyll_packet +{ + /** 应答包的字节数 */ + uint16_t rx_len; + /** 已接收到应答包的字节数 */ + uint16_t rx_index; + /** 应答包接收缓冲区 */ + uint8_t rx_bytes[JSWYLL_PACKET_BUFFER_SIZE + 16]; +} jswyll_packet_t; + +/** + * @brief 解析jswyll iap协议应答包 + * + * @param packet 应答包结构体 + * @param ch 每次收到的一个字节 + * @retval true 已收到完整的应答包 + * @retval false 尚未收到完整的应答包 + */ +bool jswyll_packet_parse(jswyll_packet_t *packet, char ch); + +#endif \ No newline at end of file diff --git a/applications/test/SConscript b/applications/test/SConscript new file mode 100644 index 0000000..00affce --- /dev/null +++ b/applications/test/SConscript @@ -0,0 +1,15 @@ +import os +from building import * + +cwd = GetCurrentDir() +src = Glob('*.c') + Glob('*.cpp') +CPPPATH = [cwd] + +group = DefineGroup('test', src, depend = [''], CPPPATH = CPPPATH) + +list = os.listdir(cwd) +for item in list: + if os.path.isfile(os.path.join(cwd, item, 'SConscript')): + group = group + SConscript(os.path.join(item, 'SConscript')) + +Return('group') diff --git a/applications/test/gcov/SConscript b/applications/test/gcov/SConscript new file mode 100644 index 0000000..5399d26 --- /dev/null +++ b/applications/test/gcov/SConscript @@ -0,0 +1,15 @@ +import os +from building import * + +cwd = GetCurrentDir() +src = Glob('*.c') + Glob('*.cpp') +CPPPATH = [cwd] + +group = DefineGroup('gcov', src, depend = [''], CPPPATH = CPPPATH) + +list = os.listdir(cwd) +for item in list: + if os.path.isfile(os.path.join(cwd, item, 'SConscript')): + group = group + SConscript(os.path.join(item, 'SConscript')) + +Return('group') diff --git a/applications/gcov_gcc.c b/applications/test/gcov/gcov_gcc.c similarity index 100% rename from applications/gcov_gcc.c rename to applications/test/gcov/gcov_gcc.c diff --git a/applications/gcov_gcc.h b/applications/test/gcov/gcov_gcc.h similarity index 100% rename from applications/gcov_gcc.h rename to applications/test/gcov/gcov_gcc.h diff --git a/applications/gcov_printf.c b/applications/test/gcov/gcov_printf.c similarity index 100% rename from applications/gcov_printf.c rename to applications/test/gcov/gcov_printf.c diff --git a/applications/gcov_public.c b/applications/test/gcov/gcov_public.c similarity index 94% rename from applications/gcov_public.c rename to applications/test/gcov/gcov_public.c index b223f9a..a0a6c75 100644 --- a/applications/gcov_public.c +++ b/applications/test/gcov/gcov_public.c @@ -299,11 +299,14 @@ void __gcov_exit(void) gcov_convert_to_gcda(buffer, listptr->info); #if defined(GCOV_OPT_PRINT_STATUS) || defined(GCOV_OPT_OUTPUT_SERIAL_HEXDUMP) - GCOV_PRINT_STR("Emitting "); - GCOV_PRINT_NUM(bytesNeeded); - GCOV_PRINT_STR(" bytes for "); + // GCOV_PRINT_STR("Emitting "); + // GCOV_PRINT_NUM(bytesNeeded); + // GCOV_PRINT_STR(" bytes for "); + // GCOV_PRINT_STR(gcov_info_filename(listptr->info)); + // GCOV_PRINT_STR("\n"); + GCOV_PRINT_STR("with open(r'"); GCOV_PRINT_STR(gcov_info_filename(listptr->info)); - GCOV_PRINT_STR("\n"); + GCOV_PRINT_STR("', 'wb') as file:\r\n file.write(b'"); #endif #ifdef GCOV_OPT_OUTPUT_BINARY_FILE @@ -365,17 +368,22 @@ void __gcov_exit(void) /* If your embedded system does not support printf or an imitation, * you'll need to change this code. */ - for (u32 i = 0; i < bytesNeeded; i++) + // for (u32 i = 0; i < bytesNeeded; i++) + // { + // if (i % 16 == 0) + // GCOV_PRINT_HEXDUMP_ADDR(i); + // GCOV_PRINT_HEXDUMP_DATA((unsigned char)(((unsigned char *)buffer)[i])); + // if (i % 16 == 15) + // GCOV_PRINT_STR("\n"); + // } + // GCOV_PRINT_STR("\n"); + // GCOV_PRINT_STR(gcov_info_filename(listptr->info)); + // GCOV_PRINT_STR("\n"); + for (uint32_t i = 0; i < bytesNeeded; i++) { - if (i % 16 == 0) - GCOV_PRINT_HEXDUMP_ADDR(i); - GCOV_PRINT_HEXDUMP_DATA((unsigned char)(((unsigned char *)buffer)[i])); - if (i % 16 == 15) - GCOV_PRINT_STR("\n"); + gcov_printf("\\x%02X", ((unsigned char *)buffer)[i]); } - GCOV_PRINT_STR("\n"); - GCOV_PRINT_STR(gcov_info_filename(listptr->info)); - GCOV_PRINT_STR("\n"); + GCOV_PRINT_STR("')\n"); #endif // GCOV_OPT_OUTPUT_SERIAL_HEXDUMP /* Other output methods might be imagined, diff --git a/applications/gcov_public.h b/applications/test/gcov/gcov_public.h similarity index 99% rename from applications/gcov_public.h rename to applications/test/gcov/gcov_public.h index 4adbf43..09bdc6d 100644 --- a/applications/gcov_public.h +++ b/applications/test/gcov/gcov_public.h @@ -164,7 +164,7 @@ typedef FILE *GCOV_FILE_TYPE; * for GCOV_PRINT_STR and GCOV_PRINT_NUM. * Can be combined with other GCOV_OPT_OUTPUT_* options. */ -// #define GCOV_OPT_OUTPUT_SERIAL_HEXDUMP +#define GCOV_OPT_OUTPUT_SERIAL_HEXDUMP /* Function to print a string without newline. * Not used if you don't define either GCOV_OPT_PRINT_STATUS diff --git a/applications/test/test_all.c b/applications/test/test_all.c new file mode 100644 index 0000000..dd40c86 --- /dev/null +++ b/applications/test/test_all.c @@ -0,0 +1,28 @@ +#include "unity.h" +#include "test_all.h" + +#include "test_jswyll_packet.h" +#include "gcov_public.h" + +void setUp(void) +{ + // set stuff up here + __gcov_call_constructors(); +} + +void tearDown(void) +{ + // clean stuff up here + __gcov_exit(); +} + +void unity_run_all_tests(void) +{ + UNITY_BEGIN(); + setUp(); + + RUN_TEST(test_jswyll_packet); + + tearDown(); + UNITY_END(); +} diff --git a/applications/test/test_all.h b/applications/test/test_all.h new file mode 100644 index 0000000..4f168e4 --- /dev/null +++ b/applications/test/test_all.h @@ -0,0 +1,209 @@ +// Copyright 2016-2018 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +#pragma once + +#include +#include + +// This file gets included from unity.h via unity_internals.h via unity_config.h +// It is inside #ifdef __cplusplus / extern "C" block, so we can +// only use C features here + +// Define helpers to register test cases from multiple files +#define UNITY_EXPAND2(a, b) a ## b +#define UNITY_EXPAND(a, b) UNITY_EXPAND2(a, b) +#define UNITY_TEST_UID(what) UNITY_EXPAND(what, __LINE__) + +#define UNITY_TEST_REG_HELPER reg_helper ## UNITY_TEST_UID +#define UNITY_TEST_DESC_UID desc ## UNITY_TEST_UID + + +// get count of __VA_ARGS__ +#define PP_NARG(...) \ + PP_NARG_(__VA_ARGS__,PP_RSEQ_N()) +#define PP_NARG_(...) \ + PP_ARG_N(__VA_ARGS__) +#define PP_ARG_N( \ + _1, _2, _3, _4, _5, _6, _7, _8, _9, N, ...) N +#define PP_RSEQ_N() 9,8,7,6,5,4,3,2,1,0 + +// support max 5 test func now +#define FN_NAME_SET_1(a) {#a} +#define FN_NAME_SET_2(a, b) {#a, #b} +#define FN_NAME_SET_3(a, b, c) {#a, #b, #c} +#define FN_NAME_SET_4(a, b, c, d) {#a, #b, #c, #d} +#define FN_NAME_SET_5(a, b, c, d, e) {#a, #b, #c, #d, #e} + +#define FN_NAME_SET2(n) FN_NAME_SET_##n +#define FN_NAME_SET(n, ...) FN_NAME_SET2(n)(__VA_ARGS__) + +#define UNITY_TEST_FN_SET(...) \ + static test_func UNITY_TEST_UID(test_functions)[] = {__VA_ARGS__}; \ + static const char* UNITY_TEST_UID(test_fn_name)[] = FN_NAME_SET(PP_NARG(__VA_ARGS__), __VA_ARGS__) + + +typedef void (* test_func)(void); + +typedef struct test_desc_t +{ + const char* name; + const char* desc; + test_func* fn; + const char* file; + int line; + uint8_t test_fn_count; + const char ** test_fn_name; + struct test_desc_t* next; +} test_desc_t; + +void unity_testcase_register(test_desc_t* desc); + + +/* Test case macro, a-la CATCH framework. + First argument is a free-form description, + second argument is (by convention) a list of identifiers, each one in square brackets. + Identifiers are used to group related tests, or tests with specific properties. + Use like: + + TEST_CASE("Frobnicator forbnicates", "[frobnicator][rom]") + { + // test goes here + } +*/ + +#define TEST_CASE(name_, desc_) \ + static void UNITY_TEST_UID(test_func_) (void); \ + static void __attribute__((constructor)) UNITY_TEST_UID(test_reg_helper_) (void) \ + { \ + static test_func test_fn_[] = {&UNITY_TEST_UID(test_func_)}; \ + static test_desc_t UNITY_TEST_UID(test_desc_) = { \ + .name = name_, \ + .desc = desc_, \ + .fn = test_fn_, \ + .file = __FILE__, \ + .line = __LINE__, \ + .test_fn_count = 1, \ + .test_fn_name = NULL, \ + .next = NULL \ + }; \ + unity_testcase_register( & UNITY_TEST_UID(test_desc_) ); \ + }\ + static void UNITY_TEST_UID(test_func_) (void) + + +/* + * Multiple stages test cases will handle the case that test steps are separated by DUT reset. + * e.g: we want to verify some function after SW reset, WDT reset or deep sleep reset. + * + * First argument is a free-form description, + * second argument is (by convention) a list of identifiers, each one in square brackets. + * subsequent arguments are names test functions separated by reset. + * e.g: + * TEST_CASE_MULTIPLE_STAGES("run light sleep after deep sleep","[sleep]", goto_deepsleep, light_sleep_after_deep_sleep_wakeup); + * */ + +#define TEST_CASE_MULTIPLE_STAGES(name_, desc_, ...) \ + UNITY_TEST_FN_SET(__VA_ARGS__); \ + static void __attribute__((constructor)) UNITY_TEST_UID(test_reg_helper_) (void) \ + { \ + static test_desc_t UNITY_TEST_UID(test_desc_) = { \ + .name = name_, \ + .desc = desc_"[multi_stage]", \ + .fn = UNITY_TEST_UID(test_functions), \ + .file = __FILE__, \ + .line = __LINE__, \ + .test_fn_count = PP_NARG(__VA_ARGS__), \ + .test_fn_name = UNITY_TEST_UID(test_fn_name), \ + .next = NULL \ + }; \ + unity_testcase_register( & UNITY_TEST_UID(test_desc_) ); \ + } + + + +/* + * First argument is a free-form description, + * second argument is (by convention) a list of identifiers, each one in square brackets. + * subsequent arguments are names of test functions for different DUTs + * e.g: + * TEST_CASE_MULTIPLE_DEVICES("master and slave spi","[spi][test_env=UT_T2_1]", master_test, slave_test); + * */ + +#define TEST_CASE_MULTIPLE_DEVICES(name_, desc_, ...) \ + UNITY_TEST_FN_SET(__VA_ARGS__); \ + static void __attribute__((constructor)) UNITY_TEST_UID(test_reg_helper_) (void) \ + { \ + static test_desc_t UNITY_TEST_UID(test_desc_) = { \ + .name = name_, \ + .desc = desc_"[multi_device]", \ + .fn = UNITY_TEST_UID(test_functions), \ + .file = __FILE__, \ + .line = __LINE__, \ + .test_fn_count = PP_NARG(__VA_ARGS__), \ + .test_fn_name = UNITY_TEST_UID(test_fn_name), \ + .next = NULL \ + }; \ + unity_testcase_register( & UNITY_TEST_UID(test_desc_) ); \ + } + +/** + * Note: initialization of test_desc_t fields above has to be done exactly + * in the same order as the fields are declared in the structure. + * Otherwise the initializer will not be valid in C++ (which doesn't + * support designated initializers). G++ can parse the syntax, but + * field names are treated as annotations and don't affect initialization + * order. Also make sure all the fields are initialized. + */ + +void unity_run_test_by_name(const char *name); + +void unity_run_tests_by_tag(const char *tag, bool invert); + +void unity_run_all_tests(void); + +void unity_run_menu(void); + +#define CONFIG_IDF_TARGET_NA 0 + +/* + * This macro is to disable those tests and their callees that cannot be built or run temporarily + * (needs update or runners). + * + * Usage: + * ``` + * #if !TEMPORARY_DISABLED_FOR_TARGETS(ESP32S2, ESP32S2) + * TEST_CASE("only for esp32", "") + * { + * } + * #endif + * ``` + */ +#define TEMPORARY_DISABLED_FOR_TARGETS(...) (_UNITY_DFT_10(__VA_ARGS__, NA, NA, NA, NA, NA, NA, NA, NA, NA)) + +/* + * This macro is to disable those tests and their callees that is totally impossible to run on the + * specific targets. Usage same as TEMPORARY_DISABLED_FOR_TARGETS. + */ +#define DISABLED_FOR_TARGETS(...) TEMPORARY_DISABLED_FOR_TARGETS(__VA_ARGS__) + +#define _UNITY_DFT_10(TARGET, ...) (CONFIG_IDF_TARGET_##TARGET || _UNITY_DFT_9(__VA_ARGS__)) +#define _UNITY_DFT_9(TARGET, ...) (CONFIG_IDF_TARGET_##TARGET || _UNITY_DFT_8(__VA_ARGS__)) +#define _UNITY_DFT_8(TARGET, ...) (CONFIG_IDF_TARGET_##TARGET || _UNITY_DFT_7(__VA_ARGS__)) +#define _UNITY_DFT_7(TARGET, ...) (CONFIG_IDF_TARGET_##TARGET || _UNITY_DFT_6(__VA_ARGS__)) +#define _UNITY_DFT_6(TARGET, ...) (CONFIG_IDF_TARGET_##TARGET || _UNITY_DFT_5(__VA_ARGS__)) +#define _UNITY_DFT_5(TARGET, ...) (CONFIG_IDF_TARGET_##TARGET || _UNITY_DFT_4(__VA_ARGS__)) +#define _UNITY_DFT_4(TARGET, ...) (CONFIG_IDF_TARGET_##TARGET || _UNITY_DFT_3(__VA_ARGS__)) +#define _UNITY_DFT_3(TARGET, ...) (CONFIG_IDF_TARGET_##TARGET || _UNITY_DFT_2(__VA_ARGS__)) +#define _UNITY_DFT_2(TARGET, ...) (CONFIG_IDF_TARGET_##TARGET || _UNITY_DFT_1(__VA_ARGS__)) +#define _UNITY_DFT_1(TARGET, ...) (CONFIG_IDF_TARGET_##TARGET) diff --git a/applications/test/test_jswyll_packet.c b/applications/test/test_jswyll_packet.c new file mode 100644 index 0000000..ac97aa4 --- /dev/null +++ b/applications/test/test_jswyll_packet.c @@ -0,0 +1,48 @@ +#include + +#include "jswyll_packet.h" +#include "unity.h" + +#define DBG_TAG "main " +#define DBG_LVL DBG_INFO +#include + +jswyll_packet_t packet; + +void test_jswyll_packet(void) +{ + LOG_D("未包含帧头应过滤..."); + uint8_t test_bytes_1[] = {0x12, 0x34}; + for (size_t i = 0; i < sizeof(test_bytes_1); i++) + { + bool is_got_full_packet = jswyll_packet_parse(&packet, test_bytes_1[i]); + TEST_ASSERT_MESSAGE(!is_got_full_packet, "应未收到完整数据包"); + } + TEST_ASSERT_EQUAL_UINT16_MESSAGE(0, packet.rx_index, "未包含帧头应过滤"); + + LOG_D("帧头不完全匹配应过滤..."); + uint8_t test_bytes_2[] = {0xa5, 0x34}; //, , 0xa5, 0x5a, 0x08, 0x00, 0xff, 0x00, 0x01, 0xfe + for (size_t i = 0; i < sizeof(test_bytes_2); i++) + { + bool is_got_full_packet = jswyll_packet_parse(&packet, test_bytes_2[i]); + TEST_ASSERT_MESSAGE(!is_got_full_packet, "应未收到完整数据包"); + } + TEST_ASSERT_EQUAL_UINT16_MESSAGE(0, packet.rx_index, "帧头不完全匹配应过滤"); + + LOG_D("应正确解析到完整的数据包..."); + uint8_t test_bytes_3[] = {0xa5, 0x5a, 0x08, 0x00, 0xff, 0x00, 0x01, 0xfe}; + for (size_t i = 0; i < sizeof(test_bytes_3); i++) + { + bool is_got_full_packet = jswyll_packet_parse(&packet, test_bytes_3[i]); + if (i == sizeof(test_bytes_3) - 1) + { + TEST_ASSERT_MESSAGE(is_got_full_packet, "应已收到完整数据包"); + TEST_ASSERT_EQUAL_UINT16_MESSAGE(0, packet.rx_index, "解析到完整的数据包索引应清零"); + } + else + { + TEST_ASSERT_MESSAGE(!is_got_full_packet, "应未收到完整数据包"); + TEST_ASSERT_EQUAL_UINT16_MESSAGE(i + 1, packet.rx_index, "应正确解析到完整的数据包"); + } + } +} diff --git a/applications/test/test_jswyll_packet.h b/applications/test/test_jswyll_packet.h new file mode 100644 index 0000000..c88fc0a --- /dev/null +++ b/applications/test/test_jswyll_packet.h @@ -0,0 +1,6 @@ +#ifndef __TEST_JSWYLL_PACKET_H__ +#define __TEST_JSWYLL_PACKET_H__ + +void test_jswyll_packet(void); + +#endif \ No newline at end of file diff --git a/applications/test/unity/SConscript b/applications/test/unity/SConscript new file mode 100644 index 0000000..d195bf4 --- /dev/null +++ b/applications/test/unity/SConscript @@ -0,0 +1,15 @@ +import os +from building import * + +cwd = GetCurrentDir() +src = Glob('*.c') + Glob('*.cpp') +CPPPATH = [cwd] + +group = DefineGroup('unity', src, depend = [''], CPPPATH = CPPPATH) + +list = os.listdir(cwd) +for item in list: + if os.path.isfile(os.path.join(cwd, item, 'SConscript')): + group = group + SConscript(os.path.join(item, 'SConscript')) + +Return('group') diff --git a/applications/test/unity/unity.c b/applications/test/unity/unity.c new file mode 100644 index 0000000..9add967 --- /dev/null +++ b/applications/test/unity/unity.c @@ -0,0 +1,2119 @@ +/* ========================================================================= + Unity Project - A Test Framework for C + Copyright (c) 2007-21 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +============================================================================ */ + +#include "unity.h" +#include + +#ifdef AVR +#include +#else +#define PROGMEM +#endif + +/* If omitted from header, declare overrideable prototypes here so they're ready for use */ +#ifdef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION +void UNITY_OUTPUT_CHAR(int); +#endif + +/* Helpful macros for us to use here in Assert functions */ +#define UNITY_FAIL_AND_BAIL do { Unity.CurrentTestFailed = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } while (0) +#define UNITY_IGNORE_AND_BAIL do { Unity.CurrentTestIgnored = 1; UNITY_OUTPUT_FLUSH(); TEST_ABORT(); } while (0) +#define RETURN_IF_FAIL_OR_IGNORE do { if (Unity.CurrentTestFailed || Unity.CurrentTestIgnored) { TEST_ABORT(); } } while (0) + +struct UNITY_STORAGE_T Unity; + +#ifdef UNITY_OUTPUT_COLOR +const char PROGMEM UnityStrOk[] = "\033[42mOK\033[0m"; +const char PROGMEM UnityStrPass[] = "\033[42mPASS\033[0m"; +const char PROGMEM UnityStrFail[] = "\033[41mFAIL\033[0m"; +const char PROGMEM UnityStrIgnore[] = "\033[43mIGNORE\033[0m"; +#else +const char PROGMEM UnityStrOk[] = "OK"; +const char PROGMEM UnityStrPass[] = "PASS"; +const char PROGMEM UnityStrFail[] = "FAIL"; +const char PROGMEM UnityStrIgnore[] = "IGNORE"; +#endif +static const char PROGMEM UnityStrNull[] = "NULL"; +static const char PROGMEM UnityStrSpacer[] = ". "; +static const char PROGMEM UnityStrExpected[] = " Expected "; +static const char PROGMEM UnityStrWas[] = " Was "; +static const char PROGMEM UnityStrGt[] = " to be greater than "; +static const char PROGMEM UnityStrLt[] = " to be less than "; +static const char PROGMEM UnityStrOrEqual[] = "or equal to "; +static const char PROGMEM UnityStrNotEqual[] = " to be not equal to "; +static const char PROGMEM UnityStrElement[] = " Element "; +static const char PROGMEM UnityStrByte[] = " Byte "; +static const char PROGMEM UnityStrMemory[] = " Memory Mismatch."; +static const char PROGMEM UnityStrDelta[] = " Values Not Within Delta "; +static const char PROGMEM UnityStrPointless[] = " You Asked Me To Compare Nothing, Which Was Pointless."; +static const char PROGMEM UnityStrNullPointerForExpected[] = " Expected pointer to be NULL"; +static const char PROGMEM UnityStrNullPointerForActual[] = " Actual pointer was NULL"; +#ifndef UNITY_EXCLUDE_FLOAT +static const char PROGMEM UnityStrNot[] = "Not "; +static const char PROGMEM UnityStrInf[] = "Infinity"; +static const char PROGMEM UnityStrNegInf[] = "Negative Infinity"; +static const char PROGMEM UnityStrNaN[] = "NaN"; +static const char PROGMEM UnityStrDet[] = "Determinate"; +static const char PROGMEM UnityStrInvalidFloatTrait[] = "Invalid Float Trait"; +#endif +const char PROGMEM UnityStrErrShorthand[] = "Unity Shorthand Support Disabled"; +const char PROGMEM UnityStrErrFloat[] = "Unity Floating Point Disabled"; +const char PROGMEM UnityStrErrDouble[] = "Unity Double Precision Disabled"; +const char PROGMEM UnityStrErr64[] = "Unity 64-bit Support Disabled"; +static const char PROGMEM UnityStrBreaker[] = "-----------------------"; +static const char PROGMEM UnityStrResultsTests[] = " Tests "; +static const char PROGMEM UnityStrResultsFailures[] = " Failures "; +static const char PROGMEM UnityStrResultsIgnored[] = " Ignored "; +#ifndef UNITY_EXCLUDE_DETAILS +static const char PROGMEM UnityStrDetail1Name[] = UNITY_DETAIL1_NAME " "; +static const char PROGMEM UnityStrDetail2Name[] = " " UNITY_DETAIL2_NAME " "; +#endif +/*----------------------------------------------- + * Pretty Printers & Test Result Output Handlers + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +/* Local helper function to print characters. */ +static void UnityPrintChar(const char* pch) +{ + /* printable characters plus CR & LF are printed */ + if ((*pch <= 126) && (*pch >= 32)) + { + UNITY_OUTPUT_CHAR(*pch); + } + /* write escaped carriage returns */ + else if (*pch == 13) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('r'); + } + /* write escaped line feeds */ + else if (*pch == 10) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('n'); + } + /* unprintable characters are shown as codes */ + else + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)*pch, 2); + } +} + +/*-----------------------------------------------*/ +/* Local helper function to print ANSI escape strings e.g. "\033[42m". */ +#ifdef UNITY_OUTPUT_COLOR +static UNITY_UINT UnityPrintAnsiEscapeString(const char* string) +{ + const char* pch = string; + UNITY_UINT count = 0; + + while (*pch && (*pch != 'm')) + { + UNITY_OUTPUT_CHAR(*pch); + pch++; + count++; + } + UNITY_OUTPUT_CHAR('m'); + count++; + + return count; +} +#endif + +/*-----------------------------------------------*/ +void UnityPrint(const char* string) +{ + const char* pch = string; + + if (pch != NULL) + { + while (*pch) + { +#ifdef UNITY_OUTPUT_COLOR + /* print ANSI escape code */ + if ((*pch == 27) && (*(pch + 1) == '[')) + { + pch += UnityPrintAnsiEscapeString(pch); + continue; + } +#endif + UnityPrintChar(pch); + pch++; + } + } +} +/*-----------------------------------------------*/ +void UnityPrintLen(const char* string, const UNITY_UINT32 length) +{ + const char* pch = string; + + if (pch != NULL) + { + while (*pch && ((UNITY_UINT32)(pch - string) < length)) + { + /* printable characters plus CR & LF are printed */ + if ((*pch <= 126) && (*pch >= 32)) + { + UNITY_OUTPUT_CHAR(*pch); + } + /* write escaped carriage returns */ + else if (*pch == 13) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('r'); + } + /* write escaped line feeds */ + else if (*pch == 10) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('n'); + } + /* unprintable characters are shown as codes */ + else + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)*pch, 2); + } + pch++; + } + } +} + +/*-----------------------------------------------*/ +void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style) +{ + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if (style == UNITY_DISPLAY_STYLE_CHAR) + { + /* printable characters plus CR & LF are printed */ + UNITY_OUTPUT_CHAR('\''); + if ((number <= 126) && (number >= 32)) + { + UNITY_OUTPUT_CHAR((int)number); + } + /* write escaped carriage returns */ + else if (number == 13) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('r'); + } + /* write escaped line feeds */ + else if (number == 10) + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('n'); + } + /* unprintable characters are shown as codes */ + else + { + UNITY_OUTPUT_CHAR('\\'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, 2); + } + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrintNumber(number); + } + } + else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT) + { + UnityPrintNumberUnsigned((UNITY_UINT)number); + } + else + { + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, (char)((style & 0xF) * 2)); + } +} + +/*-----------------------------------------------*/ +void UnityPrintNumber(const UNITY_INT number_to_print) +{ + UNITY_UINT number = (UNITY_UINT)number_to_print; + + if (number_to_print < 0) + { + /* A negative number, including MIN negative */ + UNITY_OUTPUT_CHAR('-'); + number = (~number) + 1; + } + UnityPrintNumberUnsigned(number); +} + +/*----------------------------------------------- + * basically do an itoa using as little ram as possible */ +void UnityPrintNumberUnsigned(const UNITY_UINT number) +{ + UNITY_UINT divisor = 1; + + /* figure out initial divisor */ + while (number / divisor > 9) + { + divisor *= 10; + } + + /* now mod and print, then divide divisor */ + do + { + UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10))); + divisor /= 10; + } while (divisor > 0); +} + +/*-----------------------------------------------*/ +void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print) +{ + int nibble; + char nibbles = nibbles_to_print; + + if ((unsigned)nibbles > UNITY_MAX_NIBBLES) + { + nibbles = UNITY_MAX_NIBBLES; + } + + while (nibbles > 0) + { + nibbles--; + nibble = (int)(number >> (nibbles * 4)) & 0x0F; + if (nibble <= 9) + { + UNITY_OUTPUT_CHAR((char)('0' + nibble)); + } + else + { + UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble)); + } + } +} + +/*-----------------------------------------------*/ +void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number) +{ + UNITY_UINT current_bit = (UNITY_UINT)1 << (UNITY_INT_WIDTH - 1); + UNITY_INT32 i; + + for (i = 0; i < UNITY_INT_WIDTH; i++) + { + if (current_bit & mask) + { + if (current_bit & number) + { + UNITY_OUTPUT_CHAR('1'); + } + else + { + UNITY_OUTPUT_CHAR('0'); + } + } + else + { + UNITY_OUTPUT_CHAR('X'); + } + current_bit = current_bit >> 1; + } +} + +/*-----------------------------------------------*/ +#ifndef UNITY_EXCLUDE_FLOAT_PRINT +/* + * This function prints a floating-point value in a format similar to + * printf("%.7g") on a single-precision machine or printf("%.9g") on a + * double-precision machine. The 7th digit won't always be totally correct + * in single-precision operation (for that level of accuracy, a more + * complicated algorithm would be needed). + */ +void UnityPrintFloat(const UNITY_DOUBLE input_number) +{ +#ifdef UNITY_INCLUDE_DOUBLE + static const int sig_digits = 9; + static const UNITY_INT32 min_scaled = 100000000; + static const UNITY_INT32 max_scaled = 1000000000; +#else + static const int sig_digits = 7; + static const UNITY_INT32 min_scaled = 1000000; + static const UNITY_INT32 max_scaled = 10000000; +#endif + + UNITY_DOUBLE number = input_number; + + /* print minus sign (does not handle negative zero) */ + if (number < 0.0f) + { + UNITY_OUTPUT_CHAR('-'); + number = -number; + } + + /* handle zero, NaN, and +/- infinity */ + if (number == 0.0f) + { + UnityPrint("0"); + } + else if (isnan(number)) + { + UnityPrint("nan"); + } + else if (isinf(number)) + { + UnityPrint("inf"); + } + else + { + UNITY_INT32 n_int = 0; + UNITY_INT32 n; + int exponent = 0; + int decimals; + int digits; + char buf[16] = {0}; + + /* + * Scale up or down by powers of 10. To minimize rounding error, + * start with a factor/divisor of 10^10, which is the largest + * power of 10 that can be represented exactly. Finally, compute + * (exactly) the remaining power of 10 and perform one more + * multiplication or division. + */ + if (number < 1.0f) + { + UNITY_DOUBLE factor = 1.0f; + + while (number < (UNITY_DOUBLE)max_scaled / 1e10f) { number *= 1e10f; exponent -= 10; } + while (number * factor < (UNITY_DOUBLE)min_scaled) { factor *= 10.0f; exponent--; } + + number *= factor; + } + else if (number > (UNITY_DOUBLE)max_scaled) + { + UNITY_DOUBLE divisor = 1.0f; + + while (number > (UNITY_DOUBLE)min_scaled * 1e10f) { number /= 1e10f; exponent += 10; } + while (number / divisor > (UNITY_DOUBLE)max_scaled) { divisor *= 10.0f; exponent++; } + + number /= divisor; + } + else + { + /* + * In this range, we can split off the integer part before + * doing any multiplications. This reduces rounding error by + * freeing up significant bits in the fractional part. + */ + UNITY_DOUBLE factor = 1.0f; + n_int = (UNITY_INT32)number; + number -= (UNITY_DOUBLE)n_int; + + while (n_int < min_scaled) { n_int *= 10; factor *= 10.0f; exponent--; } + + number *= factor; + } + + /* round to nearest integer */ + n = ((UNITY_INT32)(number + number) + 1) / 2; + +#ifndef UNITY_ROUND_TIES_AWAY_FROM_ZERO + /* round to even if exactly between two integers */ + if ((n & 1) && (((UNITY_DOUBLE)n - number) == 0.5f)) + n--; +#endif + + n += n_int; + + if (n >= max_scaled) + { + n = min_scaled; + exponent++; + } + + /* determine where to place decimal point */ + decimals = ((exponent <= 0) && (exponent >= -(sig_digits + 3))) ? (-exponent) : (sig_digits - 1); + exponent += decimals; + + /* truncate trailing zeroes after decimal point */ + while ((decimals > 0) && ((n % 10) == 0)) + { + n /= 10; + decimals--; + } + + /* build up buffer in reverse order */ + digits = 0; + while ((n != 0) || (digits <= decimals)) + { + buf[digits++] = (char)('0' + n % 10); + n /= 10; + } + + /* print out buffer (backwards) */ + while (digits > 0) + { + if (digits == decimals) + { + UNITY_OUTPUT_CHAR('.'); + } + UNITY_OUTPUT_CHAR(buf[--digits]); + } + + /* print exponent if needed */ + if (exponent != 0) + { + UNITY_OUTPUT_CHAR('e'); + + if (exponent < 0) + { + UNITY_OUTPUT_CHAR('-'); + exponent = -exponent; + } + else + { + UNITY_OUTPUT_CHAR('+'); + } + + digits = 0; + while ((exponent != 0) || (digits < 2)) + { + buf[digits++] = (char)('0' + exponent % 10); + exponent /= 10; + } + while (digits > 0) + { + UNITY_OUTPUT_CHAR(buf[--digits]); + } + } + } +} +#endif /* ! UNITY_EXCLUDE_FLOAT_PRINT */ + +/*-----------------------------------------------*/ +static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line) +{ +#ifdef UNITY_OUTPUT_FOR_ECLIPSE + UNITY_OUTPUT_CHAR('('); + UnityPrint(file); + UNITY_OUTPUT_CHAR(':'); + UnityPrintNumber((UNITY_INT)line); + UNITY_OUTPUT_CHAR(')'); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(Unity.CurrentTestName); + UNITY_OUTPUT_CHAR(':'); +#else +#ifdef UNITY_OUTPUT_FOR_IAR_WORKBENCH + UnityPrint("'); + UnityPrint(Unity.CurrentTestName); + UnityPrint(" "); +#else +#ifdef UNITY_OUTPUT_FOR_QT_CREATOR + UnityPrint("file://"); + UnityPrint(file); + UNITY_OUTPUT_CHAR(':'); + UnityPrintNumber((UNITY_INT)line); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(Unity.CurrentTestName); + UNITY_OUTPUT_CHAR(':'); +#else + UnityPrint(file); + UNITY_OUTPUT_CHAR(':'); + UnityPrintNumber((UNITY_INT)line); + UNITY_OUTPUT_CHAR(':'); + UnityPrint(Unity.CurrentTestName); + UNITY_OUTPUT_CHAR(':'); +#endif +#endif +#endif +} + +/*-----------------------------------------------*/ +static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line) +{ + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint(UnityStrFail); + UNITY_OUTPUT_CHAR(':'); +} + +/*-----------------------------------------------*/ +void UnityConcludeTest(void) +{ + if (Unity.CurrentTestIgnored) + { + Unity.TestIgnores++; + } + else if (!Unity.CurrentTestFailed) + { + UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber); + UnityPrint(UnityStrPass); + } + else + { + Unity.TestFailures++; + } + + Unity.CurrentTestFailed = 0; + Unity.CurrentTestIgnored = 0; + UNITY_PRINT_EXEC_TIME(); + UNITY_PRINT_EOL(); + UNITY_FLUSH_CALL(); +} + +/*-----------------------------------------------*/ +static void UnityAddMsgIfSpecified(const char* msg) +{ + if (msg) + { + UnityPrint(UnityStrSpacer); + +#ifdef UNITY_PRINT_TEST_CONTEXT + UNITY_PRINT_TEST_CONTEXT(); +#endif +#ifndef UNITY_EXCLUDE_DETAILS + if (Unity.CurrentDetail1) + { + UnityPrint(UnityStrDetail1Name); + UnityPrint(Unity.CurrentDetail1); + if (Unity.CurrentDetail2) + { + UnityPrint(UnityStrDetail2Name); + UnityPrint(Unity.CurrentDetail2); + } + UnityPrint(UnityStrSpacer); + } +#endif + UnityPrint(msg); + } +} + +/*-----------------------------------------------*/ +static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual) +{ + UnityPrint(UnityStrExpected); + if (expected != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrint(expected); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } + UnityPrint(UnityStrWas); + if (actual != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrint(actual); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } +} + +/*-----------------------------------------------*/ +static void UnityPrintExpectedAndActualStringsLen(const char* expected, + const char* actual, + const UNITY_UINT32 length) +{ + UnityPrint(UnityStrExpected); + if (expected != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrintLen(expected, length); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } + UnityPrint(UnityStrWas); + if (actual != NULL) + { + UNITY_OUTPUT_CHAR('\''); + UnityPrintLen(actual, length); + UNITY_OUTPUT_CHAR('\''); + } + else + { + UnityPrint(UnityStrNull); + } +} + +/*----------------------------------------------- + * Assertion & Control Helpers + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +static int UnityIsOneArrayNull(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_LINE_TYPE lineNumber, + const char* msg) +{ + /* Both are NULL or same pointer */ + if (expected == actual) { return 0; } + + /* print and return true if just expected is NULL */ + if (expected == NULL) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrNullPointerForExpected); + UnityAddMsgIfSpecified(msg); + return 1; + } + + /* print and return true if just actual is NULL */ + if (actual == NULL) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrNullPointerForActual); + UnityAddMsgIfSpecified(msg); + return 1; + } + + return 0; /* return false if neither is NULL */ +} + +/*----------------------------------------------- + * Assertion Functions + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +void UnityAssertBits(const UNITY_INT mask, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if ((mask & expected) != (mask & actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)expected); + UnityPrint(UnityStrWas); + UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualNumber(const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if (expected != actual) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expected, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold, + const UNITY_INT actual, + const UNITY_COMPARISON_T compare, + const char *msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style) +{ + int failed = 0; + RETURN_IF_FAIL_OR_IGNORE; + + if ((threshold == actual) && (compare & UNITY_EQUAL_TO)) { return; } + if ((threshold == actual)) { failed = 1; } + + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if ((actual > threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if ((actual < threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + } + else /* UINT or HEX */ + { + if (((UNITY_UINT)actual > (UNITY_UINT)threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } + if (((UNITY_UINT)actual < (UNITY_UINT)threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } + } + + if (failed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(actual, style); + if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt); } + if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt); } + if (compare & UNITY_EQUAL_TO) { UnityPrint(UnityStrOrEqual); } + if (compare == UNITY_NOT_EQUAL) { UnityPrint(UnityStrNotEqual); } + UnityPrintNumberByStyle(threshold, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#define UnityPrintPointlessAndBail() \ +do { \ + UnityTestResultsFailBegin(lineNumber); \ + UnityPrint(UnityStrPointless); \ + UnityAddMsgIfSpecified(msg); \ + UNITY_FAIL_AND_BAIL; \ +} while (0) + +/*-----------------------------------------------*/ +void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + unsigned int length = style & 0xF; + unsigned int increment = 0; + + RETURN_IF_FAIL_OR_IGNORE; + + if (num_elements == 0) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while ((elements > 0) && (elements--)) + { + UNITY_INT expect_val; + UNITY_INT actual_val; + + switch (length) + { + case 1: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual; + increment = sizeof(UNITY_INT8); + break; + + case 2: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; + increment = sizeof(UNITY_INT16); + break; + +#ifdef UNITY_SUPPORT_64 + case 8: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual; + increment = sizeof(UNITY_INT64); + break; +#endif + + default: /* default is length 4 bytes */ + case 4: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; + increment = sizeof(UNITY_INT32); + length = 4; + break; + } + + if (expect_val != actual_val) + { + if ((style & UNITY_DISPLAY_RANGE_UINT) && (length < (UNITY_INT_WIDTH / 8))) + { /* For UINT, remove sign extension (padding 1's) from signed type casts above */ + UNITY_INT mask = 1; + mask = (mask << 8 * length) - 1; + expect_val &= mask; + actual_val &= mask; + } + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expect_val, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual_val, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + /* Walk through array by incrementing the pointers */ + if (flags == UNITY_ARRAY_TO_ARRAY) + { + expected = (UNITY_INTERNAL_PTR)((const char*)expected + increment); + } + actual = (UNITY_INTERNAL_PTR)((const char*)actual + increment); + } +} + +/*-----------------------------------------------*/ +#ifndef UNITY_EXCLUDE_FLOAT +/* Wrap this define in a function with variable types as float or double */ +#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff) \ + if (isinf(expected) && isinf(actual) && (((expected) < 0) == ((actual) < 0))) return 1; \ + if (UNITY_NAN_CHECK) return 1; \ + (diff) = (actual) - (expected); \ + if ((diff) < 0) (diff) = -(diff); \ + if ((delta) < 0) (delta) = -(delta); \ + return !(isnan(diff) || isinf(diff) || ((diff) > (delta))) + /* This first part of this condition will catch any NaN or Infinite values */ +#ifndef UNITY_NAN_NOT_EQUAL_NAN + #define UNITY_NAN_CHECK isnan(expected) && isnan(actual) +#else + #define UNITY_NAN_CHECK 0 +#endif + +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ + do { \ + UnityPrint(UnityStrExpected); \ + UnityPrintFloat(expected); \ + UnityPrint(UnityStrWas); \ + UnityPrintFloat(actual); \ + } while (0) +#else + #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ + UnityPrint(UnityStrDelta) +#endif /* UNITY_EXCLUDE_FLOAT_PRINT */ + +/*-----------------------------------------------*/ +static int UnityFloatsWithin(UNITY_FLOAT delta, UNITY_FLOAT expected, UNITY_FLOAT actual) +{ + UNITY_FLOAT diff; + UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); +} + +/*-----------------------------------------------*/ +void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_expected = expected; + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_actual = actual; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while (elements--) + { + if (!UnityFloatsWithin(*ptr_expected * UNITY_FLOAT_PRECISION, *ptr_expected, *ptr_actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)*ptr_expected, (UNITY_DOUBLE)*ptr_actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + if (flags == UNITY_ARRAY_TO_ARRAY) + { + ptr_expected++; + } + ptr_actual++; + } +} + +/*-----------------------------------------------*/ +void UnityAssertFloatsWithin(const UNITY_FLOAT delta, + const UNITY_FLOAT expected, + const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + + if (!UnityFloatsWithin(delta, expected, actual)) + { + UnityTestResultsFailBegin(lineNumber); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)expected, (UNITY_DOUBLE)actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertFloatSpecial(const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style) +{ + const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet}; + UNITY_INT should_be_trait = ((UNITY_INT)style & 1); + UNITY_INT is_trait = !should_be_trait; + UNITY_INT trait_index = (UNITY_INT)(style >> 1); + + RETURN_IF_FAIL_OR_IGNORE; + + switch (style) + { + case UNITY_FLOAT_IS_INF: + case UNITY_FLOAT_IS_NOT_INF: + is_trait = isinf(actual) && (actual > 0); + break; + case UNITY_FLOAT_IS_NEG_INF: + case UNITY_FLOAT_IS_NOT_NEG_INF: + is_trait = isinf(actual) && (actual < 0); + break; + + case UNITY_FLOAT_IS_NAN: + case UNITY_FLOAT_IS_NOT_NAN: + is_trait = isnan(actual) ? 1 : 0; + break; + + case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */ + case UNITY_FLOAT_IS_NOT_DET: + is_trait = !isinf(actual) && !isnan(actual); + break; + + default: /* including UNITY_FLOAT_INVALID_TRAIT */ + trait_index = 0; + trait_names[0] = UnityStrInvalidFloatTrait; + break; + } + + if (is_trait != should_be_trait) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + if (!should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); + UnityPrint(UnityStrWas); +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + UnityPrintFloat((UNITY_DOUBLE)actual); +#else + if (should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); +#endif + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#endif /* not UNITY_EXCLUDE_FLOAT */ + +/*-----------------------------------------------*/ +#ifndef UNITY_EXCLUDE_DOUBLE +static int UnityDoublesWithin(UNITY_DOUBLE delta, UNITY_DOUBLE expected, UNITY_DOUBLE actual) +{ + UNITY_DOUBLE diff; + UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); +} + +/*-----------------------------------------------*/ +void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_expected = expected; + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_actual = actual; + + RETURN_IF_FAIL_OR_IGNORE; + + if (elements == 0) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while (elements--) + { + if (!UnityDoublesWithin(*ptr_expected * UNITY_DOUBLE_PRECISION, *ptr_expected, *ptr_actual)) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(*ptr_expected, *ptr_actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + if (flags == UNITY_ARRAY_TO_ARRAY) + { + ptr_expected++; + } + ptr_actual++; + } +} + +/*-----------------------------------------------*/ +void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, + const UNITY_DOUBLE expected, + const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if (!UnityDoublesWithin(delta, expected, actual)) + { + UnityTestResultsFailBegin(lineNumber); + UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style) +{ + const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet}; + UNITY_INT should_be_trait = ((UNITY_INT)style & 1); + UNITY_INT is_trait = !should_be_trait; + UNITY_INT trait_index = (UNITY_INT)(style >> 1); + + RETURN_IF_FAIL_OR_IGNORE; + + switch (style) + { + case UNITY_FLOAT_IS_INF: + case UNITY_FLOAT_IS_NOT_INF: + is_trait = isinf(actual) && (actual > 0); + break; + case UNITY_FLOAT_IS_NEG_INF: + case UNITY_FLOAT_IS_NOT_NEG_INF: + is_trait = isinf(actual) && (actual < 0); + break; + + case UNITY_FLOAT_IS_NAN: + case UNITY_FLOAT_IS_NOT_NAN: + is_trait = isnan(actual) ? 1 : 0; + break; + + case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */ + case UNITY_FLOAT_IS_NOT_DET: + is_trait = !isinf(actual) && !isnan(actual); + break; + + default: /* including UNITY_FLOAT_INVALID_TRAIT */ + trait_index = 0; + trait_names[0] = UnityStrInvalidFloatTrait; + break; + } + + if (is_trait != should_be_trait) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrExpected); + if (!should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); + UnityPrint(UnityStrWas); +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + UnityPrintFloat(actual); +#else + if (should_be_trait) + { + UnityPrint(UnityStrNot); + } + UnityPrint(trait_names[trait_index]); +#endif + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +#endif /* not UNITY_EXCLUDE_DOUBLE */ + +/*-----------------------------------------------*/ +void UnityAssertNumbersWithin(const UNITY_UINT delta, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style) +{ + RETURN_IF_FAIL_OR_IGNORE; + + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if (actual > expected) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta); + } + } + else + { + if ((UNITY_UINT)actual > (UNITY_UINT)expected) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta); + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrDelta); + UnityPrintNumberByStyle((UNITY_INT)delta, style); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expected, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertNumbersArrayWithin(const UNITY_UINT delta, + UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 elements = num_elements; + unsigned int length = style & 0xF; + unsigned int increment = 0; + + RETURN_IF_FAIL_OR_IGNORE; + + if (num_elements == 0) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while ((elements > 0) && (elements--)) + { + UNITY_INT expect_val; + UNITY_INT actual_val; + + switch (length) + { + case 1: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual; + increment = sizeof(UNITY_INT8); + break; + + case 2: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; + increment = sizeof(UNITY_INT16); + break; + +#ifdef UNITY_SUPPORT_64 + case 8: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual; + increment = sizeof(UNITY_INT64); + break; +#endif + + default: /* default is length 4 bytes */ + case 4: + expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; + actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; + increment = sizeof(UNITY_INT32); + length = 4; + break; + } + + if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) + { + if (actual_val > expect_val) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual_val - (UNITY_UINT)expect_val) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expect_val - (UNITY_UINT)actual_val) > delta); + } + } + else + { + if ((UNITY_UINT)actual_val > (UNITY_UINT)expect_val) + { + Unity.CurrentTestFailed = (((UNITY_UINT)actual_val - (UNITY_UINT)expect_val) > delta); + } + else + { + Unity.CurrentTestFailed = (((UNITY_UINT)expect_val - (UNITY_UINT)actual_val) > delta); + } + } + + if (Unity.CurrentTestFailed) + { + if ((style & UNITY_DISPLAY_RANGE_UINT) && (length < (UNITY_INT_WIDTH / 8))) + { /* For UINT, remove sign extension (padding 1's) from signed type casts above */ + UNITY_INT mask = 1; + mask = (mask << 8 * length) - 1; + expect_val &= mask; + actual_val &= mask; + } + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrDelta); + UnityPrintNumberByStyle((UNITY_INT)delta, style); + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(expect_val, style); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(actual_val, style); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + /* Walk through array by incrementing the pointers */ + if (flags == UNITY_ARRAY_TO_ARRAY) + { + expected = (UNITY_INTERNAL_PTR)((const char*)expected + increment); + } + actual = (UNITY_INTERNAL_PTR)((const char*)actual + increment); + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualString(const char* expected, + const char* actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + UNITY_UINT32 i; + + RETURN_IF_FAIL_OR_IGNORE; + + /* if both pointers not null compare the strings */ + if (expected && actual) + { + for (i = 0; expected[i] || actual[i]; i++) + { + if (expected[i] != actual[i]) + { + Unity.CurrentTestFailed = 1; + break; + } + } + } + else + { /* handle case of one pointers being null (if both null, test should pass) */ + if (expected != actual) + { + Unity.CurrentTestFailed = 1; + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrintExpectedAndActualStrings(expected, actual); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualStringLen(const char* expected, + const char* actual, + const UNITY_UINT32 length, + const char* msg, + const UNITY_LINE_TYPE lineNumber) +{ + UNITY_UINT32 i; + + RETURN_IF_FAIL_OR_IGNORE; + + /* if both pointers not null compare the strings */ + if (expected && actual) + { + for (i = 0; (i < length) && (expected[i] || actual[i]); i++) + { + if (expected[i] != actual[i]) + { + Unity.CurrentTestFailed = 1; + break; + } + } + } + else + { /* handle case of one pointers being null (if both null, test should pass) */ + if (expected != actual) + { + Unity.CurrentTestFailed = 1; + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrintExpectedAndActualStringsLen(expected, actual, length); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } +} + +/*-----------------------------------------------*/ +void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected, + const char** actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_UINT32 i = 0; + UNITY_UINT32 j = 0; + const char* expd = NULL; + const char* act = NULL; + + RETURN_IF_FAIL_OR_IGNORE; + + /* if no elements, it's an error */ + if (num_elements == 0) + { + UnityPrintPointlessAndBail(); + } + + if ((const void*)expected == (const void*)actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + if (flags != UNITY_ARRAY_TO_ARRAY) + { + expd = (const char*)expected; + } + + do + { + act = actual[j]; + if (flags == UNITY_ARRAY_TO_ARRAY) + { + expd = ((const char* const*)expected)[j]; + } + + /* if both pointers not null compare the strings */ + if (expd && act) + { + for (i = 0; expd[i] || act[i]; i++) + { + if (expd[i] != act[i]) + { + Unity.CurrentTestFailed = 1; + break; + } + } + } + else + { /* handle case of one pointers being null (if both null, test should pass) */ + if (expd != act) + { + Unity.CurrentTestFailed = 1; + } + } + + if (Unity.CurrentTestFailed) + { + UnityTestResultsFailBegin(lineNumber); + if (num_elements > 1) + { + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(j); + } + UnityPrintExpectedAndActualStrings(expd, act); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + } while (++j < num_elements); +} + +/*-----------------------------------------------*/ +void UnityAssertEqualMemory(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 length, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) +{ + UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; + UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual; + UNITY_UINT32 elements = num_elements; + UNITY_UINT32 bytes; + + RETURN_IF_FAIL_OR_IGNORE; + + if ((elements == 0) || (length == 0)) + { + UnityPrintPointlessAndBail(); + } + + if (expected == actual) + { + return; /* Both are NULL or same pointer */ + } + + if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) + { + UNITY_FAIL_AND_BAIL; + } + + while (elements--) + { + bytes = length; + while (bytes--) + { + if (*ptr_exp != *ptr_act) + { + UnityTestResultsFailBegin(lineNumber); + UnityPrint(UnityStrMemory); + if (num_elements > 1) + { + UnityPrint(UnityStrElement); + UnityPrintNumberUnsigned(num_elements - elements - 1); + } + UnityPrint(UnityStrByte); + UnityPrintNumberUnsigned(length - bytes - 1); + UnityPrint(UnityStrExpected); + UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8); + UnityPrint(UnityStrWas); + UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8); + UnityAddMsgIfSpecified(msg); + UNITY_FAIL_AND_BAIL; + } + ptr_exp++; + ptr_act++; + } + if (flags == UNITY_ARRAY_TO_VAL) + { + ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; + } + } +} + +/*-----------------------------------------------*/ + +static union +{ + UNITY_INT8 i8; + UNITY_INT16 i16; + UNITY_INT32 i32; +#ifdef UNITY_SUPPORT_64 + UNITY_INT64 i64; +#endif +#ifndef UNITY_EXCLUDE_FLOAT + float f; +#endif +#ifndef UNITY_EXCLUDE_DOUBLE + double d; +#endif +} UnityQuickCompare; + +UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size) +{ + switch(size) + { + case 1: + UnityQuickCompare.i8 = (UNITY_INT8)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i8); + + case 2: + UnityQuickCompare.i16 = (UNITY_INT16)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i16); + +#ifdef UNITY_SUPPORT_64 + case 8: + UnityQuickCompare.i64 = (UNITY_INT64)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i64); +#endif + + default: /* 4 bytes */ + UnityQuickCompare.i32 = (UNITY_INT32)num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i32); + } +} + +#ifndef UNITY_EXCLUDE_FLOAT +/*-----------------------------------------------*/ +UNITY_INTERNAL_PTR UnityFloatToPtr(const float num) +{ + UnityQuickCompare.f = num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.f); +} +#endif + +#ifndef UNITY_EXCLUDE_DOUBLE +/*-----------------------------------------------*/ +UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num) +{ + UnityQuickCompare.d = num; + return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.d); +} +#endif + +/*----------------------------------------------- + * printf helper function + *-----------------------------------------------*/ +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +static void UnityPrintFVA(const char* format, va_list va) +{ + const char* pch = format; + if (pch != NULL) + { + while (*pch) + { + /* format identification character */ + if (*pch == '%') + { + pch++; + + if (pch != NULL) + { + switch (*pch) + { + case 'd': + case 'i': + { + const int number = va_arg(va, int); + UnityPrintNumber((UNITY_INT)number); + break; + } +#ifndef UNITY_EXCLUDE_FLOAT_PRINT + case 'f': + case 'g': + { + const double number = va_arg(va, double); + UnityPrintFloat((UNITY_DOUBLE)number); + break; + } +#endif + case 'u': + { + const unsigned int number = va_arg(va, unsigned int); + UnityPrintNumberUnsigned((UNITY_UINT)number); + break; + } + case 'b': + { + const unsigned int number = va_arg(va, unsigned int); + const UNITY_UINT mask = (UNITY_UINT)0 - (UNITY_UINT)1; + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('b'); + UnityPrintMask(mask, (UNITY_UINT)number); + break; + } + case 'x': + case 'X': + case 'p': + { + const unsigned int number = va_arg(va, unsigned int); + UNITY_OUTPUT_CHAR('0'); + UNITY_OUTPUT_CHAR('x'); + UnityPrintNumberHex((UNITY_UINT)number, 8); + break; + } + case 'c': + { + const int ch = va_arg(va, int); + UnityPrintChar((const char *)&ch); + break; + } + case 's': + { + const char * string = va_arg(va, const char *); + UnityPrint(string); + break; + } + case '%': + { + UnityPrintChar(pch); + break; + } + default: + { + /* print the unknown format character */ + UNITY_OUTPUT_CHAR('%'); + UnityPrintChar(pch); + break; + } + } + } + } +#ifdef UNITY_OUTPUT_COLOR + /* print ANSI escape code */ + else if ((*pch == 27) && (*(pch + 1) == '[')) + { + pch += UnityPrintAnsiEscapeString(pch); + continue; + } +#endif + else if (*pch == '\n') + { + UNITY_PRINT_EOL(); + } + else + { + UnityPrintChar(pch); + } + + pch++; + } + } +} + +void UnityPrintF(const UNITY_LINE_TYPE line, const char* format, ...) +{ + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint("INFO"); + if(format != NULL) + { + UnityPrint(": "); + va_list va; + va_start(va, format); + UnityPrintFVA(format, va); + va_end(va); + } + UNITY_PRINT_EOL(); +} +#endif /* ! UNITY_INCLUDE_PRINT_FORMATTED */ + + +/*----------------------------------------------- + * Control Functions + *-----------------------------------------------*/ + +/*-----------------------------------------------*/ +void UnityFail(const char* msg, const UNITY_LINE_TYPE line) +{ + RETURN_IF_FAIL_OR_IGNORE; + + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint(UnityStrFail); + if (msg != NULL) + { + UNITY_OUTPUT_CHAR(':'); + +#ifdef UNITY_PRINT_TEST_CONTEXT + UNITY_PRINT_TEST_CONTEXT(); +#endif +#ifndef UNITY_EXCLUDE_DETAILS + if (Unity.CurrentDetail1) + { + UnityPrint(UnityStrDetail1Name); + UnityPrint(Unity.CurrentDetail1); + if (Unity.CurrentDetail2) + { + UnityPrint(UnityStrDetail2Name); + UnityPrint(Unity.CurrentDetail2); + } + UnityPrint(UnityStrSpacer); + } +#endif + if (msg[0] != ' ') + { + UNITY_OUTPUT_CHAR(' '); + } + UnityPrint(msg); + } + + UNITY_FAIL_AND_BAIL; +} + +/*-----------------------------------------------*/ +void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line) +{ + RETURN_IF_FAIL_OR_IGNORE; + + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint(UnityStrIgnore); + if (msg != NULL) + { + UNITY_OUTPUT_CHAR(':'); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(msg); + } + UNITY_IGNORE_AND_BAIL; +} + +/*-----------------------------------------------*/ +void UnityMessage(const char* msg, const UNITY_LINE_TYPE line) +{ + UnityTestResultsBegin(Unity.TestFile, line); + UnityPrint("INFO"); + if (msg != NULL) + { + UNITY_OUTPUT_CHAR(':'); + UNITY_OUTPUT_CHAR(' '); + UnityPrint(msg); + } + UNITY_PRINT_EOL(); +} + +/*-----------------------------------------------*/ +/* If we have not defined our own test runner, then include our default test runner to make life easier */ +#ifndef UNITY_SKIP_DEFAULT_RUNNER +void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum) +{ + Unity.CurrentTestName = FuncName; + Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum; + Unity.NumberOfTests++; + UNITY_CLR_DETAILS(); + UNITY_EXEC_TIME_START(); + if (TEST_PROTECT()) + { + setUp(); + Func(); + } + if (TEST_PROTECT()) + { + tearDown(); + } + UNITY_EXEC_TIME_STOP(); + UnityConcludeTest(); +} +#endif + +/*-----------------------------------------------*/ +void UnitySetTestFile(const char* filename) +{ + Unity.TestFile = filename; +} + +/*-----------------------------------------------*/ +void UnityBegin(const char* filename) +{ + Unity.TestFile = filename; + Unity.CurrentTestName = NULL; + Unity.CurrentTestLineNumber = 0; + Unity.NumberOfTests = 0; + Unity.TestFailures = 0; + Unity.TestIgnores = 0; + Unity.CurrentTestFailed = 0; + Unity.CurrentTestIgnored = 0; + + UNITY_CLR_DETAILS(); + UNITY_OUTPUT_START(); +} + +/*-----------------------------------------------*/ +int UnityEnd(void) +{ + UNITY_PRINT_EOL(); + UnityPrint(UnityStrBreaker); + UNITY_PRINT_EOL(); + UnityPrintNumber((UNITY_INT)(Unity.NumberOfTests)); + UnityPrint(UnityStrResultsTests); + UnityPrintNumber((UNITY_INT)(Unity.TestFailures)); + UnityPrint(UnityStrResultsFailures); + UnityPrintNumber((UNITY_INT)(Unity.TestIgnores)); + UnityPrint(UnityStrResultsIgnored); + UNITY_PRINT_EOL(); + if (Unity.TestFailures == 0U) + { + UnityPrint(UnityStrOk); + } + else + { + UnityPrint(UnityStrFail); +#ifdef UNITY_DIFFERENTIATE_FINAL_FAIL + UNITY_OUTPUT_CHAR('E'); UNITY_OUTPUT_CHAR('D'); +#endif + } + UNITY_PRINT_EOL(); + UNITY_FLUSH_CALL(); + UNITY_OUTPUT_COMPLETE(); + return (int)(Unity.TestFailures); +} + +/*----------------------------------------------- + * Command Line Argument Support + *-----------------------------------------------*/ +#ifdef UNITY_USE_COMMAND_LINE_ARGS + +char* UnityOptionIncludeNamed = NULL; +char* UnityOptionExcludeNamed = NULL; +int UnityVerbosity = 1; + +/*-----------------------------------------------*/ +int UnityParseOptions(int argc, char** argv) +{ + int i; + UnityOptionIncludeNamed = NULL; + UnityOptionExcludeNamed = NULL; + + for (i = 1; i < argc; i++) + { + if (argv[i][0] == '-') + { + switch (argv[i][1]) + { + case 'l': /* list tests */ + return -1; + case 'n': /* include tests with name including this string */ + case 'f': /* an alias for -n */ + if (argv[i][2] == '=') + { + UnityOptionIncludeNamed = &argv[i][3]; + } + else if (++i < argc) + { + UnityOptionIncludeNamed = argv[i]; + } + else + { + UnityPrint("ERROR: No Test String to Include Matches For"); + UNITY_PRINT_EOL(); + return 1; + } + break; + case 'q': /* quiet */ + UnityVerbosity = 0; + break; + case 'v': /* verbose */ + UnityVerbosity = 2; + break; + case 'x': /* exclude tests with name including this string */ + if (argv[i][2] == '=') + { + UnityOptionExcludeNamed = &argv[i][3]; + } + else if (++i < argc) + { + UnityOptionExcludeNamed = argv[i]; + } + else + { + UnityPrint("ERROR: No Test String to Exclude Matches For"); + UNITY_PRINT_EOL(); + return 1; + } + break; + default: + UnityPrint("ERROR: Unknown Option "); + UNITY_OUTPUT_CHAR(argv[i][1]); + UNITY_PRINT_EOL(); + return 1; + } + } + } + + return 0; +} + +/*-----------------------------------------------*/ +int IsStringInBiggerString(const char* longstring, const char* shortstring) +{ + const char* lptr = longstring; + const char* sptr = shortstring; + const char* lnext = lptr; + + if (*sptr == '*') + { + return 1; + } + + while (*lptr) + { + lnext = lptr + 1; + + /* If they current bytes match, go on to the next bytes */ + while (*lptr && *sptr && (*lptr == *sptr)) + { + lptr++; + sptr++; + + /* We're done if we match the entire string or up to a wildcard */ + if (*sptr == '*') + return 1; + if (*sptr == ',') + return 1; + if (*sptr == '"') + return 1; + if (*sptr == '\'') + return 1; + if (*sptr == ':') + return 2; + if (*sptr == 0) + return 1; + } + + /* Otherwise we start in the long pointer 1 character further and try again */ + lptr = lnext; + sptr = shortstring; + } + + return 0; +} + +/*-----------------------------------------------*/ +int UnityStringArgumentMatches(const char* str) +{ + int retval; + const char* ptr1; + const char* ptr2; + const char* ptrf; + + /* Go through the options and get the substrings for matching one at a time */ + ptr1 = str; + while (ptr1[0] != 0) + { + if ((ptr1[0] == '"') || (ptr1[0] == '\'')) + { + ptr1++; + } + + /* look for the start of the next partial */ + ptr2 = ptr1; + ptrf = 0; + do + { + ptr2++; + if ((ptr2[0] == ':') && (ptr2[1] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ',')) + { + ptrf = &ptr2[1]; + } + } while ((ptr2[0] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ',')); + + while ((ptr2[0] != 0) && ((ptr2[0] == ':') || (ptr2[0] == '\'') || (ptr2[0] == '"') || (ptr2[0] == ','))) + { + ptr2++; + } + + /* done if complete filename match */ + retval = IsStringInBiggerString(Unity.TestFile, ptr1); + if (retval == 1) + { + return retval; + } + + /* done if testname match after filename partial match */ + if ((retval == 2) && (ptrf != 0)) + { + if (IsStringInBiggerString(Unity.CurrentTestName, ptrf)) + { + return 1; + } + } + + /* done if complete testname match */ + if (IsStringInBiggerString(Unity.CurrentTestName, ptr1) == 1) + { + return 1; + } + + ptr1 = ptr2; + } + + /* we couldn't find a match for any substrings */ + return 0; +} + +/*-----------------------------------------------*/ +int UnityTestMatches(void) +{ + /* Check if this test name matches the included test pattern */ + int retval; + if (UnityOptionIncludeNamed) + { + retval = UnityStringArgumentMatches(UnityOptionIncludeNamed); + } + else + { + retval = 1; + } + + /* Check if this test name matches the excluded test pattern */ + if (UnityOptionExcludeNamed) + { + if (UnityStringArgumentMatches(UnityOptionExcludeNamed)) + { + retval = 0; + } + } + + return retval; +} + +#endif /* UNITY_USE_COMMAND_LINE_ARGS */ +/*-----------------------------------------------*/ diff --git a/applications/test/unity/unity.h b/applications/test/unity/unity.h new file mode 100644 index 0000000..14225a3 --- /dev/null +++ b/applications/test/unity/unity.h @@ -0,0 +1,661 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007-21 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#ifndef UNITY_FRAMEWORK_H +#define UNITY_FRAMEWORK_H +#define UNITY + +#define UNITY_VERSION_MAJOR 2 +#define UNITY_VERSION_MINOR 5 +#define UNITY_VERSION_BUILD 4 +#define UNITY_VERSION ((UNITY_VERSION_MAJOR << 16) | (UNITY_VERSION_MINOR << 8) | UNITY_VERSION_BUILD) + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include "unity_internals.h" + +/*------------------------------------------------------- + * Test Setup / Teardown + *-------------------------------------------------------*/ + +/* These functions are intended to be called before and after each test. + * If using unity directly, these will need to be provided for each test + * executable built. If you are using the test runner generator and/or + * Ceedling, these are optional. */ +void setUp(void); +void tearDown(void); + +/* These functions are intended to be called at the beginning and end of an + * entire test suite. suiteTearDown() is passed the number of tests that + * failed, and its return value becomes the exit code of main(). If using + * Unity directly, you're in charge of calling these if they are desired. + * If using Ceedling or the test runner generator, these will be called + * automatically if they exist. */ +void suiteSetUp(void); +int suiteTearDown(int num_failures); + +/*------------------------------------------------------- + * Test Reset and Verify + *-------------------------------------------------------*/ + +/* These functions are intended to be called before during tests in order + * to support complex test loops, etc. Both are NOT built into Unity. Instead + * the test runner generator will create them. resetTest will run teardown and + * setup again, verifying any end-of-test needs between. verifyTest will only + * run the verification. */ +void resetTest(void); +void verifyTest(void); + +/*------------------------------------------------------- + * Configuration Options + *------------------------------------------------------- + * All options described below should be passed as a compiler flag to all files using Unity. If you must add #defines, place them BEFORE the #include above. + + * Integers/longs/pointers + * - Unity attempts to automatically discover your integer sizes + * - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in + * - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in + * - If you cannot use the automatic methods above, you can force Unity by using these options: + * - define UNITY_SUPPORT_64 + * - set UNITY_INT_WIDTH + * - set UNITY_LONG_WIDTH + * - set UNITY_POINTER_WIDTH + + * Floats + * - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons + * - define UNITY_FLOAT_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_FLOAT + * - define UNITY_FLOAT_TYPE to specify doubles instead of single precision floats + * - define UNITY_INCLUDE_DOUBLE to allow double floating point comparisons + * - define UNITY_EXCLUDE_DOUBLE to disallow double floating point comparisons (default) + * - define UNITY_DOUBLE_PRECISION to specify the precision to use when doing TEST_ASSERT_EQUAL_DOUBLE + * - define UNITY_DOUBLE_TYPE to specify something other than double + * - define UNITY_EXCLUDE_FLOAT_PRINT to trim binary size, won't print floating point values in errors + + * Output + * - by default, Unity prints to standard out with putchar. define UNITY_OUTPUT_CHAR(a) with a different function if desired + * - define UNITY_DIFFERENTIATE_FINAL_FAIL to print FAILED (vs. FAIL) at test end summary - for automated search for failure + + * Optimization + * - by default, line numbers are stored in unsigned shorts. Define UNITY_LINE_TYPE with a different type if your files are huge + * - by default, test and failure counters are unsigned shorts. Define UNITY_COUNTER_TYPE with a different type if you want to save space or have more than 65535 Tests. + + * Test Cases + * - define UNITY_SUPPORT_TEST_CASES to include the TEST_CASE macro, though really it's mostly about the runner generator script + + * Parameterized Tests + * - you'll want to create a define of TEST_CASE(...) which basically evaluates to nothing + + * Tests with Arguments + * - you'll want to define UNITY_USE_COMMAND_LINE_ARGS if you have the test runner passing arguments to Unity + + *------------------------------------------------------- + * Basic Fail and Ignore + *-------------------------------------------------------*/ + +#define TEST_FAIL_MESSAGE(message) UNITY_TEST_FAIL(__LINE__, (message)) +#define TEST_FAIL() UNITY_TEST_FAIL(__LINE__, NULL) +#define TEST_IGNORE_MESSAGE(message) UNITY_TEST_IGNORE(__LINE__, (message)) +#define TEST_IGNORE() UNITY_TEST_IGNORE(__LINE__, NULL) +#define TEST_MESSAGE(message) UnityMessage((message), __LINE__) +#define TEST_ONLY() +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +#define TEST_PRINTF(message, ...) UnityPrintF(__LINE__, (message), __VA_ARGS__) +#endif + +/* It is not necessary for you to call PASS. A PASS condition is assumed if nothing fails. + * This method allows you to abort a test immediately with a PASS state, ignoring the remainder of the test. */ +#define TEST_PASS() TEST_ABORT() +#define TEST_PASS_MESSAGE(message) do { UnityMessage((message), __LINE__); TEST_ABORT(); } while (0) + +/* This macro does nothing, but it is useful for build tools (like Ceedling) to make use of this to figure out + * which files should be linked to in order to perform a test. Use it like TEST_FILE("sandwiches.c") */ +#define TEST_FILE(a) + +/*------------------------------------------------------- + * Test Asserts (simple) + *-------------------------------------------------------*/ + +/* Boolean */ +#define TEST_ASSERT(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expression Evaluated To FALSE") +#define TEST_ASSERT_TRUE(condition) UNITY_TEST_ASSERT( (condition), __LINE__, " Expected TRUE Was FALSE") +#define TEST_ASSERT_UNLESS(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expression Evaluated To TRUE") +#define TEST_ASSERT_FALSE(condition) UNITY_TEST_ASSERT( !(condition), __LINE__, " Expected FALSE Was TRUE") +#define TEST_ASSERT_NULL(pointer) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, " Expected NULL") +#define TEST_ASSERT_NOT_NULL(pointer) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, " Expected Non-NULL") +#define TEST_ASSERT_EMPTY(pointer) UNITY_TEST_ASSERT_EMPTY( (pointer), __LINE__, " Expected Empty") +#define TEST_ASSERT_NOT_EMPTY(pointer) UNITY_TEST_ASSERT_NOT_EMPTY((pointer), __LINE__, " Expected Non-Empty") + +/* Integers (of all sizes) */ +#define TEST_ASSERT_EQUAL_INT(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT16(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT32(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT64(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_size_t(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX8(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX16(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX32(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX64(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_CHAR(expected, actual) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS(mask, expected, actual) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS_HIGH(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT)(-1), (actual), __LINE__, NULL) +#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT)(0), (actual), __LINE__, NULL) +#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(-1), (actual), __LINE__, NULL) +#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((UNITY_UINT)1 << (bit)), (UNITY_UINT)(0), (actual), __LINE__, NULL) + +/* Integer Not Equal To (of all sizes) */ +#define TEST_ASSERT_NOT_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (actual), __LINE__, NULL) + +/* Integer Greater Than/ Less Than (of all sizes) */ +#define TEST_ASSERT_GREATER_THAN(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((threshold), (actual), __LINE__, NULL) + +#define TEST_ASSERT_LESS_THAN(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_THAN_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, NULL) + +#define TEST_ASSERT_GREATER_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL) + +#define TEST_ASSERT_LESS_OR_EQUAL(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_INT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_size_t(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX8(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX16(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX32(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX64(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, NULL) +#define TEST_ASSERT_LESS_OR_EQUAL_CHAR(threshold, actual) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, NULL) + +/* Integer Ranges (of all sizes) */ +#define TEST_ASSERT_INT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_INT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_UINT64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_size_t_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX8_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX16_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_HEX64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_CHAR_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, NULL) + +/* Integer Array Ranges (of all sizes) */ +#define TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_size_t_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) +#define TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, NULL) + + +/* Structs and Strings */ +#define TEST_ASSERT_EQUAL_PTR(expected, actual) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_STRING(expected, actual) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, NULL) + +/* Arrays */ +#define TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_size_t_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_CHAR_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) + +/* Arrays Compared To Single Value */ +#define TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_size_t(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, NULL) + +/* Floating Point (If Enabled) */ +#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, NULL) + +/* Double (If Enabled) */ +#define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, NULL) + +/* Shorthand */ +#ifdef UNITY_SHORTHAND_AS_OLD +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal") +#endif +#ifdef UNITY_SHORTHAND_AS_INT +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_MEM +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, NULL) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_RAW +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, " Expected Equal") +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal") +#endif +#ifdef UNITY_SHORTHAND_AS_NONE +#define TEST_ASSERT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif + +/*------------------------------------------------------- + * Test Asserts (with additional messages) + *-------------------------------------------------------*/ + +/* Boolean */ +#define TEST_ASSERT_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message)) +#define TEST_ASSERT_TRUE_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, (message)) +#define TEST_ASSERT_UNLESS_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message)) +#define TEST_ASSERT_FALSE_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, (message)) +#define TEST_ASSERT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, (message)) +#define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, (message)) +#define TEST_ASSERT_EMPTY_MESSAGE(pointer, message) UNITY_TEST_ASSERT_EMPTY( (pointer), __LINE__, (message)) +#define TEST_ASSERT_NOT_EMPTY_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_EMPTY((pointer), __LINE__, (message)) + +/* Integers (of all sizes) */ +#define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_size_t_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, message) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(-1), (actual), __LINE__, (message)) +#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (UNITY_UINT32)(0), (actual), __LINE__, (message)) +#define TEST_ASSERT_BIT_HIGH_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(-1), (actual), __LINE__, (message)) +#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((UNITY_UINT32)1 << (bit)), (UNITY_UINT32)(0), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_CHAR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_CHAR((expected), (actual), __LINE__, (message)) + +/* Integer Not Equal To (of all sizes) */ +#define TEST_ASSERT_NOT_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_CHAR((threshold), (actual), __LINE__, (message)) + + +/* Integer Greater Than/ Less Than (of all sizes) */ +#define TEST_ASSERT_GREATER_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_CHAR((threshold), (actual), __LINE__, (message)) + +#define TEST_ASSERT_LESS_THAN_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_THAN_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_THAN_CHAR((threshold), (actual), __LINE__, (message)) + +#define TEST_ASSERT_GREATER_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_GREATER_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message)) + +#define TEST_ASSERT_LESS_OR_EQUAL_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_INT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_UINT64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_size_t_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX8_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX16_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX32_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_HEX64_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64((threshold), (actual), __LINE__, (message)) +#define TEST_ASSERT_LESS_OR_EQUAL_CHAR_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR((threshold), (actual), __LINE__, (message)) + +/* Integer Ranges (of all sizes) */ +#define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT8_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT16_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_INT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT64_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT8_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT16_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_UINT64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT64_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_size_t_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_UINT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX8_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX8_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX16_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX64_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_CHAR_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_CHAR_WITHIN((delta), (expected), (actual), __LINE__, (message)) + +/* Integer Array Ranges (of all sizes) */ +#define TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_size_t_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) +#define TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN((delta), (expected), (actual), num_elements, __LINE__, (message)) + + +/* Structs and Strings */ +#define TEST_ASSERT_EQUAL_PTR_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_PTR((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_STRING((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_STRING_LEN((expected), (actual), (len), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((expected), (actual), (len), __LINE__, (message)) + +/* Arrays */ +#define TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_INT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_UINT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_size_t_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_HEX64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_PTR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((expected), (actual), (len), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_CHAR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) + +/* Arrays Compared To Single Value*/ +#define TEST_ASSERT_EACH_EQUAL_INT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT8((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT16((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_INT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_INT64((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT8((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT16((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_UINT64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT64((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_size_t_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_UINT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX8_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX8((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX16_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX16((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX32_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX32((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_HEX64_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_HEX64((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_PTR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_PTR((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_STRING_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_STRING((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_MEMORY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY((expected), (actual), (len), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_CHAR_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_CHAR((expected), (actual), (num_elements), __LINE__, (message)) + +/* Floating Point (If Enabled) */ +#define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_FLOAT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE((actual), __LINE__, (message)) + +/* Double (If Enabled) */ +#define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_EACH_EQUAL_DOUBLE_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN((actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE((actual), __LINE__, (message)) + +/* Shorthand */ +#ifdef UNITY_SHORTHAND_AS_OLD +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, (message)) +#endif +#ifdef UNITY_SHORTHAND_AS_INT +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, message) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_MEM +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_MEMORY((&expected), (&actual), sizeof(expected), __LINE__, message) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif +#ifdef UNITY_SHORTHAND_AS_RAW +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) == (actual)), __LINE__, message) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, message) +#endif +#ifdef UNITY_SHORTHAND_AS_NONE +#define TEST_ASSERT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_FAIL(__LINE__, UnityStrErrShorthand) +#endif + +/* end of UNITY_FRAMEWORK_H */ +#ifdef __cplusplus +} +#endif +#endif diff --git a/applications/test/unity/unity_internals.h b/applications/test/unity/unity_internals.h new file mode 100644 index 0000000..d303e8f --- /dev/null +++ b/applications/test/unity/unity_internals.h @@ -0,0 +1,1053 @@ +/* ========================================== + Unity Project - A Test Framework for C + Copyright (c) 2007-21 Mike Karlesky, Mark VanderVoord, Greg Williams + [Released under MIT License. Please refer to license.txt for details] +========================================== */ + +#ifndef UNITY_INTERNALS_H +#define UNITY_INTERNALS_H + +#ifdef UNITY_INCLUDE_CONFIG_H +#include "unity_config.h" +#endif + +#ifndef UNITY_EXCLUDE_SETJMP_H +#include +#endif + +#ifndef UNITY_EXCLUDE_MATH_H +#include +#endif + +#ifndef UNITY_EXCLUDE_STDDEF_H +#include +#endif + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +#include +#endif + +/* Unity Attempts to Auto-Detect Integer Types + * Attempt 1: UINT_MAX, ULONG_MAX in , or default to 32 bits + * Attempt 2: UINTPTR_MAX in , or default to same size as long + * The user may override any of these derived constants: + * UNITY_INT_WIDTH, UNITY_LONG_WIDTH, UNITY_POINTER_WIDTH */ +#ifndef UNITY_EXCLUDE_STDINT_H +#include +#endif + +#ifndef UNITY_EXCLUDE_LIMITS_H +#include +#endif + +#if defined(__GNUC__) || defined(__clang__) + #define UNITY_FUNCTION_ATTR(a) __attribute__((a)) +#else + #define UNITY_FUNCTION_ATTR(a) /* ignore */ +#endif + +#ifndef UNITY_NORETURN + #if defined(__cplusplus) + #if __cplusplus >= 201103L + #define UNITY_NORETURN [[ noreturn ]] + #endif + #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #include + #define UNITY_NORETURN noreturn + #endif +#endif +#ifndef UNITY_NORETURN + #define UNITY_NORETURN UNITY_FUNCTION_ATTR(noreturn) +#endif + +/*------------------------------------------------------- + * Guess Widths If Not Specified + *-------------------------------------------------------*/ + +/* Determine the size of an int, if not already specified. + * We cannot use sizeof(int), because it is not yet defined + * at this stage in the translation of the C program. + * Also sizeof(int) does return the size in addressable units on all platforms, + * which may not necessarily be the size in bytes. + * Therefore, infer it from UINT_MAX if possible. */ +#ifndef UNITY_INT_WIDTH + #ifdef UINT_MAX + #if (UINT_MAX == 0xFFFF) + #define UNITY_INT_WIDTH (16) + #elif (UINT_MAX == 0xFFFFFFFF) + #define UNITY_INT_WIDTH (32) + #elif (UINT_MAX == 0xFFFFFFFFFFFFFFFF) + #define UNITY_INT_WIDTH (64) + #endif + #else /* Set to default */ + #define UNITY_INT_WIDTH (32) + #endif /* UINT_MAX */ +#endif + +/* Determine the size of a long, if not already specified. */ +#ifndef UNITY_LONG_WIDTH + #ifdef ULONG_MAX + #if (ULONG_MAX == 0xFFFF) + #define UNITY_LONG_WIDTH (16) + #elif (ULONG_MAX == 0xFFFFFFFF) + #define UNITY_LONG_WIDTH (32) + #elif (ULONG_MAX == 0xFFFFFFFFFFFFFFFF) + #define UNITY_LONG_WIDTH (64) + #endif + #else /* Set to default */ + #define UNITY_LONG_WIDTH (32) + #endif /* ULONG_MAX */ +#endif + +/* Determine the size of a pointer, if not already specified. */ +#ifndef UNITY_POINTER_WIDTH + #ifdef UINTPTR_MAX + #if (UINTPTR_MAX <= 0xFFFF) + #define UNITY_POINTER_WIDTH (16) + #elif (UINTPTR_MAX <= 0xFFFFFFFF) + #define UNITY_POINTER_WIDTH (32) + #elif (UINTPTR_MAX <= 0xFFFFFFFFFFFFFFFF) + #define UNITY_POINTER_WIDTH (64) + #endif + #else /* Set to default */ + #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH + #endif /* UINTPTR_MAX */ +#endif + +/*------------------------------------------------------- + * Int Support (Define types based on detected sizes) + *-------------------------------------------------------*/ + +#if (UNITY_INT_WIDTH == 32) + typedef unsigned char UNITY_UINT8; + typedef unsigned short UNITY_UINT16; + typedef unsigned int UNITY_UINT32; + typedef signed char UNITY_INT8; + typedef signed short UNITY_INT16; + typedef signed int UNITY_INT32; +#elif (UNITY_INT_WIDTH == 16) + typedef unsigned char UNITY_UINT8; + typedef unsigned int UNITY_UINT16; + typedef unsigned long UNITY_UINT32; + typedef signed char UNITY_INT8; + typedef signed int UNITY_INT16; + typedef signed long UNITY_INT32; +#else + #error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported) +#endif + +/*------------------------------------------------------- + * 64-bit Support + *-------------------------------------------------------*/ + +/* Auto-detect 64 Bit Support */ +#ifndef UNITY_SUPPORT_64 + #if UNITY_LONG_WIDTH == 64 || UNITY_POINTER_WIDTH == 64 + #define UNITY_SUPPORT_64 + #endif +#endif + +/* 64-Bit Support Dependent Configuration */ +#ifndef UNITY_SUPPORT_64 + /* No 64-bit Support */ + typedef UNITY_UINT32 UNITY_UINT; + typedef UNITY_INT32 UNITY_INT; + #define UNITY_MAX_NIBBLES (8) /* Maximum number of nibbles in a UNITY_(U)INT */ +#else + /* 64-bit Support */ + #if (UNITY_LONG_WIDTH == 32) + typedef unsigned long long UNITY_UINT64; + typedef signed long long UNITY_INT64; + #elif (UNITY_LONG_WIDTH == 64) + typedef unsigned long UNITY_UINT64; + typedef signed long UNITY_INT64; + #else + #error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported) + #endif + typedef UNITY_UINT64 UNITY_UINT; + typedef UNITY_INT64 UNITY_INT; + #define UNITY_MAX_NIBBLES (16) /* Maximum number of nibbles in a UNITY_(U)INT */ +#endif + +/*------------------------------------------------------- + * Pointer Support + *-------------------------------------------------------*/ + +#if (UNITY_POINTER_WIDTH == 32) + #define UNITY_PTR_TO_INT UNITY_INT32 + #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32 +#elif (UNITY_POINTER_WIDTH == 64) + #define UNITY_PTR_TO_INT UNITY_INT64 + #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64 +#elif (UNITY_POINTER_WIDTH == 16) + #define UNITY_PTR_TO_INT UNITY_INT16 + #define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX16 +#else + #error Invalid UNITY_POINTER_WIDTH specified! (16, 32 or 64 are supported) +#endif + +#ifndef UNITY_PTR_ATTRIBUTE + #define UNITY_PTR_ATTRIBUTE +#endif + +#ifndef UNITY_INTERNAL_PTR + #define UNITY_INTERNAL_PTR UNITY_PTR_ATTRIBUTE const void* +#endif + +/*------------------------------------------------------- + * Float Support + *-------------------------------------------------------*/ + +#ifdef UNITY_EXCLUDE_FLOAT + +/* No Floating Point Support */ +#ifndef UNITY_EXCLUDE_DOUBLE +#define UNITY_EXCLUDE_DOUBLE /* Remove double when excluding float support */ +#endif +#ifndef UNITY_EXCLUDE_FLOAT_PRINT +#define UNITY_EXCLUDE_FLOAT_PRINT +#endif + +#else + +/* Floating Point Support */ +#ifndef UNITY_FLOAT_PRECISION +#define UNITY_FLOAT_PRECISION (0.00001f) +#endif +#ifndef UNITY_FLOAT_TYPE +#define UNITY_FLOAT_TYPE float +#endif +typedef UNITY_FLOAT_TYPE UNITY_FLOAT; + +/* isinf & isnan macros should be provided by math.h */ +#ifndef isinf +/* The value of Inf - Inf is NaN */ +#define isinf(n) (isnan((n) - (n)) && !isnan(n)) +#endif + +#ifndef isnan +/* NaN is the only floating point value that does NOT equal itself. + * Therefore if n != n, then it is NaN. */ +#define isnan(n) ((n != n) ? 1 : 0) +#endif + +#endif + +/*------------------------------------------------------- + * Double Float Support + *-------------------------------------------------------*/ + +/* unlike float, we DON'T include by default */ +#if defined(UNITY_EXCLUDE_DOUBLE) || !defined(UNITY_INCLUDE_DOUBLE) + + /* No Floating Point Support */ + #ifndef UNITY_EXCLUDE_DOUBLE + #define UNITY_EXCLUDE_DOUBLE + #else + #undef UNITY_INCLUDE_DOUBLE + #endif + + #ifndef UNITY_EXCLUDE_FLOAT + #ifndef UNITY_DOUBLE_TYPE + #define UNITY_DOUBLE_TYPE double + #endif + typedef UNITY_FLOAT UNITY_DOUBLE; + /* For parameter in UnityPrintFloat(UNITY_DOUBLE), which aliases to double or float */ + #endif + +#else + + /* Double Floating Point Support */ + #ifndef UNITY_DOUBLE_PRECISION + #define UNITY_DOUBLE_PRECISION (1e-12) + #endif + + #ifndef UNITY_DOUBLE_TYPE + #define UNITY_DOUBLE_TYPE double + #endif + typedef UNITY_DOUBLE_TYPE UNITY_DOUBLE; + +#endif + +/*------------------------------------------------------- + * Output Method: stdout (DEFAULT) + *-------------------------------------------------------*/ +#ifndef UNITY_OUTPUT_CHAR + /* Default to using putchar, which is defined in stdio.h */ + #include + #define UNITY_OUTPUT_CHAR(a) (void)putchar(a) +#else + /* If defined as something else, make sure we declare it here so it's ready for use */ + #ifdef UNITY_OUTPUT_CHAR_HEADER_DECLARATION + extern void UNITY_OUTPUT_CHAR_HEADER_DECLARATION; + #endif +#endif + +#ifndef UNITY_OUTPUT_FLUSH + #ifdef UNITY_USE_FLUSH_STDOUT + /* We want to use the stdout flush utility */ + #include + #define UNITY_OUTPUT_FLUSH() (void)fflush(stdout) + #else + /* We've specified nothing, therefore flush should just be ignored */ + #define UNITY_OUTPUT_FLUSH() (void)0 + #endif +#else + /* If defined as something else, make sure we declare it here so it's ready for use */ + #ifdef UNITY_OUTPUT_FLUSH_HEADER_DECLARATION + extern void UNITY_OUTPUT_FLUSH_HEADER_DECLARATION; + #endif +#endif + +#ifndef UNITY_OUTPUT_FLUSH +#define UNITY_FLUSH_CALL() +#else +#define UNITY_FLUSH_CALL() UNITY_OUTPUT_FLUSH() +#endif + +#ifndef UNITY_PRINT_EOL +#define UNITY_PRINT_EOL() UNITY_OUTPUT_CHAR('\n') +#endif + +#ifndef UNITY_OUTPUT_START +#define UNITY_OUTPUT_START() +#endif + +#ifndef UNITY_OUTPUT_COMPLETE +#define UNITY_OUTPUT_COMPLETE() +#endif + +#ifdef UNITY_INCLUDE_EXEC_TIME + #if !defined(UNITY_EXEC_TIME_START) && \ + !defined(UNITY_EXEC_TIME_STOP) && \ + !defined(UNITY_PRINT_EXEC_TIME) && \ + !defined(UNITY_TIME_TYPE) + /* If none any of these macros are defined then try to provide a default implementation */ + + #if defined(UNITY_CLOCK_MS) + /* This is a simple way to get a default implementation on platforms that support getting a millisecond counter */ + #define UNITY_TIME_TYPE UNITY_UINT + #define UNITY_EXEC_TIME_START() Unity.CurrentTestStartTime = UNITY_CLOCK_MS() + #define UNITY_EXEC_TIME_STOP() Unity.CurrentTestStopTime = UNITY_CLOCK_MS() + #define UNITY_PRINT_EXEC_TIME() { \ + UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \ + UnityPrint(" ("); \ + UnityPrintNumberUnsigned(execTimeMs); \ + UnityPrint(" ms)"); \ + } + #elif defined(_WIN32) + #include + #define UNITY_TIME_TYPE clock_t + #define UNITY_GET_TIME(t) t = (clock_t)((clock() * 1000) / CLOCKS_PER_SEC) + #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime) + #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime) + #define UNITY_PRINT_EXEC_TIME() { \ + UNITY_UINT execTimeMs = (Unity.CurrentTestStopTime - Unity.CurrentTestStartTime); \ + UnityPrint(" ("); \ + UnityPrintNumberUnsigned(execTimeMs); \ + UnityPrint(" ms)"); \ + } + #elif defined(__unix__) || defined(__APPLE__) + #include + #define UNITY_TIME_TYPE struct timespec + #define UNITY_GET_TIME(t) clock_gettime(CLOCK_MONOTONIC, &t) + #define UNITY_EXEC_TIME_START() UNITY_GET_TIME(Unity.CurrentTestStartTime) + #define UNITY_EXEC_TIME_STOP() UNITY_GET_TIME(Unity.CurrentTestStopTime) + #define UNITY_PRINT_EXEC_TIME() { \ + UNITY_UINT execTimeMs = ((Unity.CurrentTestStopTime.tv_sec - Unity.CurrentTestStartTime.tv_sec) * 1000L); \ + execTimeMs += ((Unity.CurrentTestStopTime.tv_nsec - Unity.CurrentTestStartTime.tv_nsec) / 1000000L); \ + UnityPrint(" ("); \ + UnityPrintNumberUnsigned(execTimeMs); \ + UnityPrint(" ms)"); \ + } + #endif + #endif +#endif + +#ifndef UNITY_EXEC_TIME_START +#define UNITY_EXEC_TIME_START() do { /* nothing*/ } while (0) +#endif + +#ifndef UNITY_EXEC_TIME_STOP +#define UNITY_EXEC_TIME_STOP() do { /* nothing*/ } while (0) +#endif + +#ifndef UNITY_TIME_TYPE +#define UNITY_TIME_TYPE UNITY_UINT +#endif + +#ifndef UNITY_PRINT_EXEC_TIME +#define UNITY_PRINT_EXEC_TIME() do { /* nothing*/ } while (0) +#endif + +/*------------------------------------------------------- + * Footprint + *-------------------------------------------------------*/ + +#ifndef UNITY_LINE_TYPE +#define UNITY_LINE_TYPE UNITY_UINT +#endif + +#ifndef UNITY_COUNTER_TYPE +#define UNITY_COUNTER_TYPE UNITY_UINT +#endif + +/*------------------------------------------------------- + * Internal Structs Needed + *-------------------------------------------------------*/ + +typedef void (*UnityTestFunction)(void); + +#define UNITY_DISPLAY_RANGE_INT (0x10) +#define UNITY_DISPLAY_RANGE_UINT (0x20) +#define UNITY_DISPLAY_RANGE_HEX (0x40) +#define UNITY_DISPLAY_RANGE_CHAR (0x80) + +typedef enum +{ + UNITY_DISPLAY_STYLE_INT = (UNITY_INT_WIDTH / 8) + UNITY_DISPLAY_RANGE_INT, + UNITY_DISPLAY_STYLE_INT8 = 1 + UNITY_DISPLAY_RANGE_INT, + UNITY_DISPLAY_STYLE_INT16 = 2 + UNITY_DISPLAY_RANGE_INT, + UNITY_DISPLAY_STYLE_INT32 = 4 + UNITY_DISPLAY_RANGE_INT, +#ifdef UNITY_SUPPORT_64 + UNITY_DISPLAY_STYLE_INT64 = 8 + UNITY_DISPLAY_RANGE_INT, +#endif + + UNITY_DISPLAY_STYLE_UINT = (UNITY_INT_WIDTH / 8) + UNITY_DISPLAY_RANGE_UINT, + UNITY_DISPLAY_STYLE_UINT8 = 1 + UNITY_DISPLAY_RANGE_UINT, + UNITY_DISPLAY_STYLE_UINT16 = 2 + UNITY_DISPLAY_RANGE_UINT, + UNITY_DISPLAY_STYLE_UINT32 = 4 + UNITY_DISPLAY_RANGE_UINT, +#ifdef UNITY_SUPPORT_64 + UNITY_DISPLAY_STYLE_UINT64 = 8 + UNITY_DISPLAY_RANGE_UINT, +#endif + + UNITY_DISPLAY_STYLE_HEX8 = 1 + UNITY_DISPLAY_RANGE_HEX, + UNITY_DISPLAY_STYLE_HEX16 = 2 + UNITY_DISPLAY_RANGE_HEX, + UNITY_DISPLAY_STYLE_HEX32 = 4 + UNITY_DISPLAY_RANGE_HEX, +#ifdef UNITY_SUPPORT_64 + UNITY_DISPLAY_STYLE_HEX64 = 8 + UNITY_DISPLAY_RANGE_HEX, +#endif + + UNITY_DISPLAY_STYLE_CHAR = 1 + UNITY_DISPLAY_RANGE_CHAR + UNITY_DISPLAY_RANGE_INT, + + UNITY_DISPLAY_STYLE_UNKNOWN +} UNITY_DISPLAY_STYLE_T; + +typedef enum +{ + UNITY_WITHIN = 0x0, + UNITY_EQUAL_TO = 0x1, + UNITY_GREATER_THAN = 0x2, + UNITY_GREATER_OR_EQUAL = 0x2 + UNITY_EQUAL_TO, + UNITY_SMALLER_THAN = 0x4, + UNITY_SMALLER_OR_EQUAL = 0x4 + UNITY_EQUAL_TO, + UNITY_NOT_EQUAL = 0x0, + UNITY_UNKNOWN +} UNITY_COMPARISON_T; + +#ifndef UNITY_EXCLUDE_FLOAT +typedef enum UNITY_FLOAT_TRAIT +{ + UNITY_FLOAT_IS_NOT_INF = 0, + UNITY_FLOAT_IS_INF, + UNITY_FLOAT_IS_NOT_NEG_INF, + UNITY_FLOAT_IS_NEG_INF, + UNITY_FLOAT_IS_NOT_NAN, + UNITY_FLOAT_IS_NAN, + UNITY_FLOAT_IS_NOT_DET, + UNITY_FLOAT_IS_DET, + UNITY_FLOAT_INVALID_TRAIT +} UNITY_FLOAT_TRAIT_T; +#endif + +typedef enum +{ + UNITY_ARRAY_TO_VAL = 0, + UNITY_ARRAY_TO_ARRAY, + UNITY_ARRAY_UNKNOWN +} UNITY_FLAGS_T; + +struct UNITY_STORAGE_T +{ + const char* TestFile; + const char* CurrentTestName; +#ifndef UNITY_EXCLUDE_DETAILS + const char* CurrentDetail1; + const char* CurrentDetail2; +#endif + 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 +}; + +extern struct UNITY_STORAGE_T Unity; + +/*------------------------------------------------------- + * Test Suite Management + *-------------------------------------------------------*/ + +void UnityBegin(const char* filename); +int UnityEnd(void); +void UnitySetTestFile(const char* filename); +void UnityConcludeTest(void); + +#ifndef RUN_TEST +void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum); +#else +#define UNITY_SKIP_DEFAULT_RUNNER +#endif + +/*------------------------------------------------------- + * Details Support + *-------------------------------------------------------*/ + +#ifdef UNITY_EXCLUDE_DETAILS +#define UNITY_CLR_DETAILS() +#define UNITY_SET_DETAIL(d1) +#define UNITY_SET_DETAILS(d1,d2) +#else +#define UNITY_CLR_DETAILS() do { Unity.CurrentDetail1 = 0; Unity.CurrentDetail2 = 0; } while (0) +#define UNITY_SET_DETAIL(d1) do { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = 0; } while (0) +#define UNITY_SET_DETAILS(d1,d2) do { Unity.CurrentDetail1 = (d1); Unity.CurrentDetail2 = (d2); } while (0) + +#ifndef UNITY_DETAIL1_NAME +#define UNITY_DETAIL1_NAME "Function" +#endif + +#ifndef UNITY_DETAIL2_NAME +#define UNITY_DETAIL2_NAME "Argument" +#endif +#endif + +#ifdef UNITY_PRINT_TEST_CONTEXT +void UNITY_PRINT_TEST_CONTEXT(void); +#endif + +/*------------------------------------------------------- + * Test Output + *-------------------------------------------------------*/ + +void UnityPrint(const char* string); + +#ifdef UNITY_INCLUDE_PRINT_FORMATTED +void UnityPrintF(const UNITY_LINE_TYPE line, const char* format, ...); +#endif + +void UnityPrintLen(const char* string, const UNITY_UINT32 length); +void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number); +void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style); +void UnityPrintNumber(const UNITY_INT number_to_print); +void UnityPrintNumberUnsigned(const UNITY_UINT number); +void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print); + +#ifndef UNITY_EXCLUDE_FLOAT_PRINT +void UnityPrintFloat(const UNITY_DOUBLE input_number); +#endif + +/*------------------------------------------------------- + * Test Assertion Functions + *------------------------------------------------------- + * Use the macros below this section instead of calling + * these directly. The macros have a consistent naming + * convention and will pull in file and line information + * for you. */ + +void UnityAssertEqualNumber(const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold, + const UNITY_INT actual, + const UNITY_COMPARISON_T compare, + const char *msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags); + +void UnityAssertBits(const UNITY_INT mask, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualString(const char* expected, + const char* actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualStringLen(const char* expected, + const char* actual, + const UNITY_UINT32 length, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualStringArray( UNITY_INTERNAL_PTR expected, + const char** actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 length, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertNumbersWithin(const UNITY_UINT delta, + const UNITY_INT expected, + const UNITY_INT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style); + +void UnityAssertNumbersArrayWithin(const UNITY_UINT delta, + UNITY_INTERNAL_PTR expected, + UNITY_INTERNAL_PTR actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_DISPLAY_STYLE_T style, + const UNITY_FLAGS_T flags); + +#ifndef UNITY_EXCLUDE_SETJMP_H +UNITY_NORETURN void UnityFail(const char* message, const UNITY_LINE_TYPE line); +UNITY_NORETURN void UnityIgnore(const char* message, const UNITY_LINE_TYPE line); +#else +void UnityFail(const char* message, const UNITY_LINE_TYPE line); +void UnityIgnore(const char* message, const UNITY_LINE_TYPE line); +#endif + +void UnityMessage(const char* message, const UNITY_LINE_TYPE line); + +#ifndef UNITY_EXCLUDE_FLOAT +void UnityAssertFloatsWithin(const UNITY_FLOAT delta, + const UNITY_FLOAT expected, + const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertFloatSpecial(const UNITY_FLOAT actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style); +#endif + +#ifndef UNITY_EXCLUDE_DOUBLE +void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, + const UNITY_DOUBLE expected, + const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber); + +void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); + +void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLOAT_TRAIT_T style); +#endif + +/*------------------------------------------------------- + * Helpers + *-------------------------------------------------------*/ + +UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size); +#ifndef UNITY_EXCLUDE_FLOAT +UNITY_INTERNAL_PTR UnityFloatToPtr(const float num); +#endif +#ifndef UNITY_EXCLUDE_DOUBLE +UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num); +#endif + +/*------------------------------------------------------- + * Error Strings We Might Need + *-------------------------------------------------------*/ + +extern const char UnityStrOk[]; +extern const char UnityStrPass[]; +extern const char UnityStrFail[]; +extern const char UnityStrIgnore[]; + +extern const char UnityStrErrFloat[]; +extern const char UnityStrErrDouble[]; +extern const char UnityStrErr64[]; +extern const char UnityStrErrShorthand[]; + +/*------------------------------------------------------- + * Test Running Macros + *-------------------------------------------------------*/ + +#ifndef UNITY_EXCLUDE_SETJMP_H +#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0) +#define TEST_ABORT() longjmp(Unity.AbortFrame, 1) +#else +#define TEST_PROTECT() 1 +#define TEST_ABORT() return +#endif + +/* This tricky series of macros gives us an optional line argument to treat it as RUN_TEST(func, num=__LINE__) */ +#ifndef RUN_TEST +#ifdef __STDC_VERSION__ +#if __STDC_VERSION__ >= 199901L +#define UNITY_SUPPORT_VARIADIC_MACROS +#endif +#endif +#ifdef UNITY_SUPPORT_VARIADIC_MACROS +#define RUN_TEST(...) RUN_TEST_AT_LINE(__VA_ARGS__, __LINE__, throwaway) +#define RUN_TEST_AT_LINE(func, line, ...) UnityDefaultTestRun(func, #func, line) +#endif +#endif + +/* If we can't do the tricky version, we'll just have to require them to always include the line number */ +#ifndef RUN_TEST +#ifdef CMOCK +#define RUN_TEST(func, num) UnityDefaultTestRun(func, #func, num) +#else +#define RUN_TEST(func) UnityDefaultTestRun(func, #func, __LINE__) +#endif +#endif + +#define TEST_LINE_NUM (Unity.CurrentTestLineNumber) +#define TEST_IS_IGNORED (Unity.CurrentTestIgnored) +#define UNITY_NEW_TEST(a) \ + Unity.CurrentTestName = (a); \ + Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)(__LINE__); \ + Unity.NumberOfTests++; + +#ifndef UNITY_BEGIN +#define UNITY_BEGIN() UnityBegin(__FILE__) +#endif + +#ifndef UNITY_END +#define UNITY_END() UnityEnd() +#endif + +#ifndef UNITY_SHORTHAND_AS_INT +#ifndef UNITY_SHORTHAND_AS_MEM +#ifndef UNITY_SHORTHAND_AS_NONE +#ifndef UNITY_SHORTHAND_AS_RAW +#define UNITY_SHORTHAND_AS_OLD +#endif +#endif +#endif +#endif + +/*----------------------------------------------- + * Command Line Argument Support + *-----------------------------------------------*/ + +#ifdef UNITY_USE_COMMAND_LINE_ARGS +int UnityParseOptions(int argc, char** argv); +int UnityTestMatches(void); +#endif + +/*------------------------------------------------------- + * Basic Fail and Ignore + *-------------------------------------------------------*/ + +#define UNITY_TEST_FAIL(line, message) UnityFail( (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_IGNORE(line, message) UnityIgnore( (message), (UNITY_LINE_TYPE)(line)) + +/*------------------------------------------------------- + * Test Asserts + *-------------------------------------------------------*/ + +#define UNITY_TEST_ASSERT(condition, line, message) do { if (condition) { /* nothing*/ } else { UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), (message)); } } while (0) +#define UNITY_TEST_ASSERT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) == NULL), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_NOT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) != NULL), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_EMPTY(pointer, line, message) UNITY_TEST_ASSERT(((pointer[0]) == 0), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_NOT_EMPTY(pointer, line, message) UNITY_TEST_ASSERT(((pointer[0]) != 0), (UNITY_LINE_TYPE)(line), (message)) + +#define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_EQUAL_UINT(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT16)(expected), (UNITY_INT)(UNITY_INT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT32)(expected), (UNITY_INT)(UNITY_INT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_EQUAL_CHAR(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(UNITY_INT8 )(expected), (UNITY_INT)(UNITY_INT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) +#define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message) UnityAssertBits((UNITY_INT)(mask), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line)) + +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_NOT_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_GREATER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_GREATER_THAN_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_SMALLER_THAN_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 )(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 ) (threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16) (threshold), (UNITY_INT)(UNITY_INT16) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32) (threshold), (UNITY_INT)(UNITY_INT32) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 ) (threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT16)(threshold), (UNITY_INT)(UNITY_INT16) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT32)(threshold), (UNITY_INT)(UNITY_INT32) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT) (threshold), (UNITY_INT) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX8(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT8 )(threshold), (UNITY_INT)(UNITY_UINT8 )(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX16(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT16)(threshold), (UNITY_INT)(UNITY_UINT16)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX32(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_UINT32)(threshold), (UNITY_INT)(UNITY_UINT32)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_CHAR(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(UNITY_INT8 )(threshold), (UNITY_INT)(UNITY_INT8 ) (actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin( (delta), (UNITY_INT) (expected), (UNITY_INT) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT) +#define UNITY_TEST_ASSERT_INT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_INT8 ) (expected), (UNITY_INT)(UNITY_INT8 ) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8) +#define UNITY_TEST_ASSERT_INT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_INT16) (expected), (UNITY_INT)(UNITY_INT16) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16) +#define UNITY_TEST_ASSERT_INT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_INT32) (expected), (UNITY_INT)(UNITY_INT32) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32) +#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin( (delta), (UNITY_INT) (expected), (UNITY_INT) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT) +#define UNITY_TEST_ASSERT_UINT8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8) +#define UNITY_TEST_ASSERT_UINT16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16) +#define UNITY_TEST_ASSERT_UINT32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32) +#define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT8 )(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8) +#define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT16)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT16)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16) +#define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT32)(delta), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(expected), (UNITY_INT)(UNITY_UINT)(UNITY_UINT32)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32) +#define UNITY_TEST_ASSERT_CHAR_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((UNITY_UINT8 )(delta), (UNITY_INT)(UNITY_INT8 ) (expected), (UNITY_INT)(UNITY_INT8 ) (actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR) + +#define UNITY_TEST_ASSERT_INT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin( (delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_INT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_INT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_INT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin( (delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX8_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX16_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT16)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX32_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT32)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_CHAR_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT8 )(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), ((UNITY_UINT32)(num_elements)), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_ARRAY) + + +#define UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, line, message) UnityAssertEqualNumber((UNITY_PTR_TO_INT)(expected), (UNITY_PTR_TO_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER) +#define UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, line, message) UnityAssertEqualString((const char*)(expected), (const char*)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len, line, message) UnityAssertEqualStringLen((const char*)(expected), (const char*)(actual), (UNITY_UINT32)(len), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), 1, (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) + +#define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_CHAR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_ARRAY) + +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), (UNITY_INT_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT8, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT16, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT32, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT) (expected), (UNITY_INT_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT8, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT16)(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT16, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT32)(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT32, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX8(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX8, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX16(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT16 )(expected), 2), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX16, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX32(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT32 )(expected), 4), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX32, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_PTR(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_PTR_TO_INT) (expected), (UNITY_POINTER_WIDTH / 8)), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_POINTER, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_STRING(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((UNITY_INTERNAL_PTR)(expected), (const char**)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_MEMORY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(len), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_CHAR(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT8 )(expected), 1), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_CHAR, UNITY_ARRAY_TO_VAL) + +#ifdef UNITY_SUPPORT_64 +#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UnityAssertEqualNumber((UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_INT64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_UINT64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_UINT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EACH_EQUAL_HEX64(expected, actual, num_elements, line, message) UnityAssertEqualIntArray(UnityNumToPtr((UNITY_INT)(UNITY_INT64)(expected), 8), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((delta), (UNITY_INT)(expected), (UNITY_INT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_NOT_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_NOT_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_NOT_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_NOT_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message) UnityAssertGreaterOrLessOrEqualNumber((UNITY_INT)(threshold), (UNITY_INT)(actual), UNITY_SMALLER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64) +#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_INT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_UINT64, UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertNumbersArrayWithin((UNITY_UINT64)(delta), (UNITY_INTERNAL_PTR)(expected), (UNITY_INTERNAL_PTR)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_DISPLAY_STYLE_HEX64, UNITY_ARRAY_TO_ARRAY) +#else +#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_INT64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_UINT64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_THAN_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_THAN_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_THAN_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_THAN_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_INT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_UINT64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_SMALLER_OR_EQUAL_HEX64(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_INT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_UINT64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#define UNITY_TEST_ASSERT_HEX64_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErr64) +#endif + +#ifdef UNITY_EXCLUDE_FLOAT +#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#else +#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray((UNITY_FLOAT*)(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray(UnityFloatToPtr(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN) +#define UNITY_TEST_ASSERT_FLOAT_IS_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_NAN(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN) +#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UnityAssertFloatSpecial((UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET) +#endif + +#ifdef UNITY_EXCLUDE_DOUBLE +#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#else +#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line)) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray((UNITY_DOUBLE*)(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray(UnityDoubleToPtr(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NEG_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NAN) +#define UNITY_TEST_ASSERT_DOUBLE_IS_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_DET) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NEG_INF) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_NAN(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_NAN) +#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UnityAssertDoubleSpecial((UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line), UNITY_FLOAT_IS_NOT_DET) +#endif + +/* End of UNITY_INTERNALS_H */ +#endif diff --git a/applications/test/unity_config.h b/applications/test/unity_config.h new file mode 100644 index 0000000..a76d1c7 --- /dev/null +++ b/applications/test/unity_config.h @@ -0,0 +1,10 @@ +#ifndef UNITY_INCLUDE_CONFIG_H +#define UNITY_INCLUDE_CONFIG_H + +#define UNITY_OUTPUT_COLOR +#define UNITY_SUPPORT_TEST_CASES +#define UNITY_OUTPUT_CHAR(a) rt_kprintf("%c", a) + +#include "test_all.h" + +#endif diff --git a/applications/test/write_gcda.py b/applications/test/write_gcda.py new file mode 100644 index 0000000..01f52bb --- /dev/null +++ b/applications/test/write_gcda.py @@ -0,0 +1,14 @@ +# -*- coding: utf-8 -*- +""" +写入gcda，示例： + +with open(r'文件路径', 'wb') as file: + file.write(b'数据') +""" + + +with open(r'E:\Code\test\rtt-gcov\build\applications\src\jswyll_packet.gcda', 'wb') as file: + file.write(b'\x61\x64\x63\x67\x72\x33\x30\x42\x37\x0D\x30\x1E\x00\x00\x00\x01\x03\x00\x00\x00\x09\x5D\xE6\x5C\x9F\xEE\xAF\xCD\x70\xC6\x36\xA0\x00\x00\xA1\x01\x0A\x00\x00\x00\x0C\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00') + +with open(r'E:\Code\test\rtt-gcov\build\applications\src\jswyll_packet.gcda', 'wb') as file: + file.write(b'\x61\x64\x63\x67\x72\x33\x30\x42\x37\x0D\x30\x1E\x00\x00\x00\x01\x03\x00\x00\x00\x09\x5D\xE6\x5C\x9F\xEE\xAF\xCD\x70\xC6\x36\xA0\x00\x00\xA1\x01\x0A\x00\x00\x00\x0C\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00') diff --git a/figures/jswyll_test_packet_lcov.png b/figures/jswyll_test_packet_lcov.png new file mode 100644 index 0000000000000000000000000000000000000000..c1cedc576f0b5a55397d91f3f7330a4001bce680 GIT binary patch literal 64474 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

Nq*-Clil-Mcf2@hOBWk@f(&RPkbo`dV-0LweQ# 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 literal 0 HcmV?d00001 diff --git a/makefile.targets b/makefile.targets index a00129b..02f80c8 100644 --- a/makefile.targets +++ b/makefile.targets @@ -1,4 +1,7 @@ clean2: -$(RM) $(CC_DEPS)$(C++_DEPS)$(C_UPPER_DEPS)$(CXX_DEPS)$(SECONDARY_FLASH)$(SECONDARY_SIZE)$(ASM_DEPS)$(S_UPPER_DEPS)$(C_DEPS)$(CPP_DEPS) -$(RM) $(OBJS) *.elf - -@echo ' ' \ No newline at end of file + -@echo ' ' + + +*.elf: $(wildcard ../link.lds) diff --git a/rtconfig.py b/rtconfig.py index 1d9e327..0fb4c1b 100644 --- a/rtconfig.py +++ b/rtconfig.py @@ -59,11 +59,11 @@ if PLATFORM == 'gcc': OBJCPY = PREFIX + 'objcopy' STRIP = PREFIX + 'strip' - DEVICE = ' -march=armv7-a -marm -msoft-float -fprofile-arcs -ftest-coverage' + DEVICE = ' -march=armv7-a -marm -msoft-float' CFLAGS = DEVICE + ' -Wall -Werror' AFLAGS = ' -c' + DEVICE + ' -x assembler-with-cpp -D__ASSEMBLY__ -I.' LINK_SCRIPT = 'link.lds' - LFLAGS = DEVICE + ' -nostartfiles -Wl,--gc-sections,-Map=rtthread.map,-cref,-u,system_vectors' +\ + LFLAGS = DEVICE + ' -nostartfiles -Wl,--gc-sections,-Map=rtthread.map,-cref,-u,system_vectors --coverage' +\ ' -T %s' % LINK_SCRIPT CPATH = '' -- Gitee