espressif/Unity
1
0
Fork 0
mirror of https://github.com/ThrowTheSwitch/Unity.git synced 2025-06-18 21:08:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

- added 64 bit support

Browse Source 
- organized targets into a subdirectory
- cleaned up testing so floats and 64-bit ints are only tested if enabled


git-svn-id: http://unity.svn.sourceforge.net/svnroot/unity/trunk@85 e7d17a6e-8845-0410-bbbc-c8efb4fdad7e
This commit is contained in:
mvandervoord
2010-07-28 01:06:21 +00:00
parent 095af497b0
commit a9ccd245b0
13 changed files with 590 additions and 260 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
docs/Unity Summary.odt
View File

Binary file not shown.

BIN
docs/Unity Summary.pdf
View File

Binary file not shown.

1
rakefile_helper.rb
View File

@ -27,6 +27,7 @@ module RakefileHelpers
def configure_toolchain(config_file=DEFAULT_CONFIG_FILE) def configure_toolchain(config_file=DEFAULT_CONFIG_FILE)
config_file += '.yml' unless config_file =~ /\.yml$/ config_file += '.yml' unless config_file =~ /\.yml$/
config_file = "targets/#{config_file}" unless config_file =~ /[\\|\/]/
load_configuration(config_file) load_configuration(config_file)
configure_clean configure_clean
end end

158
src/unity.c
View File

@ -12,6 +12,7 @@
#define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; UNITY_OUTPUT_CHAR('\n'); longjmp(Unity.AbortFrame, 1); } #define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; UNITY_OUTPUT_CHAR('\n'); longjmp(Unity.AbortFrame, 1); }
/// return prematurely if we are already in failure or ignore state /// return prematurely if we are already in failure or ignore state
#define UNITY_SKIP_EXECUTION { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} } #define UNITY_SKIP_EXECUTION { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} }
#define UNITY_PRINT_CR_LF { UNITY_OUTPUT_CHAR('\r'); UNITY_OUTPUT_CHAR('\n'); }
struct _Unity Unity = { 0 }; struct _Unity Unity = { 0 };
@ -40,17 +41,27 @@ void UnityPrint(const char* string)
while (*pch) while (*pch)
{ {
// printable characters plus CR & LF are printed // printable characters plus CR & LF are printed
if ( ((*pch <= 126) && (*pch >= 32)) || (*pch == 13) || (*pch == 10) ) if ((*pch <= 126) && (*pch >= 32))
{ {
UNITY_OUTPUT_CHAR(*pch); 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 // unprintable characters are shown as codes
else else
{ {
UNITY_OUTPUT_CHAR('{');
UNITY_OUTPUT_CHAR('\\'); UNITY_OUTPUT_CHAR('\\');
UnityPrintNumber((_US32)*pch); UnityPrintNumberHex((_U_SINT)*pch, 2);
UNITY_OUTPUT_CHAR('}');
} }
pch++; pch++;
} }
@ -58,25 +69,29 @@ void UnityPrint(const char* string)
} }
//----------------------------------------------- //-----------------------------------------------
void UnityPrintNumberByStyle(const _US32 number, const UNITY_DISPLAY_STYLE_T style) void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style)
{ {
switch (style) if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
{ {
case UNITY_DISPLAY_STYLE_HEX8: UnityPrintNumberHex((_UU32)number, 2); break; UnityPrintNumber(number);
case UNITY_DISPLAY_STYLE_HEX16: UnityPrintNumberHex((_UU32)number, 4); break; }
case UNITY_DISPLAY_STYLE_HEX32: UnityPrintNumberHex((_UU32)number, 8); break; else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
case UNITY_DISPLAY_STYLE_UINT: UnityPrintNumberUnsigned((_UU32)number); break; {
default: UnityPrintNumber(number); break; UnityPrintNumberUnsigned((_U_UINT)number);
}
else
{
UnityPrintNumberHex((_U_UINT)number, (style & 0x000F) << 1);
} }
} }
//----------------------------------------------- //-----------------------------------------------
/// basically do an itoa using as little ram as possible /// basically do an itoa using as little ram as possible
void UnityPrintNumber(const _US32 number_to_print) void UnityPrintNumber(const _U_SINT number_to_print)
{ {
_US32 divisor = 1; _U_SINT divisor = 1;
_US32 next_divisor; _U_SINT next_divisor;
_US32 number = number_to_print; _U_SINT number = number_to_print;
if (number < 0) if (number < 0)
{ {
@ -105,10 +120,10 @@ void UnityPrintNumber(const _US32 number_to_print)
//----------------------------------------------- //-----------------------------------------------
/// basically do an itoa using as little ram as possible /// basically do an itoa using as little ram as possible
void UnityPrintNumberUnsigned(const _UU32 number) void UnityPrintNumberUnsigned(const _U_UINT number)
{ {
_UU32 divisor = 1; _U_UINT divisor = 1;
_UU32 next_divisor; _U_UINT next_divisor;
// figure out initial divisor // figure out initial divisor
while (number / divisor > 9) while (number / divisor > 9)
@ -130,9 +145,9 @@ void UnityPrintNumberUnsigned(const _UU32 number)
} }
//----------------------------------------------- //-----------------------------------------------
void UnityPrintNumberHex(const _UU32 number, const char nibbles_to_print) void UnityPrintNumberHex(const _U_UINT number, const char nibbles_to_print)
{ {
_UU32 nibble; _U_UINT nibble;
char nibbles = nibbles_to_print; char nibbles = nibbles_to_print;
UnityPrint("0x"); UnityPrint("0x");
@ -151,12 +166,12 @@ void UnityPrintNumberHex(const _UU32 number, const char nibbles_to_print)
} }
//----------------------------------------------- //-----------------------------------------------
void UnityPrintMask(const _UU32 mask, const _UU32 number) void UnityPrintMask(const _U_UINT mask, const _U_UINT number)
{ {
_UU32 bit = 0x80000000; _U_UINT bit = (_U_UINT)1 << (UNITY_INT_WIDTH - 1);
_US32 i; _US32 i;
for (i = 0; i < 32; i++) for (i = 0; i < UNITY_INT_WIDTH; i++)
{ {
if (bit & mask) if (bit & mask)
{ {
@ -215,7 +230,8 @@ void UnityConcludeTest(void)
else if (!Unity.CurrentTestFailed) else if (!Unity.CurrentTestFailed)
{ {
UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber); UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber);
UnityPrint("PASS\n"); UnityPrint("PASS");
UNITY_PRINT_CR_LF;
} }
else else
{ {
@ -299,9 +315,9 @@ int UnityCheckArraysForNull(const void* expected, const void* actual, const UNIT
// Assertion Functions // Assertion Functions
//----------------------------------------------- //-----------------------------------------------
void UnityAssertBits(const _US32 mask, void UnityAssertBits(const _U_SINT mask,
const _US32 expected, const _U_SINT expected,
const _US32 actual, const _U_SINT actual,
const char* msg, const char* msg,
const UNITY_LINE_TYPE lineNumber) const UNITY_LINE_TYPE lineNumber)
{ {
@ -320,8 +336,8 @@ void UnityAssertBits(const _US32 mask,
} }
//----------------------------------------------- //-----------------------------------------------
void UnityAssertEqualNumber(const _US32 expected, void UnityAssertEqualNumber(const _U_SINT expected,
const _US32 actual, const _U_SINT actual,
const char* msg, const char* msg,
const UNITY_LINE_TYPE lineNumber, const UNITY_LINE_TYPE lineNumber,
const UNITY_DISPLAY_STYLE_T style) const UNITY_DISPLAY_STYLE_T style)
@ -341,20 +357,16 @@ void UnityAssertEqualNumber(const _US32 expected,
} }
//----------------------------------------------- //-----------------------------------------------
void UnityAssertEqualIntArray(const int* expected, void UnityAssertEqualIntArray(const _U_SINT* expected,
const int* actual, const _U_SINT* actual,
const _UU32 num_elements, const _UU32 num_elements,
const char* msg, const char* msg,
const UNITY_LINE_TYPE lineNumber, const UNITY_LINE_TYPE lineNumber,
const UNITY_DISPLAY_STYLE_T style) const UNITY_DISPLAY_STYLE_T style)
{ {
_UU32 elements = num_elements; _UU32 elements = num_elements;
const _US32* ptr_exp32 = (_US32*)expected; const _US8* ptr_exp = (_US8*)expected;
const _US16* ptr_exp16 = (_US16*)expected; const _US8* ptr_act = (_US8*)actual;
const _US8* ptr_exp8 = (_US8*)expected;
const _US32* ptr_act32 = (_US32*)actual;
const _US16* ptr_act16 = (_US16*)actual;
const _US8* ptr_act8 = (_US8*)actual;
UNITY_SKIP_EXECUTION; UNITY_SKIP_EXECUTION;
@ -376,18 +388,20 @@ void UnityAssertEqualIntArray(const int* expected,
case UNITY_DISPLAY_STYLE_UINT8: case UNITY_DISPLAY_STYLE_UINT8:
while (elements--) while (elements--)
{ {
if (*ptr_exp8++ != *ptr_act8++) if (*ptr_exp != *ptr_act)
{ {
UnityTestResultsFailBegin(lineNumber); UnityTestResultsFailBegin(lineNumber);
UnityPrint(UnityStrElement); UnityPrint(UnityStrElement);
UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
UnityPrint(UnityStrExpected); UnityPrint(UnityStrExpected);
UnityPrintNumberByStyle(*--ptr_exp8, style); UnityPrintNumberByStyle(*ptr_exp, style);
UnityPrint(UnityStrWas); UnityPrint(UnityStrWas);
UnityPrintNumberByStyle(*--ptr_act8, style); UnityPrintNumberByStyle(*ptr_act, style);
UnityAddMsgIfSpecified(msg); UnityAddMsgIfSpecified(msg);
UNITY_FAIL_AND_BAIL; UNITY_FAIL_AND_BAIL;
} }
ptr_exp += 1;
ptr_act += 1;
} }
break; break;
case UNITY_DISPLAY_STYLE_HEX16: case UNITY_DISPLAY_STYLE_HEX16:
@ -395,35 +409,62 @@ void UnityAssertEqualIntArray(const int* expected,
case UNITY_DISPLAY_STYLE_UINT16: case UNITY_DISPLAY_STYLE_UINT16:
while (elements--) while (elements--)
{ {
if (*ptr_exp16++ != *ptr_act16++) if (*(_US16*)ptr_exp != *(_US16*)ptr_act)
{ {
UnityTestResultsFailBegin(lineNumber); UnityTestResultsFailBegin(lineNumber);
UnityPrint(UnityStrElement); UnityPrint(UnityStrElement);
UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
UnityPrint(UnityStrExpected); UnityPrint(UnityStrExpected);
UnityPrintNumberByStyle(*--ptr_exp16, style); UnityPrintNumberByStyle(*(_US16*)ptr_exp, style);
UnityPrint(UnityStrWas); UnityPrint(UnityStrWas);
UnityPrintNumberByStyle(*--ptr_act16, style); UnityPrintNumberByStyle(*(_US16*)ptr_act, style);
UnityAddMsgIfSpecified(msg); UnityAddMsgIfSpecified(msg);
UNITY_FAIL_AND_BAIL; UNITY_FAIL_AND_BAIL;
} }
ptr_exp += 2;
ptr_act += 2;
} }
break; break;
#ifdef UNITY_SUPPORT_64
case UNITY_DISPLAY_STYLE_HEX64:
case UNITY_DISPLAY_STYLE_INT64:
case UNITY_DISPLAY_STYLE_UINT64:
while (elements--)
{
if (*(_US64*)ptr_exp != *(_US64*)ptr_act)
{
UnityTestResultsFailBegin(lineNumber);
UnityPrint(UnityStrElement);
UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
UnityPrint(UnityStrExpected);
UnityPrintNumberByStyle(*(_US64*)ptr_exp, style);
UnityPrint(UnityStrWas);
UnityPrintNumberByStyle(*(_US64*)ptr_act, style);
UnityAddMsgIfSpecified(msg);
UNITY_FAIL_AND_BAIL;
}
ptr_exp += 8;
ptr_act += 8;
}
break;
#endif
default: default:
while (elements--) while (elements--)
{ {
if (*ptr_exp32++ != *ptr_act32++) if (*(_US32*)ptr_exp != *(_US32*)ptr_act)
{ {
UnityTestResultsFailBegin(lineNumber); UnityTestResultsFailBegin(lineNumber);
UnityPrint(UnityStrElement); UnityPrint(UnityStrElement);
UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
UnityPrint(UnityStrExpected); UnityPrint(UnityStrExpected);
UnityPrintNumberByStyle(*--ptr_exp32, style); UnityPrintNumberByStyle(*(_US32*)ptr_exp, style);
UnityPrint(UnityStrWas); UnityPrint(UnityStrWas);
UnityPrintNumberByStyle(*--ptr_act32, style); UnityPrintNumberByStyle(*(_US32*)ptr_act, style);
UnityAddMsgIfSpecified(msg); UnityAddMsgIfSpecified(msg);
UNITY_FAIL_AND_BAIL; UNITY_FAIL_AND_BAIL;
} }
ptr_exp += 4;
ptr_act += 4;
} }
break; break;
} }
@ -523,16 +564,16 @@ void UnityAssertFloatsWithin(const _UF delta,
#endif #endif
//----------------------------------------------- //-----------------------------------------------
void UnityAssertNumbersWithin( const _US32 delta, void UnityAssertNumbersWithin( const _U_SINT delta,
const _US32 expected, const _U_SINT expected,
const _US32 actual, const _U_SINT actual,
const char* msg, const char* msg,
const UNITY_LINE_TYPE lineNumber, const UNITY_LINE_TYPE lineNumber,
const UNITY_DISPLAY_STYLE_T style) const UNITY_DISPLAY_STYLE_T style)
{ {
UNITY_SKIP_EXECUTION; UNITY_SKIP_EXECUTION;
if (style == UNITY_DISPLAY_STYLE_INT) if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
{ {
if (actual > expected) if (actual > expected)
Unity.CurrentTestFailed = ((actual - expected) > delta); Unity.CurrentTestFailed = ((actual - expected) > delta);
@ -541,10 +582,10 @@ void UnityAssertNumbersWithin( const _US32 delta,
} }
else else
{ {
if ((_UU32)actual > (_UU32)expected) if ((_U_UINT)actual > (_U_UINT)expected)
Unity.CurrentTestFailed = ((_UU32)(actual - expected) > (_UU32)delta); Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > (_U_UINT)delta);
else else
Unity.CurrentTestFailed = ((_UU32)(expected - actual) > (_UU32)delta); Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > (_U_UINT)delta);
} }
if (Unity.CurrentTestFailed) if (Unity.CurrentTestFailed)
@ -757,19 +798,22 @@ void UnityBegin(void)
//----------------------------------------------- //-----------------------------------------------
void UnityEnd(void) void UnityEnd(void)
{ {
UnityPrint("-----------------------\n"); UnityPrint("-----------------------");
UNITY_PRINT_CR_LF;
UnityPrintNumber(Unity.NumberOfTests); UnityPrintNumber(Unity.NumberOfTests);
UnityPrint(" Tests "); UnityPrint(" Tests ");
UnityPrintNumber(Unity.TestFailures); UnityPrintNumber(Unity.TestFailures);
UnityPrint(" Failures "); UnityPrint(" Failures ");
UnityPrintNumber(Unity.TestIgnores); UnityPrintNumber(Unity.TestIgnores);
UnityPrint(" Ignored\n"); UnityPrint(" Ignored");
UNITY_PRINT_CR_LF;
if (Unity.TestFailures == 0U) if (Unity.TestFailures == 0U)
{ {
UnityPrint("OK\n"); UnityPrint("OK");
} }
else else
{ {
UnityPrint("FAIL\n"); UnityPrint("FAIL");
} }
UNITY_PRINT_CR_LF;
} }

28
src/unity.h
View File

@ -76,16 +76,19 @@
#define TEST_ASSERT_EQUAL_INT8(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT8((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_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_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(expected, actual) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, NULL) #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") #define TEST_ASSERT_NOT_EQUAL(expected, actual) UNITY_TEST_ASSERT(((expected) != (actual)), __LINE__, " Expected Not-Equal")
#define TEST_ASSERT_EQUAL_UINT(expected, actual) UNITY_TEST_ASSERT_EQUAL_UINT( (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_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_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_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_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_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_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_HEX32(expected, actual) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, NULL)
#define TEST_ASSERT_EQUAL_HEX(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_BITS(mask, expected, actual) UNITY_TEST_ASSERT_BITS((mask), (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), (_UU32)(-1), (actual), __LINE__, NULL) #define TEST_ASSERT_BITS_HIGH(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(-1), (actual), __LINE__, NULL)
#define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, NULL) #define TEST_ASSERT_BITS_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, NULL)
@ -95,12 +98,14 @@
//Integer Ranges (of all sizes) //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_INT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_INT_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_UINT_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_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_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_HEX32_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX32_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_HEX64_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, __LINE__, NULL)
//Structs and Strings //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(expected, actual) UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, __LINE__, NULL)
#define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, __LINE__, NULL) #define TEST_ASSERT_EQUAL_MEMORY(expected, actual, len) UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, __LINE__, NULL)
@ -109,14 +114,17 @@
#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_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_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_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_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_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_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_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_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_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_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_HEX32_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX32_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_HEX64_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_HEX64_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_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_MEMORY_ARRAY(expected, actual, len, num_elements) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, __LINE__, NULL)
@ -142,16 +150,19 @@
#define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT8((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_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_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_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, message) #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) #define TEST_ASSERT_NOT_EQUAL_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT(((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_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_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_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_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_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_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_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_HEX32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((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_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_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), (_UU32)(-1), (actual), __LINE__, message) #define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(-1), (actual), __LINE__, message)
#define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, message) #define TEST_ASSERT_BITS_LOW_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, message)
@ -161,12 +172,14 @@
//Integer Ranges (of all sizes) //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_INT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT_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_UINT_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_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_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_HEX32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_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_HEX64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, __LINE__, message)
//Structs and Strings //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_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_STRING(expected, actual, __LINE__, message)
#define TEST_ASSERT_EQUAL_MEMORY_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_MEMORY(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)
@ -175,14 +188,17 @@
#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_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_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_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_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_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_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_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_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_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_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_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_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_HEX64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX64_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_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_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, __LINE__, message)

187
src/unity_internals.h
View File

@ -18,6 +18,10 @@
#define UNITY_INT_WIDTH (32) #define UNITY_INT_WIDTH (32)
#endif #endif
#ifndef UNITY_LONG_WIDTH
#define UNITY_LONG_WIDTH (32)
#endif
#if (UNITY_INT_WIDTH == 32) #if (UNITY_INT_WIDTH == 32)
typedef unsigned char _UU8; typedef unsigned char _UU8;
typedef unsigned short _UU16; typedef unsigned short _UU16;
@ -33,7 +37,55 @@
typedef signed int _US16; typedef signed int _US16;
typedef signed long _US32; typedef signed long _US32;
#else #else
#error Invalid UNITY_INT_WIDTH specified! (32 or 16 only are currently supported) #error Invalid UNITY_INT_WIDTH specified! (16 or 32 are supported)
#endif
//-------------------------------------------------------
// 64-bit Support
//-------------------------------------------------------
#ifndef UNITY_SUPPORT_64
//No 64-bit Support
typedef _UU32 _U_UINT;
typedef _US32 _U_SINT;
#else
//64-bit Support
#if (UNITY_LONG_WIDTH == 32)
typedef unsigned long long _UU64;
typedef signed long long _US64;
#elif (UNITY_LONG_WIDTH == 64)
typedef unsigned long _UU64;
typedef signed long _US64;
#else
#error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported)
#endif
typedef _UU64 _U_UINT;
typedef _US64 _U_SINT;
#endif
//-------------------------------------------------------
// Pointer Support
//-------------------------------------------------------
#ifndef UNITY_POINTER_WIDTH
#define UNITY_POINTER_WIDTH (32)
#endif
#if (UNITY_POINTER_WIDTH == 32)
typedef _UU32 _UP;
#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32
#elif (UNITY_POINTER_WIDTH == 64)
typedef _UU64 _UP;
#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX64
#elif (UNITY_POINTER_WIDTH == 16)
typedef _UU16 _UP;
#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX16
#else
#error Invalid UNITY_POINTER_WIDTH specified! (16, 32 or 64 are supported)
#endif #endif
//------------------------------------------------------- //-------------------------------------------------------
@ -86,19 +138,33 @@ typedef UNITY_FLOAT_TYPE _UF;
typedef void (*UnityTestFunction)(void); 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_AUTO (0x80)
typedef enum typedef enum
{ {
UNITY_DISPLAY_STYLE_INT, UNITY_DISPLAY_STYLE_INT = 4 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
UNITY_DISPLAY_STYLE_INT8, UNITY_DISPLAY_STYLE_INT8 = 1 + UNITY_DISPLAY_RANGE_INT,
UNITY_DISPLAY_STYLE_INT16, UNITY_DISPLAY_STYLE_INT16 = 2 + UNITY_DISPLAY_RANGE_INT,
UNITY_DISPLAY_STYLE_INT32, UNITY_DISPLAY_STYLE_INT32 = 4 + UNITY_DISPLAY_RANGE_INT,
UNITY_DISPLAY_STYLE_UINT, #ifdef UNITY_SUPPORT_64
UNITY_DISPLAY_STYLE_UINT8, UNITY_DISPLAY_STYLE_INT64 = 8 + UNITY_DISPLAY_RANGE_INT,
UNITY_DISPLAY_STYLE_UINT16, #endif
UNITY_DISPLAY_STYLE_UINT32, UNITY_DISPLAY_STYLE_UINT = 4 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
UNITY_DISPLAY_STYLE_HEX8, UNITY_DISPLAY_STYLE_UINT8 = 1 + UNITY_DISPLAY_RANGE_UINT,
UNITY_DISPLAY_STYLE_HEX16, UNITY_DISPLAY_STYLE_UINT16 = 2 + UNITY_DISPLAY_RANGE_UINT,
UNITY_DISPLAY_STYLE_HEX32 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_T; } UNITY_DISPLAY_STYLE_T;
struct _Unity struct _Unity
@ -129,11 +195,11 @@ void UnityConcludeTest(void);
//------------------------------------------------------- //-------------------------------------------------------
void UnityPrint(const char* string); void UnityPrint(const char* string);
void UnityPrintMask(const _UU32 mask, const _UU32 number); void UnityPrintMask(const _U_UINT mask, const _U_UINT number);
void UnityPrintNumberByStyle(const _US32 number, const UNITY_DISPLAY_STYLE_T style); void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style);
void UnityPrintNumber(const _US32 number); void UnityPrintNumber(const _U_SINT number);
void UnityPrintNumberUnsigned(const _UU32 number); void UnityPrintNumberUnsigned(const _U_UINT number);
void UnityPrintNumberHex(const _UU32 number, const char nibbles); void UnityPrintNumberHex(const _U_UINT number, const char nibbles);
#ifdef UNITY_FLOAT_VERBOSE #ifdef UNITY_FLOAT_VERBOSE
void UnityPrintFloat(const _UF number); void UnityPrintFloat(const _UF number);
@ -147,22 +213,22 @@ void UnityPrintFloat(const _UF number);
// convention and will pull in file and line information // convention and will pull in file and line information
// for you. // for you.
void UnityAssertEqualNumber(const _US32 expected, void UnityAssertEqualNumber(const _U_SINT expected,
const _US32 actual, const _U_SINT actual,
const char* msg, const char* msg,
const UNITY_LINE_TYPE lineNumber, const UNITY_LINE_TYPE lineNumber,
const UNITY_DISPLAY_STYLE_T style); const UNITY_DISPLAY_STYLE_T style);
void UnityAssertEqualIntArray(const int* expected, void UnityAssertEqualIntArray(const _U_SINT* expected,
const int* actual, const _U_SINT* actual,
const _UU32 num_elements, const _UU32 num_elements,
const char* msg, const char* msg,
const UNITY_LINE_TYPE lineNumber, const UNITY_LINE_TYPE lineNumber,
const UNITY_DISPLAY_STYLE_T style); const UNITY_DISPLAY_STYLE_T style);
void UnityAssertBits(const _US32 mask, void UnityAssertBits(const _U_SINT mask,
const _US32 expected, const _U_SINT expected,
const _US32 actual, const _U_SINT actual,
const char* msg, const char* msg,
const UNITY_LINE_TYPE lineNumber); const UNITY_LINE_TYPE lineNumber);
@ -184,9 +250,9 @@ void UnityAssertEqualMemory( const void* expected,
const char* msg, const char* msg,
const UNITY_LINE_TYPE lineNumber); const UNITY_LINE_TYPE lineNumber);
void UnityAssertNumbersWithin(const _US32 delta, void UnityAssertNumbersWithin(const _U_SINT delta,
const _US32 expected, const _U_SINT expected,
const _US32 actual, const _U_SINT actual,
const char* msg, const char* msg,
const UNITY_LINE_TYPE lineNumber, const UNITY_LINE_TYPE lineNumber,
const UNITY_DISPLAY_STYLE_T style); const UNITY_DISPLAY_STYLE_T style);
@ -224,42 +290,53 @@ void UnityAssertEqualFloatArray(const _UF* expected,
#define UNITY_TEST_ASSERT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) == NULL), (UNITY_LINE_TYPE)line, message) #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_NOT_NULL(pointer, line, message) UNITY_TEST_ASSERT(((pointer) != NULL), (UNITY_LINE_TYPE)line, message)
#define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT) #define UNITY_TEST_ASSERT_EQUAL_INT(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
#define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT) #define UNITY_TEST_ASSERT_EQUAL_INT8(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
#define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT) #define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
#define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT) #define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
#define UNITY_TEST_ASSERT_EQUAL_UINT(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT) #define UNITY_TEST_ASSERT_EQUAL_UINT(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
#define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT) #define UNITY_TEST_ASSERT_EQUAL_UINT8(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT) #define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT) #define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8) #define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8)
#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16) #define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16)
#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualNumber((_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32) #define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32)
#define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message) UnityAssertBits((_US32)(mask), (_US32)(expected), (_US32)(actual), (message), (UNITY_LINE_TYPE)line) #define UNITY_TEST_ASSERT_BITS(mask, expected, actual, line, message) UnityAssertBits((_U_SINT)(mask), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line)
#define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_US32)(delta), (_US32)(expected), (_US32)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT) #define UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_US32)(delta), (_US32)(expected), (_US32)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT) #define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
#define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_US32)(delta), (_US32)(expected), (_US32)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8) #define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8)
#define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_US32)(delta), (_US32)(expected), (_US32)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16) #define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16)
#define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_US32)(delta), (_US32)(expected), (_US32)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32) #define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32)
#define UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), NULL, (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX64)
#define UNITY_TEST_ASSERT_EQUAL_PTR(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_UP)(expected), (_U_SINT)(_UP)(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(expected, actual, line, message) UnityAssertEqualString((const char*)(expected), (const char*)(actual), (message), (UNITY_LINE_TYPE)line)
#define UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, line, message) UnityAssertEqualMemory((void*)(expected), (void*)(actual), (_UU32)(len), 1, (message), (UNITY_LINE_TYPE)line) #define UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, line, message) UnityAssertEqualMemory((void*)(expected), (void*)(actual), (_UU32)(len), 1, (message), (UNITY_LINE_TYPE)line)
#define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT) #define UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
#define UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT8) #define UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT8)
#define UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT16) #define UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT16)
#define UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT32) #define UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT32)
#define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT) #define UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
#define UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT8) #define UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT8)
#define UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT16) #define UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT16)
#define UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT32) #define UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT32)
#define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8) #define UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8)
#define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16) #define UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16)
#define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _US32*)(expected), (const _US32*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32) #define UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32)
#define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((const char**)(expected), (const char**)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line) #define UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualStringArray((const char**)(expected), (const char**)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line)
#define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((void*)(expected), (void*)(actual), (_UU32)(len), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line) #define UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, line, message) UnityAssertEqualMemory((void*)(expected), (void*)(actual), (_UU32)(len), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line)
#ifdef UNITY_SUPPORT_64
#define UNITY_TEST_ASSERT_EQUAL_INT64(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT64)
#define UNITY_TEST_ASSERT_EQUAL_UINT64(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT64)
#define UNITY_TEST_ASSERT_EQUAL_HEX64(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX64)
#define UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT64)
#define UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT64)
#define UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX64)
#endif
#ifdef UNITY_EXCLUDE_FLOAT #ifdef UNITY_EXCLUDE_FLOAT
#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled") #define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled")
#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled") #define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled")

1
gcc.yml → targets/gcc.yml
View File

@ -16,6 +16,7 @@ compiler:
defines: defines:
prefix: '-D' prefix: '-D'
items: items:
- UNITY_SUPPORT_64
object_files: object_files:
prefix: '-o' prefix: '-o'
extension: '.o' extension: '.o'

38
targets/gcc_64.yml Normal file
View File

@ -0,0 +1,38 @@
compiler:
path: gcc
source_path: 'src/'
unit_tests_path: &unit_tests_path 'test/'
build_path: &build_path 'build/'
options:
- '-c'
- '-Wall'
- '-std=c99'
- '-pedantic'
includes:
prefix: '-I'
items:
- 'src/'
- *unit_tests_path
defines:
prefix: '-D'
items:
- UNITY_SUPPORT_64
- 'UNITY_POINTER_WIDTH=64'
object_files:
prefix: '-o'
extension: '.o'
destination: *build_path
linker:
path: gcc
options:
- -lm
includes:
prefix: '-I'
object_files:
path: *build_path
extension: '.o'
bin_files:
prefix: '-o'
extension: '.exe'
destination: *build_path
colour: true

1
iar_arm_v4.yml → targets/iar_arm_v4.yml
View File

@ -36,6 +36,7 @@ compiler:
defines: defines:
prefix: '-D' prefix: '-D'
items: items:
- UNITY_SUPPORT_64
object_files: object_files:
prefix: '-o' prefix: '-o'
extension: '.r79' extension: '.r79'

3
iar_arm_v5.yml → targets/iar_arm_v5.yml
View File

@ -1,4 +1,4 @@
tools_root: &tools_root 'C:\Program Files\IAR Systems\Embedded Workbench 5.0 Kickstart\' tools_root: &tools_root 'C:\Program Files\IAR Systems\Embedded Workbench 5.3\'
compiler: compiler:
path: [*tools_root, 'arm\bin\iccarm.exe'] path: [*tools_root, 'arm\bin\iccarm.exe']
source_path: 'src\' source_path: 'src\'
@ -36,6 +36,7 @@ compiler:
defines: defines:
prefix: '-D' prefix: '-D'
items: items:
- UNITY_SUPPORT_64
object_files: object_files:
prefix: '-o' prefix: '-o'
extension: '.r79' extension: '.r79'

1
iar_cortexm3_v5.yml → targets/iar_cortexm3_v5.yml
View File

@ -39,6 +39,7 @@ compiler:
prefix: '-D' prefix: '-D'
items: items:
- 'IAR' - 'IAR'
- 'UNITY_SUPPORT_64'
object_files: object_files:
prefix: '-o' prefix: '-o'
extension: '.r79' extension: '.r79'

6
iar_msp430.yml → targets/iar_msp430.yml
View File

@ -20,9 +20,6 @@ compiler:
- --no_code_motion - --no_code_motion
- --no_tbaa - --no_tbaa
- --debug - --debug
- -D__MSP430F149__
- -DINT_WIDTH=16
- -DUNITY_FLOAT_SUPPORT_DISABLED
- -e - -e
- -Ol - -Ol
- --multiplier=16 - --multiplier=16
@ -41,6 +38,9 @@ compiler:
defines: defines:
prefix: '-D' prefix: '-D'
items: items:
- '__MSP430F149__'
- 'INT_WIDTH=16'
- 'UNITY_EXCLUDE_FLOAT'
object_files: object_files:
prefix: '-o' prefix: '-o'
extension: '.r43' extension: '.r43'

424
test/testunity.c
View File

@ -15,7 +15,9 @@
} \ } \
Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1; \ Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1; \
if (Unity.CurrentTestFailed == 1) { \ if (Unity.CurrentTestFailed == 1) { \
UnityPrint("[[[[ Previous Test Should Have Failed But Did Not ]]]]\n"); \ SetToOneMeanWeAlreadyCheckedThisGuy = 1; \
UnityPrint("[[[[ Previous Test Should Have Failed But Did Not ]]]]"); \
UNITY_OUTPUT_CHAR('\n'); \
} }
#define VERIFY_IGNORES_END \ #define VERIFY_IGNORES_END \
@ -23,20 +25,29 @@
Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1; \ Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1; \
Unity.CurrentTestIgnored = 0; \ Unity.CurrentTestIgnored = 0; \
if (Unity.CurrentTestFailed == 1) { \ if (Unity.CurrentTestFailed == 1) { \
UnityPrint("[[[[ Previous Test Should Have Ignored But Did Not ]]]]\n"); \ SetToOneMeanWeAlreadyCheckedThisGuy = 1; \
UnityPrint("[[[[ Previous Test Should Have Ignored But Did Not ]]]]"); \
UNITY_OUTPUT_CHAR('\n'); \
} }
int SetToOneToFailInTearDown; int SetToOneToFailInTearDown;
int SetToOneMeanWeAlreadyCheckedThisGuy;
void setUp(void) void setUp(void)
{ {
SetToOneToFailInTearDown = 0; SetToOneToFailInTearDown = 0;
SetToOneMeanWeAlreadyCheckedThisGuy = 0;
} }
void tearDown(void) void tearDown(void)
{ {
if (SetToOneToFailInTearDown == 1) if (SetToOneToFailInTearDown == 1)
TEST_FAIL("Failed in tearDown"); TEST_FAIL("<= Failed in tearDown");
if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0))
{
UnityPrint("[[[[ Previous Test Should Have Passed But Did Not ]]]]");
UNITY_OUTPUT_CHAR('\n');
}
} }
void testTrue(void) void testTrue(void)
@ -474,53 +485,16 @@ void testEqualPointers(void)
p1 = &v1; p1 = &v1;
p2 = &v1; p2 = &v1;
TEST_ASSERT_EQUAL_INT(p0, &v0); TEST_ASSERT_EQUAL_PTR(p0, &v0);
TEST_ASSERT_EQUAL_INT(&v1, p1); TEST_ASSERT_EQUAL_PTR(&v1, p1);
TEST_ASSERT_EQUAL_INT(p2, p1); TEST_ASSERT_EQUAL_PTR(p2, p1);
TEST_ASSERT_EQUAL_INT(&v0, &v0); TEST_ASSERT_EQUAL_PTR(&v0, &v0);
} }
void testFloatsWithinDelta(void) void testNotEqualPointers(void)
{
TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f);
TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f);
TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f);
TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f);
}
void testFloatsNotWithinDelta(void)
{ {
EXPECT_ABORT_BEGIN EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f); TEST_ASSERT_EQUAL_PTR(0x12345678, 0x12345677);
VERIFY_FAILS_END
}
void testFloatsEqual(void)
{
TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f);
TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f);
TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f);
TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f);
}
void testFloatsNotEqual(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f);
VERIFY_FAILS_END
}
void testFloatsNotEqualNegative1(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f);
VERIFY_FAILS_END
}
void testFloatsNotEqualNegative2(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f);
VERIFY_FAILS_END VERIFY_FAILS_END
} }
@ -531,7 +505,7 @@ void testIntsWithinDelta(void)
TEST_ASSERT_INT_WITHIN(5, 5000, 5005); TEST_ASSERT_INT_WITHIN(5, 5000, 5005);
TEST_ASSERT_INT_WITHIN(500, 50, -440); TEST_ASSERT_INT_WITHIN(500, 50, -440);
TEST_ASSERT_INT_WITHIN(2, 2147483647, -1); TEST_ASSERT_INT_WITHIN(2, -1, -1);
TEST_ASSERT_INT_WITHIN(5, 1, -1); TEST_ASSERT_INT_WITHIN(5, 1, -1);
TEST_ASSERT_INT_WITHIN(5, -1, 1); TEST_ASSERT_INT_WITHIN(5, -1, 1);
} }
@ -615,8 +589,6 @@ void testHEX8sWithinDelta(void)
void testHEX8sNotWithinDelta(void) void testHEX8sNotWithinDelta(void)
{ {
EXPECT_ABORT_BEGIN EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX8_WITHIN(2, 255, 0); TEST_ASSERT_HEX8_WITHIN(2, 255, 0);
VERIFY_FAILS_END VERIFY_FAILS_END
@ -631,7 +603,17 @@ void testEqualStrings(void)
TEST_ASSERT_EQUAL_STRING("foo", testString); TEST_ASSERT_EQUAL_STRING("foo", testString);
TEST_ASSERT_EQUAL_STRING(testString, "foo"); TEST_ASSERT_EQUAL_STRING(testString, "foo");
TEST_ASSERT_EQUAL_STRING("", ""); TEST_ASSERT_EQUAL_STRING("", "");
TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures); }
void testEqualStringsWithCarriageReturnsAndLineFeeds(void)
{
const char *testString = "foo\r\nbar";
TEST_ASSERT_EQUAL_STRING(testString, testString);
TEST_ASSERT_EQUAL_STRING("foo\r\nbar", "foo\r\nbar");
TEST_ASSERT_EQUAL_STRING("foo\r\nbar", testString);
TEST_ASSERT_EQUAL_STRING(testString, "foo\r\nbar");
TEST_ASSERT_EQUAL_STRING("", "");
} }
void testNotEqualString1(void) void testNotEqualString1(void)
@ -655,6 +637,22 @@ void testNotEqualString3(void)
VERIFY_FAILS_END VERIFY_FAILS_END
} }
void testNotEqualString4(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING("bar\r", "bar\n");
VERIFY_FAILS_END
}
void testNotEqualString5(void)
{
const char str1[] = { 0x41, 0x42, 0x03, 0x00 };
const char str2[] = { 0x41, 0x42, 0x04, 0x00 };
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_STRING(str1, str2);
VERIFY_FAILS_END
}
void testNotEqualString_ExpectedStringIsNull(void) void testNotEqualString_ExpectedStringIsNull(void)
{ {
EXPECT_ABORT_BEGIN EXPECT_ABORT_BEGIN
@ -1076,6 +1074,244 @@ void testNotEqualHEX8Arrays3(void)
VERIFY_FAILS_END VERIFY_FAILS_END
} }
void testEqualMemoryArrays(void)
{
int p0[] = {1, 8, 987, -2};
int p1[] = {1, 8, 987, -2};
int p2[] = {1, 8, 987, 2};
int p3[] = {1, 500, 600, 700};
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, 4, 1);
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, 4, 4);
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p2, 4, 3);
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p3, 4, 1);
}
void testNotEqualMemoryArraysExpectedNull(void)
{
int* p0 = NULL;
int p1[] = {1, 8, 987, 2};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
VERIFY_FAILS_END
}
void testNotEqualMemoryArraysActualNull(void)
{
int p0[] = {1, 8, 987, -2};
int* p1 = NULL;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
VERIFY_FAILS_END
}
void testNotEqualMemoryArrays1(void)
{
int p0[] = {1, 8, 987, -2};
int p1[] = {1, 8, 987, 2};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
VERIFY_FAILS_END
}
void testNotEqualMemoryArrays2(void)
{
int p0[] = {1, 8, 987, -2};
int p1[] = {2, 8, 987, -2};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
VERIFY_FAILS_END
}
void testNotEqualMemoryArrays3(void)
{
int p0[] = {1, 8, 987, -2};
int p1[] = {1, 8, 986, -2};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
VERIFY_FAILS_END
}
void testProtection(void)
{
volatile int mask = 0;
if (TEST_PROTECT())
{
mask |= 1;
TEST_ABORT();
}
else
{
Unity.CurrentTestFailed = 0;
mask |= 2;
}
TEST_ASSERT_EQUAL(3, mask);
}
void testIgnoredAndThenFailInTearDown(void)
{
SetToOneToFailInTearDown = 1;
TEST_IGNORE();
}
// ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES 64 BIT SUPPORT ==================
#ifdef UNITY_SUPPORT_64
void testEqualHex64s(void)
{
_UU64 v0, v1;
_UU64 *p0, *p1;
v0 = 0x9876543201234567;
v1 = 0x9876543201234567;
p0 = &v0;
p1 = &v1;
TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, 0x9876543201234567);
TEST_ASSERT_EQUAL_HEX64(v0, v1);
TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, v1);
TEST_ASSERT_EQUAL_HEX64(v0, 0x9876543201234567);
TEST_ASSERT_EQUAL_HEX64(*p0, v1);
TEST_ASSERT_EQUAL_HEX64(*p0, *p1);
TEST_ASSERT_EQUAL_HEX64(*p0, 0x9876543201234567);
}
void testNotEqualHex64s(void)
{
_UU64 v0, v1;
v0 = 9000000000;
v1 = 9100000000;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_HEX64(v0, v1);
VERIFY_FAILS_END
}
void testNotEqualHex64sIfSigned(void)
{
_US64 v0, v1;
v0 = -9000000000;
v1 = 9000000000;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_HEX64(v0, v1);
VERIFY_FAILS_END
}
void testHEX64sWithinDelta(void)
{
TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
TEST_ASSERT_HEX64_WITHIN(5, 5000, 4996);
TEST_ASSERT_HEX64_WITHIN(5, 5000, 5005);
}
void testHEX64sNotWithinDelta(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
VERIFY_FAILS_END
}
void testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_HEX64_WITHIN(5, 1, -1);
VERIFY_FAILS_END
}
void testEqualHEX64Arrays(void)
{
_UU64 p0[] = {1, 8, 987, 65132u};
_UU64 p1[] = {1, 8, 987, 65132u};
_UU64 p2[] = {1, 8, 987, 2};
_UU64 p3[] = {1, 500, 600, 700};
TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 1);
TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 4);
TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p2, 3);
TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p3, 1);
}
void testNotEqualHEX64Arrays1(void)
{
_UU64 p0[] = {1, 8, 987, 65132u};
_UU64 p1[] = {1, 8, 987, 65131u};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
}
void testNotEqualHEX64Arrays2(void)
{
_UU64 p0[] = {1, 8, 987, 65132u};
_UU64 p1[] = {2, 8, 987, 65132u};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4);
VERIFY_FAILS_END
}
#endif //64-bit SUPPORT
// ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES FLOAT SUPPORT ==================
#ifndef UNITY_EXCLUDE_FLOAT
void testFloatsWithinDelta(void)
{
TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f);
TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f);
TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f);
TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f);
}
void testFloatsNotWithinDelta(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f);
VERIFY_FAILS_END
}
void testFloatsEqual(void)
{
TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f);
TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f);
TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f);
TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f);
}
void testFloatsNotEqual(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f);
VERIFY_FAILS_END
}
void testFloatsNotEqualNegative1(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f);
VERIFY_FAILS_END
}
void testFloatsNotEqualNegative2(void)
{
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f);
VERIFY_FAILS_END
}
void testEqualFloatArrays(void) void testEqualFloatArrays(void)
{ {
float p0[] = {1.0, -8.0, 25.4, -0.123}; float p0[] = {1.0, -8.0, 25.4, -0.123};
@ -1170,90 +1406,4 @@ void testNotEqualFloatArraysNegative3(void)
VERIFY_FAILS_END VERIFY_FAILS_END
} }
void testEqualMemoryArrays(void) #endif //FLOAT SUPPORT
{
int p0[] = {1, 8, 987, -2};
int p1[] = {1, 8, 987, -2};
int p2[] = {1, 8, 987, 2};
int p3[] = {1, 500, 600, 700};
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, 4, 1);
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, 4, 4);
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p2, 4, 3);
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p3, 4, 1);
}
void testNotEqualMemoryArraysExpectedNull(void)
{
int* p0 = NULL;
int p1[] = {1, 8, 987, 2};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
VERIFY_FAILS_END
}
void testNotEqualMemoryArraysActualNull(void)
{
int p0[] = {1, 8, 987, -2};
int* p1 = NULL;
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
VERIFY_FAILS_END
}
void testNotEqualMemoryArrays1(void)
{
int p0[] = {1, 8, 987, -2};
int p1[] = {1, 8, 987, 2};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
VERIFY_FAILS_END
}
void testNotEqualMemoryArrays2(void)
{
int p0[] = {1, 8, 987, -2};
int p1[] = {2, 8, 987, -2};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
VERIFY_FAILS_END
}
void testNotEqualMemoryArrays3(void)
{
int p0[] = {1, 8, 987, -2};
int p1[] = {1, 8, 986, -2};
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, 4, 4);
VERIFY_FAILS_END
}
void testProtection(void)
{
volatile int mask = 0;
if (TEST_PROTECT())
{
mask |= 1;
TEST_ABORT();
}
else
{
Unity.CurrentTestFailed = 0;
mask |= 2;
}
TEST_ASSERT_EQUAL(3, mask);
}
void testIgnoredAndThenFailInTearDown(void)
{
SetToOneToFailInTearDown = 1;
TEST_IGNORE();
}