C C++最全C语言断言assert和单元测试的关系_单元测试assert和(1)，2024年最新优秀C C++程序员必知必会的网络基础

最新推荐文章于 2024-06-26 11:25:37 发布
最新推荐文章于 2024-06-26 11:25:37 发布
阅读量829 收藏 28
点赞数 27
分类专栏： 程序员 文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84978595/article/details/138870315
版权

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

TEST_ASSERT_GREATER_THAN(threshold, actual)
断言实际值大于阈值。这也出现在大小特定的变体。

TEST_ASSERT_LESS_THAN(threshold, actual)
断言实际值小于阈值。这也出现在大小特定的变体。

C单元测试Unity+CMock

阅读: 1474

ThrowTheSwitch-Unity

GirHub地址：https://github.com/ThrowTheSwitch/Unity

ThrowTheSwitch-CMock

GirHub地址：https://github.com/ThrowTheSwitch/CMock

Basic Validity Tests

TEST_ASSERT_TRUE(condition)
计算任何处于条件下的代码，如果计算结果为false，则失败

TEST_ASSERT_FALSE(condition)
对任何处于条件下的代码求值，如果求值为true，则失败

TEST_ASSERT(condition)
另一种调用TEST_ASSERT_TRUE的方法

TEST_ASSERT_UNLESS(condition)
另一种调用TEST_ASSERT_FALSE的方法

TEST_FAIL()
TEST_FAIL_MESSAGE(message)
这个测试被自动标记为失败。
消息输出说明了原因。

Numerical Assertions: Integers

TEST_ASSERT_EQUAL_INT(expected, actual)
TEST_ASSERT_EQUAL_INT8(expected, actual)
TEST_ASSERT_EQUAL_INT16(expected, actual)
TEST_ASSERT_EQUAL_INT32(expected, actual)
TEST_ASSERT_EQUAL_INT64(expected, actual)
比较两个整数是否相等，并将错误显示为带符号的整数。强制类型转换将按您的自然整数大小执行，因此经常可以使用这种方法。当你需要指定确切的大小，如比较数组时，你可以使用一个特定的版本:

TEST_ASSERT_EQUAL_UINT(expected, actual)
TEST_ASSERT_EQUAL_UINT8(expected, actual)
TEST_ASSERT_EQUAL_UINT16(expected, actual)
TEST_ASSERT_EQUAL_UINT32(expected, actual)
TEST_ASSERT_EQUAL_UINT64(expected, actual)
比较两个整数是否相等，并将错误显示为无符号整数。像INT一样，也有不同大小的变体。

TEST_ASSERT_EQUAL_HEX(expected, actual)
TEST_ASSERT_EQUAL_HEX8(expected, actual)
TEST_ASSERT_EQUAL_HEX16(expected, actual)
TEST_ASSERT_EQUAL_HEX32(expected, actual)
TEST_ASSERT_EQUAL_HEX64(expected, actual)
比较两个整数是否相等，并将错误显示为十六进制。与其他整数比较一样，您可以指定大小…在这里，大小也会影响显示了多少个小块(例如，HEX16将显示4个小块)。

TEST_ASSERT_EQUAL(expected, actual)
另一种调用TEST_ASSERT_EQUAL_INT的方法

TEST_ASSERT_INT_WITHIN(delta, expected, actual)
断言实际值在期望值的正负之间。这也出现在大小特定的变体。

TEST_ASSERT_GREATER_THAN(threshold, actual)
断言实际值大于阈值。这也出现在大小特定的变体。

TEST_ASSERT_LESS_THAN(threshold, actual)
断言实际值小于阈值。这也出现在大小特定的变体。

Arrays

_ARRAY

您可以将_ARRAY附加到任何这些宏中，以对该类型进行数组比较。在这里，您需要更关心被检查的值的实际大小。您还将指定一个附加参数，即要比较的元素数量。例如:

TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, elements)

_EACH_EQUAL

另一个数组比较选项是检查数组中的每个元素是否等于单个期望值。您可以通过指定EACH_EQUAL宏来实现这一点。例如:

TEST_ASSERT_EACH_EQUAL_INT32(expected, actual, elements)

Numerical Assertions: Bitwise

TEST_ASSERT_BITS(mask, expected, actual)
使用一个整数掩码来指定两个其他整数之间应该比较哪些位。比较掩码中的高比特，忽略低比特。

TEST_ASSERT_BITS_HIGH(mask, actual)
使用整数掩码指定应该检查哪些位以确定它们是否都设置为高。比较掩码中的高比特，忽略低比特。

TEST_ASSERT_BITS_LOW(mask, actual)
使用一个整数掩码来指定应该检查哪些位以确定它们是否都设置得很低。比较掩码中的高比特，忽略低比特。

TEST_ASSERT_BIT_HIGH(bit, actual)
测试单个位，并验证它是否高。为32位整数指定0-31位。

TEST_ASSERT_BIT_LOW(bit, actual)
测试一个比特并确认它是低的。为32位整数指定0-31位。

Numerical Assertions: Floats

TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual)
断言实际值在期望值的正负之间。

TEST_ASSERT_EQUAL_FLOAT(expected, actual)
TEST_ASSERT_EQUAL_DOUBLE(expected, actual)
断言两个浮点值在期望值的小%增量内“相等”。

String Assertions

TEST_ASSERT_EQUAL_STRING(expected, actual)
比较两个空终止字符串。如果任何字符不同或长度不同，则失败。

TEST_ASSERT_EQUAL_STRING_LEN(expected, actual, len)
比较两个字符串。如果任何字符不同，则在len字符后停止比较。

TEST_ASSERT_EQUAL_STRING_MESSAGE(expected, actual, message)
比较两个空终止字符串。如果任何字符不同或长度不同，则失败。失败时输出自定义消息。

TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE(expected, actual, len, message)
比较两个字符串。如果任何字符不同，则在len字符后停止比较。失败时输出自定义消息。

Pointer Assertions

大多数指针操作都可以通过使用上面的整数比较来执行。但是，为了清楚起见，添加了一些特殊的情况。

TEST_ASSERT_NULL(pointer)
如果指针不等于NULL，则失败

TEST_ASSERT_NOT_NULL(pointer)
如果指针等于NULL，则失败

Memory Assertions

TEST_ASSERT_EQUAL_MEMORY(expected, actual, len)
比较两块内存。对于不能强制执行标准类型的类型来说，这是一个很好的通用断言……但是由于这是内存比较，所以必须注意数据类型的打包。

可以看到在unity中，存在着各种各样的断言。

除了C语言库中存在的真假断言，还有整数断言，数组断言，位断言，浮点数断言，字符串断言，指针断言，

在单元测试框架中，我们在一个测试函数中，可以建立对某个函数的完整测试，

void testNullInputToInit\_should\_fail(void) {
    uint8_t ret;
    lwrb_t buff = { 0 };
    uint8_t buff_data[1];

    ret = lwrb\_init(NULL, buff_data, sizeof(buff_data));
    TEST\_ASSERT\_EQUAL(0, ret);

    ret = lwrb\_init(&buff, NULL, sizeof(buff_data));
    TEST\_ASSERT\_EQUAL(0, ret);

    ret = lwrb\_init(&buff, buff_data, 0);
    TEST\_ASSERT\_EQUAL(0, ret);

    ret = lwrb\_is\_ready(&buff);
    TEST\_ASSERT\_EQUAL(0, ret);
}

在这个测试函数中，我们主要测试的是环形缓冲的lwrb_init函数，我们对其进行了不同的输入测试，并且使用断言来判断实际输出和我们期望的输出是否一致。

在我之前的博客【C语言开源库】在CLion上使用一个轻量的适合嵌入式系统的环形缓冲库ring buffer 和C语言Unity单元测试框架中，我们测试了环形缓冲开源库的一些函数，运行结果和预期一致时，运行显示如下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rlVueSAk-1628230382669)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210805180906253.png)]

当运行结果和预期不一致时，运行显示如下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cB2Xl1Ii-1628230382671)(https://raw.githubusercontent.com/xkyvvv/blogpic/main/pic1/image-20210805181024986.png)]

可以看到，单元测试框架就是一个断言集合，下面我们通过源码来看一下不同断言的具体实现。

/\* ==========================================
 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 <stdint.h>
 \* - define UNITY\_EXCLUDE\_LIMITS\_H to stop attempting to look in <limits.h>
 \* - 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)


![img](https://img-blog.csdnimg.cn/img_convert/a8c4c796136d6d627d6147f09c4c11c6.png)
![img](https://img-blog.csdnimg.cn/img_convert/59d971602ac919b715c297fca5d154e3.png)

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

ACH\_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)


[外链图片转存中...(img-qRdJh9wN-1715692096921)]
[外链图片转存中...(img-gg1ArF5u-1715692096921)]

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化的资料的朋友，可以添加戳这里获取](https://bbs.csdn.net/topics/618668825)**


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
2401_84978595
关注
  • 27
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言32以及C++63个关键字及其含义 (2).pdf
02-27
C语言和C++是两种广泛使用的编程语言，它们的关键字是语言的核心组成部分，用来定义变量、控制流程、声明数据类型等。以下是对C语言32个关键字和C++63个关键字的详细解释： 1. **auto**：C++中的`auto`用于自动推断...
C和C++头文件，函数和关键字的使用和比较
12-11
程序员应根据实际问题选择合适的头文件和函数，同时注意C和C++在关键字和语法上的差异，以便更好地利用这两种语言的优势。在编写代码时，正确地使用这些工具可以提高代码的可读性、可维护性和性能。
c和c++ 头文件大全
06-20
在C和C++编程语言中，头文件是包含预定义函数、变量、常量和类型定义的文件，它们提供了一种方便的方式来导入和使用库功能。...同时，了解并熟练掌握这些头文件中的函数和类是成为一名高效C/C++程序员的必要条件。
c/c++ 学习总结 初学者必备
09-16
答:断言assert是仅在debug版本起作用的宏,用于检查“不应该“发生的情况。程序员可以把assert看成一个在任何系统状态下都可以安全使用的无害测试手段。 9、用预处理指令#define 声明一个常数,用以表明1年中有多少秒...
c/C++面试题大全--96页
04-14
本文的写作目的并不在于提供C/C++程序员求职面试指导，而旨在从技术上分析面试题的内涵。文中的大多数面试题来自各大论坛，部分试题解答也参考了网友的意见。 　许多面试题看似简单，却需要深厚的基本功才能给出...
C语言第17篇：预处理详解
2302_78977491的博客
06-22 808
C语言设置了一些预定义符号，可以直接使用。预定义符号也是在预处理期间处理的。__FILE__ //进行编译的源文件__LINE__ //文件当前的行号__DATE__ //文件被编译的日期__TIME__ //文件被编译的时间__STDC__ //如果编译器遵循ANSI C，其值为1, 否则未定义int main()printf("进行编译的源文件:%s\n", __FILE__);printf("当前文件的行号:%d\n", __LINE__);
基于CPWM与DPWM综合调制的光伏逆变器
weixin_43015338的博客
06-22 930
仿真及实验参数为：额定电网相电压 ea，b，c= 220 V，额定电网电流ia，b，c = 30A，电网基频fs = 50 Hz， 开关频率 fw = 10 kHz，直流母线电压 Udc= 600 V， 直流母线电容C = 2 200 μF，滤波电感L = 5 mH。图1中，ea，eb，ec为三相电网电压，ia，ib，ic为电 感电流；通过零序分量注入，SVM增益为 2/ 3 ，因此调制 比 m 在［0，1］之间取值时，参考电压 u* a_ref , b_ref , c_ref 的调制度最大达到1.15。
C语言——函数
最新发布
weixin_45725380的博客
06-26 595
存储类型 数据类型 函数名（数据类型 形参1，数据类型 形参2，……）；存储类型数据类型函数名（数据类型 形参1，数据类型 形参2，……）函数体；函数名：是一个标识符，要符合标识符命名规则。数据类型：是整个函数的返回值类型，如果无返回值应该写void。形式参数说明：是逗号分隔开的多个变量的说明形式，通常简称为形参。形参就是函数声明和定义时函数名后面括号中的变量，因为形式参数只有在函数调用时才有实际的数值（即分配内存空间）。大括号对{语句序列}：称为函数体，语句序列是大于等于零个语句组成的。
【代码】c++几个常用的函数
一个小学学霸的博客
06-25 1137
c++函数
LeetCode 算法：二叉树的层序遍历 c++
小金牛来了
06-25 709
LeetCode 算法：二叉树的层序遍历 c++
什么野指针（c++）
qq_35374791的博客
06-24 7756
野指针（Wild Pointer）是指向不确定位置或者非法地址的指针。当一个指针指向的内存被释放后，如果没有将其设置为NULL，那么这个指针就变成了野指针。使用野指针会导致未定义行为，可能引发程序崩溃或数据损坏。
Android C++系列：string最佳实践一
轻口味的专栏
06-25 381
在Java中操作字符串比较简单，这里简单介绍下Java字符串操作相关接口。字符串拼接直接用号既可，字符串比较实用equel方法，同时还提供了StringBuilder和StringBuffer可变的字符串。。StringBuffer是线程安全，StringBuilder线程不安全。因为 StringBuffer 的所有公开方法都是 synchronized 修饰的，而 StringBuilder 并没有 synchronized修饰；
【华为OD机试】 硬件产品销售方案（C++/Java/Python）
dvlinker的技术专栏
06-24 44
【华为OD机试】 硬件产品销售方案（C++/Java/Python）
openCV3.0 C++ 学习笔记补充(自用 代码+注释)---持续更新 二(51-)
weixin_47059239的博客
06-26 265
环境：OpenCV3.2.0 + VS2015。
Android C++系列：C++最佳实践5const
轻口味的专栏
06-24 1314
本文介绍了const与宏定义常量的区别，以及const修饰变量的注意事项，绑定常量的引用、指向常量的指针和常量指针。并介绍了顶层const与底层const的区别。
QT学习积累——在C++中，for循环中使用`&`与不使用`&`的区别和联系
Arya的博客，专注后端领域
06-25 956
QT学习积累——在C++中，for循环中使用`&`与不使用`&`的区别和联系
CJson源码解析之cJSON_CreateObject函数
m0_62599305的博客
06-25 66
在现代编程中，JSON已经成为了一种非常流行的数据交换格式。它的简洁性和易读性使得开发者可以轻松地在不同的系统和应用之间共享和理解数据。CJson是一个轻量级的JSON解析库，它提供了一种简单和高效的方式来解析和生成JSON数据。本文将深入探讨CJson的源码，特别是它的核心函数cJSON_CreateObject。通过深入研究CJson的源码和cJSON_CreateObject函数，我们可以更好地理解如何创建JSON对象，以及如何有效地解析和生成JSON数据。
部门人力分配（85%用例）C卷(Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
06-25 95
部门在进行需求开发时需要进行人力安排。当前部门需要完成N个需求，需求用requirements0表示，requirements[i]表示第i个需求的工作量大小，单位:人月。这部分需求需要在M个月内完成开发，进行人力安排后每个月的人力是固定的。目前要求每个月最多有2个需求开发，并且每个月需要完成的需求不能超过部门人力。请帮部门评估在满足需求开发进度的情况下每个月需要的最小人力是多少?
c++单元测试断言用法
04-04
3. CPPUNIT_ASSERT(expression)：这是C++单元测试框架CppUnit中的断言宏，如果表达式为false，则触发断言失败，并输出错误信息。 4. BOOST_ASSERT(expression)：这是C++单元测试框架Boost.Test中的断言宏，如果...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值