summaryrefslogtreecommitdiff
path: root/tests/unity/src
diff options
context:
space:
mode:
Diffstat (limited to 'tests/unity/src')
-rw-r--r--tests/unity/src/unity.c1141
-rw-r--r--tests/unity/src/unity.h242
-rw-r--r--tests/unity/src/unity_internals.h546
3 files changed, 0 insertions, 1929 deletions
diff --git a/tests/unity/src/unity.c b/tests/unity/src/unity.c
deleted file mode 100644
index b6ec3d119..000000000
--- a/tests/unity/src/unity.c
+++ /dev/null
@@ -1,1141 +0,0 @@
-/* ==========================================
- Unity Project - A Test Framework for C
- Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
- [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
-#include "unity.h"
-#include <stdio.h>
-#include <string.h>
-
-#define UNITY_FAIL_AND_BAIL { Unity.CurrentTestFailed = 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
-#define UNITY_SKIP_EXECUTION { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} }
-#define UNITY_PRINT_EOL { UNITY_OUTPUT_CHAR('\n'); }
-
-struct _Unity Unity = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , { 0 } };
-
-const char* UnityStrNull = "NULL";
-const char* UnityStrSpacer = ". ";
-const char* UnityStrExpected = " Expected ";
-const char* UnityStrWas = " Was ";
-const char* UnityStrTo = " To ";
-const char* UnityStrElement = " Element ";
-const char* UnityStrByte = " Byte ";
-const char* UnityStrMemory = " Memory Mismatch.";
-const char* UnityStrDelta = " Values Not Within Delta ";
-const char* UnityStrPointless= " You Asked Me To Compare Nothing, Which Was Pointless.";
-const char* UnityStrNullPointerForExpected= " Expected pointer to be NULL";
-const char* UnityStrNullPointerForActual = " Actual pointer was NULL";
-const char* UnityStrInf = "Infinity";
-const char* UnityStrNegInf = "Negative Infinity";
-const char* UnityStrNaN = "NaN";
-
-// Dividing by these constants produces +/- infinity.
-// The rationale is given in UnityAssertFloatIsInf's body.
-static const _UF f_zero = 0.0f;
-#ifndef UNITY_EXCLUDE_DOUBLE
-static const _UD d_zero = 0.0;
-#endif
-
-// compiler-generic print formatting masks
-const _U_UINT UnitySizeMask[] =
-{
- 255u, // 0xFF
- 65535u, // 0xFFFF
- 65535u,
- 4294967295u, // 0xFFFFFFFF
- 4294967295u,
- 4294967295u,
- 4294967295u
-#ifdef UNITY_SUPPORT_64
- ,0xFFFFFFFFFFFFFFFF
-#endif
-};
-
-void UnityPrintFail(void);
-void UnityPrintOk(void);
-
-//-----------------------------------------------
-// Pretty Printers & Test Result Output Handlers
-//-----------------------------------------------
-
-void UnityPrint(const char* string)
-{
- const char* pch = string;
-
- if (pch != NULL)
- {
- while (*pch)
- {
- // printable characters plus CR & LF are printed
- if ((*pch <= 126) && (*pch >= 32))
- {
- UNITY_OUTPUT_CHAR(*pch);
- }
- //write escaped carriage returns
- else if (*pch == 13)
- {
- UNITY_OUTPUT_CHAR('\\');
- UNITY_OUTPUT_CHAR('r');
- }
- //write escaped line feeds
- else if (*pch == 10)
- {
- UNITY_OUTPUT_CHAR('\\');
- UNITY_OUTPUT_CHAR('n');
- }
- // unprintable characters are shown as codes
- else
- {
- UNITY_OUTPUT_CHAR('\\');
- UnityPrintNumberHex((_U_SINT)*pch, 2);
- }
- pch++;
- }
- }
-}
-
-//-----------------------------------------------
-void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style)
-{
- if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
- {
- UnityPrintNumber(number);
- }
- else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
- {
- UnityPrintNumberUnsigned( (_U_UINT)number & UnitySizeMask[((_U_UINT)style & (_U_UINT)0x0F) - 1] );
- }
- else
- {
- UnityPrintNumberHex((_U_UINT)number, (style & 0x000F) << 1);
- }
-}
-
-//-----------------------------------------------
-/// basically do an itoa using as little ram as possible
-void UnityPrintNumber(const _U_SINT number_to_print)
-{
- _U_SINT divisor = 1;
- _U_SINT next_divisor;
- _U_SINT number = number_to_print;
-
- if (number < 0)
- {
- UNITY_OUTPUT_CHAR('-');
- number = -number;
- }
-
- // figure out initial divisor
- while (number / divisor > 9)
- {
- next_divisor = divisor * 10;
- if (next_divisor > divisor)
- divisor = next_divisor;
- else
- break;
- }
-
- // now mod and print, then divide divisor
- do
- {
- UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
- divisor /= 10;
- }
- while (divisor > 0);
-}
-
-//-----------------------------------------------
-/// basically do an itoa using as little ram as possible
-void UnityPrintNumberUnsigned(const _U_UINT number)
-{
- _U_UINT divisor = 1;
- _U_UINT next_divisor;
-
- // figure out initial divisor
- while (number / divisor > 9)
- {
- next_divisor = divisor * 10;
- if (next_divisor > divisor)
- divisor = next_divisor;
- else
- break;
- }
-
- // now mod and print, then divide divisor
- do
- {
- UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
- divisor /= 10;
- }
- while (divisor > 0);
-}
-
-//-----------------------------------------------
-void UnityPrintNumberHex(const _U_UINT number, const char nibbles_to_print)
-{
- _U_UINT nibble;
- char nibbles = nibbles_to_print;
- UNITY_OUTPUT_CHAR('0');
- UNITY_OUTPUT_CHAR('x');
-
- while (nibbles > 0)
- {
- nibble = (number >> (--nibbles << 2)) & 0x0000000F;
- if (nibble <= 9)
- {
- UNITY_OUTPUT_CHAR((char)('0' + nibble));
- }
- else
- {
- UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble));
- }
- }
-}
-
-//-----------------------------------------------
-void UnityPrintMask(const _U_UINT mask, const _U_UINT number)
-{
- _U_UINT current_bit = (_U_UINT)1 << (UNITY_INT_WIDTH - 1);
- _US32 i;
-
- for (i = 0; i < UNITY_INT_WIDTH; i++)
- {
- if (current_bit & mask)
- {
- if (current_bit & number)
- {
- UNITY_OUTPUT_CHAR('1');
- }
- else
- {
- UNITY_OUTPUT_CHAR('0');
- }
- }
- else
- {
- UNITY_OUTPUT_CHAR('X');
- }
- current_bit = current_bit >> 1;
- }
-}
-
-//-----------------------------------------------
-#ifdef UNITY_FLOAT_VERBOSE
-void UnityPrintFloat(_UF number)
-{
- char TempBuffer[32];
- sprintf(TempBuffer, "%.6f", number);
- UnityPrint(TempBuffer);
-}
-#endif
-
-//-----------------------------------------------
-
-void UnityPrintFail(void)
-{
- UnityPrint("FAIL");
-}
-
-void UnityPrintOk(void)
-{
- UnityPrint("OK");
-}
-
-//-----------------------------------------------
-void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line)
-{
- UnityPrint(file);
- UNITY_OUTPUT_CHAR(':');
- UnityPrintNumber(line);
- UNITY_OUTPUT_CHAR(':');
- UnityPrint(Unity.CurrentTestName);
- UNITY_OUTPUT_CHAR(':');
-}
-
-//-----------------------------------------------
-void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line)
-{
- UnityTestResultsBegin(Unity.TestFile, line);
- UnityPrint("FAIL:");
-}
-
-//-----------------------------------------------
-void UnityConcludeTest(void)
-{
- if (Unity.CurrentTestIgnored)
- {
- Unity.TestIgnores++;
- }
- else if (!Unity.CurrentTestFailed)
- {
- UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber);
- UnityPrint("PASS");
- UNITY_PRINT_EOL;
- }
- else
- {
- Unity.TestFailures++;
- }
-
- Unity.CurrentTestFailed = 0;
- Unity.CurrentTestIgnored = 0;
-}
-
-//-----------------------------------------------
-void UnityAddMsgIfSpecified(const char* msg)
-{
- if (msg)
- {
- UnityPrint(UnityStrSpacer);
- UnityPrint(msg);
- }
-}
-
-//-----------------------------------------------
-void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual)
-{
- UnityPrint(UnityStrExpected);
- if (expected != NULL)
- {
- UNITY_OUTPUT_CHAR('\'');
- UnityPrint(expected);
- UNITY_OUTPUT_CHAR('\'');
- }
- else
- {
- UnityPrint(UnityStrNull);
- }
- UnityPrint(UnityStrWas);
- if (actual != NULL)
- {
- UNITY_OUTPUT_CHAR('\'');
- UnityPrint(actual);
- UNITY_OUTPUT_CHAR('\'');
- }
- else
- {
- UnityPrint(UnityStrNull);
- }
-}
-
-//-----------------------------------------------
-// Assertion & Control Helpers
-//-----------------------------------------------
-
-int UnityCheckArraysForNull(const void* expected, const void* actual, const UNITY_LINE_TYPE lineNumber, const char* msg)
-{
- //return true if they are both NULL
- if ((expected == NULL) && (actual == NULL))
- return 1;
-
- //throw error if just expected is NULL
- if (expected == NULL)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrNullPointerForExpected);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-
- //throw error if just actual is NULL
- if (actual == NULL)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrNullPointerForActual);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-
- //return false if neither is NULL
- return 0;
-}
-
-//-----------------------------------------------
-// Assertion Functions
-//-----------------------------------------------
-
-void UnityAssertBits(const _U_SINT mask,
- const _U_SINT expected,
- const _U_SINT actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- UNITY_SKIP_EXECUTION;
-
- if ((mask & expected) != (mask & actual))
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrExpected);
- UnityPrintMask(mask, expected);
- UnityPrint(UnityStrWas);
- UnityPrintMask(mask, actual);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertEqualNumber(const _U_SINT expected,
- const _U_SINT actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style)
-{
- UNITY_SKIP_EXECUTION;
-
- if (expected != actual)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(expected, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(actual, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertEqualIntArray(const _U_SINT* expected,
- const _U_SINT* actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style)
-{
- _UU32 elements = num_elements;
- const _US8* ptr_exp = (_US8*)expected;
- const _US8* ptr_act = (_US8*)actual;
-
- UNITY_SKIP_EXECUTION;
-
- if (elements == 0)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrPointless);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-
- if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
- return;
-
- switch(style)
- {
- case UNITY_DISPLAY_STYLE_HEX8:
- case UNITY_DISPLAY_STYLE_INT8:
- case UNITY_DISPLAY_STYLE_UINT8:
- while (elements--)
- {
- if (*ptr_exp != *ptr_act)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(*ptr_exp, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(*ptr_act, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
- ptr_exp += 1;
- ptr_act += 1;
- }
- break;
- case UNITY_DISPLAY_STYLE_HEX16:
- case UNITY_DISPLAY_STYLE_INT16:
- case UNITY_DISPLAY_STYLE_UINT16:
- while (elements--)
- {
- if (*(_US16*)ptr_exp != *(_US16*)ptr_act)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(*(_US16*)ptr_exp, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(*(_US16*)ptr_act, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
- ptr_exp += 2;
- ptr_act += 2;
- }
- 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:
- while (elements--)
- {
- if (*(_US32*)ptr_exp != *(_US32*)ptr_act)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(*(_US32*)ptr_exp, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(*(_US32*)ptr_act, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
- ptr_exp += 4;
- ptr_act += 4;
- }
- break;
- }
-}
-
-//-----------------------------------------------
-#ifndef UNITY_EXCLUDE_FLOAT
-void UnityAssertEqualFloatArray(const _UF* expected,
- const _UF* actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UU32 elements = num_elements;
- const _UF* ptr_expected = expected;
- const _UF* ptr_actual = actual;
- _UF diff, tol;
-
- UNITY_SKIP_EXECUTION;
-
- if (elements == 0)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrPointless);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-
- if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
- return;
-
- while (elements--)
- {
- diff = *ptr_expected - *ptr_actual;
- if (diff < 0.0f)
- diff = 0.0f - diff;
- tol = UNITY_FLOAT_PRECISION * *ptr_expected;
- if (tol < 0.0f)
- tol = 0.0f - tol;
-
- //This first part of this condition will catch any NaN or Infinite values
- if ((diff * 0.0f != 0.0f) || (diff > tol))
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
-#ifdef UNITY_FLOAT_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrintFloat(*ptr_expected);
- UnityPrint(UnityStrWas);
- UnityPrintFloat(*ptr_actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
- ptr_expected++;
- ptr_actual++;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertFloatsWithin(const _UF delta,
- const _UF expected,
- const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UF diff = actual - expected;
- _UF pos_delta = delta;
-
- UNITY_SKIP_EXECUTION;
-
- if (diff < 0.0f)
- {
- diff = 0.0f - diff;
- }
- if (pos_delta < 0.0f)
- {
- pos_delta = 0.0f - pos_delta;
- }
-
- //This first part of this condition will catch any NaN or Infinite values
- if ((diff * 0.0f != 0.0f) || (pos_delta < diff))
- {
- UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_FLOAT_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrintFloat(expected);
- UnityPrint(UnityStrWas);
- UnityPrintFloat(actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertFloatIsInf(const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- UNITY_SKIP_EXECUTION;
-
- // In Microsoft Visual C++ Express Edition 2008,
- // if ((1.0f / f_zero) != actual)
- // produces
- // error C2124: divide or mod by zero
- // As a workaround, place 0 into a variable.
- if ((1.0f / f_zero) != actual)
- {
- UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_FLOAT_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrint(UnityStrInf);
- UnityPrint(UnityStrWas);
- UnityPrintFloat(actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertFloatIsNegInf(const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- UNITY_SKIP_EXECUTION;
-
- // The rationale for not using 1.0f/0.0f is given in UnityAssertFloatIsInf's body.
- if ((-1.0f / f_zero) != actual)
- {
- UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_FLOAT_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrint(UnityStrNegInf);
- UnityPrint(UnityStrWas);
- UnityPrintFloat(actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertFloatIsNaN(const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- UNITY_SKIP_EXECUTION;
-
- if (actual == actual)
- {
- UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_FLOAT_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrint(UnityStrNaN);
- UnityPrint(UnityStrWas);
- UnityPrintFloat(actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-#endif //not UNITY_EXCLUDE_FLOAT
-
-//-----------------------------------------------
-#ifndef UNITY_EXCLUDE_DOUBLE
-void UnityAssertEqualDoubleArray(const _UD* expected,
- const _UD* actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UU32 elements = num_elements;
- const _UD* ptr_expected = expected;
- const _UD* ptr_actual = actual;
- _UD diff, tol;
-
- UNITY_SKIP_EXECUTION;
-
- if (elements == 0)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrPointless);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-
- if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
- return;
-
- while (elements--)
- {
- diff = *ptr_expected - *ptr_actual;
- if (diff < 0.0)
- diff = 0.0 - diff;
- tol = UNITY_DOUBLE_PRECISION * *ptr_expected;
- if (tol < 0.0)
- tol = 0.0 - tol;
-
- //This first part of this condition will catch any NaN or Infinite values
- if ((diff * 0.0 != 0.0) || (diff > tol))
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrElement);
- UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
-#ifdef UNITY_DOUBLE_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrintFloat((float)(*ptr_expected));
- UnityPrint(UnityStrWas);
- UnityPrintFloat((float)(*ptr_actual));
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
- ptr_expected++;
- ptr_actual++;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertDoublesWithin(const _UD delta,
- const _UD expected,
- const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UD diff = actual - expected;
- _UD pos_delta = delta;
-
- UNITY_SKIP_EXECUTION;
-
- if (diff < 0.0)
- {
- diff = 0.0 - diff;
- }
- if (pos_delta < 0.0)
- {
- pos_delta = 0.0 - pos_delta;
- }
-
- //This first part of this condition will catch any NaN or Infinite values
- if ((diff * 0.0 != 0.0) || (pos_delta < diff))
- {
- UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_DOUBLE_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrintFloat((float)expected);
- UnityPrint(UnityStrWas);
- UnityPrintFloat((float)actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertDoubleIsInf(const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- UNITY_SKIP_EXECUTION;
-
- // The rationale for not using 1.0/0.0 is given in UnityAssertFloatIsInf's body.
- if ((1.0 / d_zero) != actual)
- {
- UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_DOUBLE_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrint(UnityStrInf);
- UnityPrint(UnityStrWas);
- UnityPrintFloat((float)actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertDoubleIsNegInf(const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- UNITY_SKIP_EXECUTION;
-
- // The rationale for not using 1.0/0.0 is given in UnityAssertFloatIsInf's body.
- if ((-1.0 / d_zero) != actual)
- {
- UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_DOUBLE_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrint(UnityStrNegInf);
- UnityPrint(UnityStrWas);
- UnityPrintFloat((float)actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertDoubleIsNaN(const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- UNITY_SKIP_EXECUTION;
-
- if (actual == actual)
- {
- UnityTestResultsFailBegin(lineNumber);
-#ifdef UNITY_DOUBLE_VERBOSE
- UnityPrint(UnityStrExpected);
- UnityPrint(UnityStrNaN);
- UnityPrint(UnityStrWas);
- UnityPrintFloat((float)actual);
-#else
- UnityPrint(UnityStrDelta);
-#endif
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-#endif // not UNITY_EXCLUDE_DOUBLE
-
-//-----------------------------------------------
-void UnityAssertNumbersWithin( const _U_SINT delta,
- const _U_SINT expected,
- const _U_SINT actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style)
-{
- UNITY_SKIP_EXECUTION;
-
- if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
- {
- if (actual > expected)
- Unity.CurrentTestFailed = ((actual - expected) > delta);
- else
- Unity.CurrentTestFailed = ((expected - actual) > delta);
- }
- else
- {
- if ((_U_UINT)actual > (_U_UINT)expected)
- Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > (_U_UINT)delta);
- else
- Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > (_U_UINT)delta);
- }
-
- if (Unity.CurrentTestFailed)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrDelta);
- UnityPrintNumberByStyle(delta, style);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(expected, style);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(actual, style);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertEqualString(const char* expected,
- const char* actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UU32 i;
-
- UNITY_SKIP_EXECUTION;
-
- // if both pointers not null compare the strings
- if (expected && actual)
- {
- for (i = 0; expected[i] || actual[i]; i++)
- {
- if (expected[i] != actual[i])
- {
- Unity.CurrentTestFailed = 1;
- break;
- }
- }
- }
- else
- { // handle case of one pointers being null (if both null, test should pass)
- if (expected != actual)
- {
- Unity.CurrentTestFailed = 1;
- }
- }
-
- if (Unity.CurrentTestFailed)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrintExpectedAndActualStrings(expected, actual);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-}
-
-//-----------------------------------------------
-void UnityAssertEqualStringArray( const char** expected,
- const char** actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- _UU32 i, j = 0;
-
- UNITY_SKIP_EXECUTION;
-
- // if no elements, it's an error
- if (num_elements == 0)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrPointless);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-
- if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
- return;
-
- do
- {
- // if both pointers not null compare the strings
- if (expected[j] && actual[j])
- {
- for (i = 0; expected[j][i] || actual[j][i]; i++)
- {
- if (expected[j][i] != actual[j][i])
- {
- Unity.CurrentTestFailed = 1;
- break;
- }
- }
- }
- else
- { // handle case of one pointers being null (if both null, test should pass)
- if (expected[j] != actual[j])
- {
- Unity.CurrentTestFailed = 1;
- }
- }
-
- if (Unity.CurrentTestFailed)
- {
- UnityTestResultsFailBegin(lineNumber);
- if (num_elements > 1)
- {
- UnityPrint(UnityStrElement);
- UnityPrintNumberByStyle((num_elements - j - 1), UNITY_DISPLAY_STYLE_UINT);
- }
- UnityPrintExpectedAndActualStrings((const char*)(expected[j]), (const char*)(actual[j]));
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
- } while (++j < num_elements);
-}
-
-//-----------------------------------------------
-void UnityAssertEqualMemory( const void* expected,
- const void* actual,
- const _UU32 length,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber)
-{
- unsigned char* ptr_exp = (unsigned char*)expected;
- unsigned char* ptr_act = (unsigned char*)actual;
- _UU32 elements = num_elements;
- _UU32 bytes;
-
- UNITY_SKIP_EXECUTION;
-
- if ((elements == 0) || (length == 0))
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrPointless);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
-
- if (UnityCheckArraysForNull((void*)expected, (void*)actual, lineNumber, msg) == 1)
- return;
-
- while (elements--)
- {
- /////////////////////////////////////
- bytes = length;
- while (bytes--)
- {
- if (*ptr_exp != *ptr_act)
- {
- UnityTestResultsFailBegin(lineNumber);
- UnityPrint(UnityStrMemory);
- if (num_elements > 1)
- {
- UnityPrint(UnityStrElement);
- UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT);
- }
- UnityPrint(UnityStrByte);
- UnityPrintNumberByStyle((length - bytes - 1), UNITY_DISPLAY_STYLE_UINT);
- UnityPrint(UnityStrExpected);
- UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8);
- UnityPrint(UnityStrWas);
- UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8);
- UnityAddMsgIfSpecified(msg);
- UNITY_FAIL_AND_BAIL;
- }
- ptr_exp += 1;
- ptr_act += 1;
- }
- /////////////////////////////////////
-
- }
-}
-
-//-----------------------------------------------
-// Control Functions
-//-----------------------------------------------
-
-void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
-{
- UNITY_SKIP_EXECUTION;
-
- UnityTestResultsBegin(Unity.TestFile, line);
- UnityPrintFail();
- if (msg != NULL)
- {
- UNITY_OUTPUT_CHAR(':');
- if (msg[0] != ' ')
- {
- UNITY_OUTPUT_CHAR(' ');
- }
- UnityPrint(msg);
- }
- UNITY_FAIL_AND_BAIL;
-}
-
-//-----------------------------------------------
-void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line)
-{
- UNITY_SKIP_EXECUTION;
-
- UnityTestResultsBegin(Unity.TestFile, line);
- UnityPrint("IGNORE");
- if (msg != NULL)
- {
- UNITY_OUTPUT_CHAR(':');
- UNITY_OUTPUT_CHAR(' ');
- UnityPrint(msg);
- }
- UNITY_IGNORE_AND_BAIL;
-}
-
-//-----------------------------------------------
-void setUp(void);
-void tearDown(void);
-void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)
-{
- Unity.CurrentTestName = FuncName;
- Unity.CurrentTestLineNumber = FuncLineNum;
- Unity.NumberOfTests++;
- if (TEST_PROTECT())
- {
- setUp();
- Func();
- }
- if (TEST_PROTECT() && !(Unity.CurrentTestIgnored))
- {
- tearDown();
- }
- UnityConcludeTest();
-}
-
-//-----------------------------------------------
-void UnityBegin(void)
-{
- Unity.NumberOfTests = 0;
- Unity.TestFailures = 0;
- Unity.TestIgnores = 0;
- Unity.CurrentTestFailed = 0;
- Unity.CurrentTestIgnored = 0;
-}
-
-//-----------------------------------------------
-int UnityEnd(void)
-{
- UnityPrint("-----------------------");
- UNITY_PRINT_EOL;
- UnityPrintNumber(Unity.NumberOfTests);
- UnityPrint(" Tests ");
- UnityPrintNumber(Unity.TestFailures);
- UnityPrint(" Failures ");
- UnityPrintNumber(Unity.TestIgnores);
- UnityPrint(" Ignored");
- UNITY_PRINT_EOL;
- if (Unity.TestFailures == 0U)
- {
- UnityPrintOk();
- }
- else
- {
- UnityPrintFail();
- }
- UNITY_PRINT_EOL;
- return Unity.TestFailures;
-}
diff --git a/tests/unity/src/unity.h b/tests/unity/src/unity.h
deleted file mode 100644
index 0c3abe185..000000000
--- a/tests/unity/src/unity.h
+++ /dev/null
@@ -1,242 +0,0 @@
-/* ==========================================
- Unity Project - A Test Framework for C
- Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
- [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
-#ifndef UNITY_FRAMEWORK_H
-#define UNITY_FRAMEWORK_H
-
-#define UNITY
-
-#include "unity_internals.h"
-
-//-------------------------------------------------------
-// Configuration Options
-//-------------------------------------------------------
-
-// Integers
-// - Unity assumes 32 bit integers by default
-// - If your compiler treats ints of a different size, define UNITY_INT_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_FLOAT_VERBOSE to print floating point values in errors (uses sprintf)
-// - 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_DOUBLE_VERBOSE to print floating point values in errors (uses sprintf)
-
-// Output
-// - by default, Unity prints to standard out with putchar. define UNITY_OUTPUT_CHAR(a) with a different function if desired
-
-// 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
-
-//-------------------------------------------------------
-// Test Running Macros
-//-------------------------------------------------------
-
-#define TEST_PROTECT() (setjmp(Unity.AbortFrame) == 0)
-
-#define TEST_ABORT() {longjmp(Unity.AbortFrame, 1);}
-
-#ifndef RUN_TEST
-#define RUN_TEST(func, line_num) UnityDefaultTestRun(func, #func, line_num)
-#endif
-
-#define TEST_LINE_NUM (Unity.CurrentTestLineNumber)
-#define TEST_IS_IGNORED (Unity.CurrentTestIgnored)
-
-//-------------------------------------------------------
-// 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_ONLY()
-
-//-------------------------------------------------------
-// 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")
-
-//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(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_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_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_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_LOW(mask, actual) UNITY_TEST_ASSERT_BITS((mask), (_UU32)(0), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BIT_HIGH(bit, actual) UNITY_TEST_ASSERT_BITS(((_UU32)1 << bit), (_UU32)(-1), (actual), __LINE__, NULL)
-#define TEST_ASSERT_BIT_LOW(bit, actual) UNITY_TEST_ASSERT_BITS(((_UU32)1 << bit), (_UU32)(0), (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_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_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)
-
-//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_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_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)
-
-//Floating Point (If Enabled)
-#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_NEG_INF(actual) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, __LINE__, NULL)
-#define TEST_ASSERT_FLOAT_IS_NAN(actual) UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, __LINE__, NULL)
-
-//Double (If Enabled)
-#define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, __LINE__, NULL)
-#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_NEG_INF(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, __LINE__, NULL)
-#define TEST_ASSERT_DOUBLE_IS_NAN(actual) UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, __LINE__, NULL)
-
-//-------------------------------------------------------
-// Test Asserts (with additional messages)
-//-------------------------------------------------------
-
-//Boolean
-#define TEST_ASSERT_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, message)
-#define TEST_ASSERT_TRUE_MESSAGE(condition, message) UNITY_TEST_ASSERT( (condition), __LINE__, message)
-#define TEST_ASSERT_UNLESS_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, message)
-#define TEST_ASSERT_FALSE_MESSAGE(condition, message) UNITY_TEST_ASSERT( !(condition), __LINE__, message)
-#define TEST_ASSERT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NULL( (pointer), __LINE__, message)
-#define TEST_ASSERT_NOT_NULL_MESSAGE(pointer, message) UNITY_TEST_ASSERT_NOT_NULL((pointer), __LINE__, message)
-
-//Integers (of all sizes)
-#define TEST_ASSERT_EQUAL_INT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT((expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_INT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT8((expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_INT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT16((expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_INT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT32((expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_INT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_INT64((expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_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_EQUAL_UINT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT( (expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_UINT8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT8( (expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_UINT16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT16( (expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_UINT32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT32( (expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_UINT64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_UINT64( (expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_HEX_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_HEX8_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX8( (expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_HEX16_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX16((expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_HEX32_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX32((expected), (actual), __LINE__, message)
-#define TEST_ASSERT_EQUAL_HEX64_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_HEX64((expected), (actual), __LINE__, message)
-#define TEST_ASSERT_BITS_MESSAGE(mask, expected, actual, message) UNITY_TEST_ASSERT_BITS((mask), (expected), (actual), __LINE__, message)
-#define TEST_ASSERT_BITS_HIGH_MESSAGE(mask, actual, message) UNITY_TEST_ASSERT_BITS((mask), (_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_BIT_HIGH_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((_UU32)1 << bit), (_UU32)(-1), (actual), __LINE__, message)
-#define TEST_ASSERT_BIT_LOW_MESSAGE(bit, actual, message) UNITY_TEST_ASSERT_BITS(((_UU32)1 << bit), (_UU32)(0), (actual), __LINE__, message)
-
-//Integer Ranges (of all sizes)
-#define TEST_ASSERT_INT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_INT_WITHIN(delta, expected, actual, __LINE__, message)
-#define TEST_ASSERT_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_HEX16_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, __LINE__, message)
-#define TEST_ASSERT_HEX32_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, __LINE__, message)
-#define TEST_ASSERT_HEX64_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_HEX64_WITHIN(delta, expected, actual, __LINE__, message)
-
-//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_MEMORY_MESSAGE(expected, actual, len, message) UNITY_TEST_ASSERT_EQUAL_MEMORY(expected, actual, len, __LINE__, message)
-
-//Arrays
-#define TEST_ASSERT_EQUAL_INT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_INT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT8_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_INT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT16_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_INT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT32_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_INT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_INT64_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_UINT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_UINT8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT8_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_UINT16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT16_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_UINT32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_UINT64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_UINT64_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_HEX_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_HEX8_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX8_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_HEX16_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX16_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_HEX32_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_HEX64_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_HEX64_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_PTR_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_STRING_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_STRING_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_EQUAL_MEMORY_ARRAY_MESSAGE(expected, actual, len, num_elements, message) UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY(expected, actual, len, num_elements, __LINE__, message)
-
-//Floating Point (If Enabled)
-#define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, __LINE__, message)
-#define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, __LINE__, message)
-#define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_FLOAT_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, __LINE__, message)
-#define TEST_ASSERT_FLOAT_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, __LINE__, message)
-#define TEST_ASSERT_FLOAT_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, __LINE__, message)
-
-//Double (If Enabled)
-#define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, __LINE__, message)
-#define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, __LINE__, message)
-#define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, __LINE__, message)
-#define TEST_ASSERT_DOUBLE_IS_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, __LINE__, message)
-#define TEST_ASSERT_DOUBLE_IS_NEG_INF_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, __LINE__, message)
-#define TEST_ASSERT_DOUBLE_IS_NAN_MESSAGE(actual, message) UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, __LINE__, message)
-#endif
diff --git a/tests/unity/src/unity_internals.h b/tests/unity/src/unity_internals.h
deleted file mode 100644
index 1e2f668f0..000000000
--- a/tests/unity/src/unity_internals.h
+++ /dev/null
@@ -1,546 +0,0 @@
-/* ==========================================
- Unity Project - A Test Framework for C
- Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
- [Released under MIT License. Please refer to license.txt for details]
-========================================== */
-
-#ifndef UNITY_INTERNALS_H
-#define UNITY_INTERNALS_H
-
-#include <stdio.h>
-#include <setjmp.h>
-
-// Unity attempts to determine sizeof(various types)
-// based on UINT_MAX, ULONG_MAX, etc. These are typically
-// defined in limits.h.
-#ifdef UNITY_USE_LIMITS_H
-#include <limits.h>
-#endif
-// As a fallback, hope that including stdint.h will
-// provide this information.
-#ifndef UNITY_EXCLUDE_STDINT_H
-#include <stdint.h>
-#endif
-
-//-------------------------------------------------------
-// Guess Widths If Not Specified
-//-------------------------------------------------------
-
-// Determine the size of an int, if not already specificied.
-// We cannot use sizeof(int), because it is not yet defined
-// at this stage in the trnslation of the C program.
-// Therefore, infer it from UINT_MAX if possible.
-#ifndef UNITY_INT_WIDTH
- #ifdef UINT_MAX
- #if (UINT_MAX == 0xFFFF)
- #define UNITY_INT_WIDTH (16)
- #elif (UINT_MAX == 0xFFFFFFFF)
- #define UNITY_INT_WIDTH (32)
- #elif (UINT_MAX == 0xFFFFFFFFFFFFFFFF)
- #define UNITY_INT_WIDTH (64)
- #ifndef UNITY_SUPPORT_64
- #define UNITY_SUPPORT_64
- #endif
- #endif
- #endif
-#endif
-#ifndef UNITY_INT_WIDTH
- #define UNITY_INT_WIDTH (32)
-#endif
-
-// Determine the size of a long, if not already specified,
-// by following the process used above to define
-// UNITY_INT_WIDTH.
-#ifndef UNITY_LONG_WIDTH
- #ifdef ULONG_MAX
- #if (ULONG_MAX == 0xFFFF)
- #define UNITY_LONG_WIDTH (16)
- #elif (ULONG_MAX == 0xFFFFFFFF)
- #define UNITY_LONG_WIDTH (32)
- #elif (ULONG_MAX == 0xFFFFFFFFFFFFFFFF)
- #define UNITY_LONG_WIDTH (64)
- #ifndef UNITY_SUPPORT_64
- #define UNITY_SUPPORT_64
- #endif
- #endif
- #endif
-#endif
-#ifndef UNITY_LONG_WIDTH
- #define UNITY_LONG_WIDTH (32)
-#endif
-
-// Determine the size of a pointer, if not already specified,
-// by following the process used above to define
-// UNITY_INT_WIDTH.
-#ifndef UNITY_POINTER_WIDTH
- #ifdef UINTPTR_MAX
- #if (UINTPTR_MAX <= 0xFFFF)
- #define UNITY_POINTER_WIDTH (16)
- #elif (UINTPTR_MAX <= 0xFFFFFFFF)
- #define UNITY_POINTER_WIDTH (32)
- #elif (UINTPTR_MAX <= 0xFFFFFFFFFFFFFFFF)
- #define UNITY_POINTER_WIDTH (64)
- #ifndef UNITY_SUPPORT_64
- #define UNITY_SUPPORT_64
- #endif
- #endif
- #endif
-#endif
-#ifndef UNITY_POINTER_WIDTH
- #ifdef INTPTR_MAX
- #if (INTPTR_MAX <= 0x7FFF)
- #define UNITY_POINTER_WIDTH (16)
- #elif (INTPTR_MAX <= 0x7FFFFFFF)
- #define UNITY_POINTER_WIDTH (32)
- #elif (INTPTR_MAX <= 0x7FFFFFFFFFFFFFFF)
- #define UNITY_POINTER_WIDTH (64)
- #ifndef UNITY_SUPPORT_64
- #define UNITY_SUPPORT_64
- #endif
- #endif
- #endif
-#endif
-#ifndef UNITY_POINTER_WIDTH
- #define UNITY_POINTER_WIDTH (32)
-#endif
-
-//-------------------------------------------------------
-// Int Support
-//-------------------------------------------------------
-
-#if (UNITY_INT_WIDTH == 32)
- typedef unsigned char _UU8;
- typedef unsigned short _UU16;
- typedef unsigned int _UU32;
- typedef signed char _US8;
- typedef signed short _US16;
- typedef signed int _US32;
-#elif (UNITY_INT_WIDTH == 16)
- typedef unsigned char _UU8;
- typedef unsigned int _UU16;
- typedef unsigned long _UU32;
- typedef signed char _US8;
- typedef signed int _US16;
- typedef signed long _US32;
-#else
- #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
-//-------------------------------------------------------
-
-#if (UNITY_POINTER_WIDTH == 32)
- typedef _UU32 _UP;
-#define UNITY_DISPLAY_STYLE_POINTER UNITY_DISPLAY_STYLE_HEX32
-#elif (UNITY_POINTER_WIDTH == 64)
-#ifndef UNITY_SUPPORT_64
-#error "You've Specified 64-bit pointers without enabling 64-bit Support. Define UNITY_SUPPORT_64"
-#endif
- 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
-
-//-------------------------------------------------------
-// Float Support
-//-------------------------------------------------------
-
-#ifdef UNITY_EXCLUDE_FLOAT
-
-//No Floating Point Support
-#undef UNITY_FLOAT_PRECISION
-#undef UNITY_FLOAT_TYPE
-#undef UNITY_FLOAT_VERBOSE
-
-#else
-
-//Floating Point Support
-#ifndef UNITY_FLOAT_PRECISION
-#define UNITY_FLOAT_PRECISION (0.00001f)
-#endif
-#ifndef UNITY_FLOAT_TYPE
-#define UNITY_FLOAT_TYPE float
-#endif
-typedef UNITY_FLOAT_TYPE _UF;
-
-#endif
-
-//-------------------------------------------------------
-// Double Float Support
-//-------------------------------------------------------
-
-//unlike FLOAT, we DON'T include by default
-#ifndef UNITY_EXCLUDE_DOUBLE
-#ifndef UNITY_INCLUDE_DOUBLE
-#define UNITY_EXCLUDE_DOUBLE
-#endif
-#endif
-
-#ifdef UNITY_EXCLUDE_DOUBLE
-
-//No Floating Point Support
-#undef UNITY_DOUBLE_PRECISION
-#undef UNITY_DOUBLE_TYPE
-#undef UNITY_DOUBLE_VERBOSE
-
-#else
-
-//Floating Point Support
-#ifndef UNITY_DOUBLE_PRECISION
-#define UNITY_DOUBLE_PRECISION (1e-12f)
-#endif
-#ifndef UNITY_DOUBLE_TYPE
-#define UNITY_DOUBLE_TYPE double
-#endif
-typedef UNITY_DOUBLE_TYPE _UD;
-
-#endif
-
-//-------------------------------------------------------
-// Output Method
-//-------------------------------------------------------
-
-#ifndef UNITY_OUTPUT_CHAR
-//Default to using putchar, which is defined in stdio.h above
-#define UNITY_OUTPUT_CHAR(a) putchar(a)
-#else
-//If defined as something else, make sure we declare it here so it's ready for use
-extern int UNITY_OUTPUT_CHAR(int);
-#endif
-
-//-------------------------------------------------------
-// Footprint
-//-------------------------------------------------------
-
-#ifndef UNITY_LINE_TYPE
-#define UNITY_LINE_TYPE _U_UINT
-#endif
-
-#ifndef UNITY_COUNTER_TYPE
-#define UNITY_COUNTER_TYPE _U_UINT
-#endif
-
-//-------------------------------------------------------
-// Internal Structs Needed
-//-------------------------------------------------------
-
-typedef void (*UnityTestFunction)(void);
-
-#define UNITY_DISPLAY_RANGE_INT (0x10)
-#define UNITY_DISPLAY_RANGE_UINT (0x20)
-#define UNITY_DISPLAY_RANGE_HEX (0x40)
-#define UNITY_DISPLAY_RANGE_AUTO (0x80)
-
-typedef enum
-{
-#if (UNITY_INT_WIDTH == 16)
- UNITY_DISPLAY_STYLE_INT = 2 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH == 32)
- UNITY_DISPLAY_STYLE_INT = 4 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH == 64)
- UNITY_DISPLAY_STYLE_INT = 8 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#endif
- UNITY_DISPLAY_STYLE_INT8 = 1 + UNITY_DISPLAY_RANGE_INT,
- UNITY_DISPLAY_STYLE_INT16 = 2 + UNITY_DISPLAY_RANGE_INT,
- UNITY_DISPLAY_STYLE_INT32 = 4 + UNITY_DISPLAY_RANGE_INT,
-#ifdef UNITY_SUPPORT_64
- UNITY_DISPLAY_STYLE_INT64 = 8 + UNITY_DISPLAY_RANGE_INT,
-#endif
-
-#if (UNITY_INT_WIDTH == 16)
- UNITY_DISPLAY_STYLE_UINT = 2 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH == 32)
- UNITY_DISPLAY_STYLE_UINT = 4 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH == 64)
- UNITY_DISPLAY_STYLE_UINT = 8 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#endif
- UNITY_DISPLAY_STYLE_UINT8 = 1 + UNITY_DISPLAY_RANGE_UINT,
- UNITY_DISPLAY_STYLE_UINT16 = 2 + UNITY_DISPLAY_RANGE_UINT,
- UNITY_DISPLAY_STYLE_UINT32 = 4 + UNITY_DISPLAY_RANGE_UINT,
-#ifdef UNITY_SUPPORT_64
- UNITY_DISPLAY_STYLE_UINT64 = 8 + UNITY_DISPLAY_RANGE_UINT,
-#endif
- UNITY_DISPLAY_STYLE_HEX8 = 1 + UNITY_DISPLAY_RANGE_HEX,
- UNITY_DISPLAY_STYLE_HEX16 = 2 + UNITY_DISPLAY_RANGE_HEX,
- UNITY_DISPLAY_STYLE_HEX32 = 4 + UNITY_DISPLAY_RANGE_HEX,
-#ifdef UNITY_SUPPORT_64
- UNITY_DISPLAY_STYLE_HEX64 = 8 + UNITY_DISPLAY_RANGE_HEX,
-#endif
- UNITY_DISPLAY_STYLE_UNKNOWN
-} UNITY_DISPLAY_STYLE_T;
-
-struct _Unity
-{
- const char* TestFile;
- const char* CurrentTestName;
- UNITY_LINE_TYPE CurrentTestLineNumber;
- UNITY_COUNTER_TYPE NumberOfTests;
- UNITY_COUNTER_TYPE TestFailures;
- UNITY_COUNTER_TYPE TestIgnores;
- UNITY_COUNTER_TYPE CurrentTestFailed;
- UNITY_COUNTER_TYPE CurrentTestIgnored;
- jmp_buf AbortFrame;
-};
-
-extern struct _Unity Unity;
-
-//-------------------------------------------------------
-// Test Suite Management
-//-------------------------------------------------------
-
-void UnityBegin(void);
-int UnityEnd(void);
-void UnityConcludeTest(void);
-void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum);
-
-//-------------------------------------------------------
-// Test Output
-//-------------------------------------------------------
-
-void UnityPrint(const char* string);
-void UnityPrintMask(const _U_UINT mask, const _U_UINT number);
-void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style);
-void UnityPrintNumber(const _U_SINT number);
-void UnityPrintNumberUnsigned(const _U_UINT number);
-void UnityPrintNumberHex(const _U_UINT number, const char nibbles);
-
-#ifdef UNITY_FLOAT_VERBOSE
-void UnityPrintFloat(const _UF number);
-#endif
-
-//-------------------------------------------------------
-// Test Assertion Fuctions
-//-------------------------------------------------------
-// Use the macros below this section instead of calling
-// these directly. The macros have a consistent naming
-// convention and will pull in file and line information
-// for you.
-
-void UnityAssertEqualNumber(const _U_SINT expected,
- const _U_SINT actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style);
-
-void UnityAssertEqualIntArray(const _U_SINT* expected,
- const _U_SINT* actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style);
-
-void UnityAssertBits(const _U_SINT mask,
- const _U_SINT expected,
- const _U_SINT actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualString(const char* expected,
- const char* actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualStringArray( const char** expected,
- const char** actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualMemory( const void* expected,
- const void* actual,
- const _UU32 length,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertNumbersWithin(const _U_SINT delta,
- const _U_SINT expected,
- const _U_SINT actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber,
- const UNITY_DISPLAY_STYLE_T style);
-
-void UnityFail(const char* message, const UNITY_LINE_TYPE line);
-
-void UnityIgnore(const char* message, const UNITY_LINE_TYPE line);
-
-#ifndef UNITY_EXCLUDE_FLOAT
-void UnityAssertFloatsWithin(const _UF delta,
- const _UF expected,
- const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualFloatArray(const _UF* expected,
- const _UF* actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertFloatIsInf(const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertFloatIsNegInf(const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertFloatIsNaN(const _UF actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-#endif
-
-#ifndef UNITY_EXCLUDE_DOUBLE
-void UnityAssertDoublesWithin(const _UD delta,
- const _UD expected,
- const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertEqualDoubleArray(const _UD* expected,
- const _UD* actual,
- const _UU32 num_elements,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertDoubleIsInf(const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertDoubleIsNegInf(const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-
-void UnityAssertDoubleIsNaN(const _UD actual,
- const char* msg,
- const UNITY_LINE_TYPE lineNumber);
-#endif
-
-//-------------------------------------------------------
-// Basic Fail and Ignore
-//-------------------------------------------------------
-
-#define UNITY_TEST_FAIL(line, message) UnityFail( (message), (UNITY_LINE_TYPE)line);
-#define UNITY_TEST_IGNORE(line, message) UnityIgnore( (message), (UNITY_LINE_TYPE)line);
-
-//-------------------------------------------------------
-// Test Asserts
-//-------------------------------------------------------
-
-#define UNITY_TEST_ASSERT(condition, line, message) if (condition) {} else {UNITY_TEST_FAIL((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_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((_U_SINT)(_US8 )(expected), (_U_SINT)(_US8 )(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_EQUAL_INT16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US16)(expected), (_U_SINT)(_US16)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_EQUAL_INT32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US32)(expected), (_U_SINT)(_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
-#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((_U_SINT)(_US8 )(expected), (_U_SINT)(_US8 )(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_EQUAL_UINT16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US16)(expected), (_U_SINT)(_US16)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_EQUAL_UINT32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US32)(expected), (_U_SINT)(_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_EQUAL_HEX8(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US8 )(expected), (_U_SINT)(_US8 )(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8)
-#define UNITY_TEST_ASSERT_EQUAL_HEX16(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US16)(expected), (_U_SINT)(_US16)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16)
-#define UNITY_TEST_ASSERT_EQUAL_HEX32(expected, actual, line, message) UnityAssertEqualNumber((_U_SINT)(_US32)(expected), (_U_SINT)(_US32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32)
-#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((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_INT)
-#define UNITY_TEST_ASSERT_UINT_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(delta), (_U_SINT)(expected), (_U_SINT)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_UINT)
-#define UNITY_TEST_ASSERT_HEX8_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(_U_UINT)(_UU8 )(delta), (_U_SINT)(_U_UINT)(_UU8 )(expected), (_U_SINT)(_U_UINT)(_UU8 )(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX8)
-#define UNITY_TEST_ASSERT_HEX16_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(_U_UINT)(_UU16)(delta), (_U_SINT)(_U_UINT)(_UU16)(expected), (_U_SINT)(_U_UINT)(_UU16)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX16)
-#define UNITY_TEST_ASSERT_HEX32_WITHIN(delta, expected, actual, line, message) UnityAssertNumbersWithin((_U_SINT)(_U_UINT)(_UU32)(delta), (_U_SINT)(_U_UINT)(_UU32)(expected), (_U_SINT)(_U_UINT)(_UU32)(actual), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32)
-
-#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_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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _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 _U_SINT*)(expected), (const _U_SINT*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_HEX32)
-#define UNITY_TEST_ASSERT_EQUAL_PTR_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualIntArray((const _U_SINT*)(_UP*)(expected), (const _U_SINT*)(_UP*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line, UNITY_DISPLAY_STYLE_POINTER)
-#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)
-
-#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)
-#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)
-#endif
-
-#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_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled")
-#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled")
-#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled")
-#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled")
-#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Floating Point Disabled")
-#else
-#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsWithin((_UF)(delta), (_UF)(expected), (_UF)(actual), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((_UF)(expected) * (_UF)UNITY_FLOAT_PRECISION, (_UF)expected, (_UF)actual, (UNITY_LINE_TYPE)line, message)
-#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray((_UF*)(expected), (_UF*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_FLOAT_IS_INF(actual, line, message) UnityAssertFloatIsInf((_UF)(actual), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NEG_INF(actual, line, message) UnityAssertFloatIsNegInf((_UF)(actual), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_FLOAT_IS_NAN(actual, line, message) UnityAssertFloatIsNaN((_UF)(actual), (message), (UNITY_LINE_TYPE)line)
-#endif
-
-#ifdef UNITY_EXCLUDE_DOUBLE
-#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Double Precision Disabled")
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Double Precision Disabled")
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Double Precision Disabled")
-#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Double Precision Disabled")
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Double Precision Disabled")
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)line, "Unity Double Precision Disabled")
-#else
-#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesWithin((_UD)(delta), (_UD)(expected), (_UD)(actual), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((_UF)(expected) * (_UD)UNITY_DOUBLE_PRECISION, (_UD)expected, (_UD)actual, (UNITY_LINE_TYPE)line, message)
-#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray((_UD*)(expected), (_UD*)(actual), (_UU32)(num_elements), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_INF(actual, line, message) UnityAssertFloatIsInf((_UF)(actual), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NEG_INF(actual, line, message) UnityAssertFloatIsNegInf((_UF)(actual), (message), (UNITY_LINE_TYPE)line)
-#define UNITY_TEST_ASSERT_DOUBLE_IS_NAN(actual, line, message) UnityAssertFloatIsNaN((_UF)(actual), (message), (UNITY_LINE_TYPE)line)
-#endif
-
-#endif
generated by cgit v1.3.1 (git 2.54.0) at 2026-08-17 22:04:31 +0000