| /* ========================================================================= | |
| Unity Project - A Test Framework for C | |
| Copyright (c) 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams | |
| [Released under MIT License. Please refer to license.txt for details] | |
| ============================================================================ */ | |
| #define UNITY_INCLUDE_SETUP_STUBS | |
| #include "unity.h" | |
| #include <stddef.h> | |
| /* If omitted from header, declare overrideable prototypes here so they're ready for use */ | |
| #ifdef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION | |
| void UNITY_OUTPUT_CHAR(int); | |
| #endif | |
| /* Helpful macros for us to use here in Assert functions */ | |
| #define UNITY_FAIL_AND_BAIL { Unity.CurrentTestFailed = 1; TEST_ABORT(); } | |
| #define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; TEST_ABORT(); } | |
| #define RETURN_IF_FAIL_OR_IGNORE if (Unity.CurrentTestFailed || Unity.CurrentTestIgnored) return | |
| struct UNITY_STORAGE_T Unity; | |
| #ifdef UNITY_OUTPUT_COLOR | |
| static const char UnityStrOk[] = "\033[42mOK\033[00m"; | |
| static const char UnityStrPass[] = "\033[42mPASS\033[00m"; | |
| static const char UnityStrFail[] = "\033[41mFAIL\033[00m"; | |
| static const char UnityStrIgnore[] = "\033[43mIGNORE\033[00m"; | |
| #else | |
| static const char UnityStrOk[] = "OK"; | |
| static const char UnityStrPass[] = "PASS"; | |
| static const char UnityStrFail[] = "FAIL"; | |
| static const char UnityStrIgnore[] = "IGNORE"; | |
| #endif | |
| static const char UnityStrNull[] = "NULL"; | |
| static const char UnityStrSpacer[] = ". "; | |
| static const char UnityStrExpected[] = " Expected "; | |
| static const char UnityStrWas[] = " Was "; | |
| static const char UnityStrGt[] = " to be greater than "; | |
| static const char UnityStrLt[] = " to be less than "; | |
| static const char UnityStrOrEqual[] = "or equal to "; | |
| static const char UnityStrElement[] = " Element "; | |
| static const char UnityStrByte[] = " Byte "; | |
| static const char UnityStrMemory[] = " Memory Mismatch."; | |
| static const char UnityStrDelta[] = " Values Not Within Delta "; | |
| static const char UnityStrPointless[] = " You Asked Me To Compare Nothing, Which Was Pointless."; | |
| static const char UnityStrNullPointerForExpected[] = " Expected pointer to be NULL"; | |
| static const char UnityStrNullPointerForActual[] = " Actual pointer was NULL"; | |
| #ifndef UNITY_EXCLUDE_FLOAT | |
| static const char UnityStrNot[] = "Not "; | |
| static const char UnityStrInf[] = "Infinity"; | |
| static const char UnityStrNegInf[] = "Negative Infinity"; | |
| static const char UnityStrNaN[] = "NaN"; | |
| static const char UnityStrDet[] = "Determinate"; | |
| static const char UnityStrInvalidFloatTrait[] = "Invalid Float Trait"; | |
| #endif | |
| const char UnityStrErrFloat[] = "Unity Floating Point Disabled"; | |
| const char UnityStrErrDouble[] = "Unity Double Precision Disabled"; | |
| const char UnityStrErr64[] = "Unity 64-bit Support Disabled"; | |
| static const char UnityStrBreaker[] = "-----------------------"; | |
| static const char UnityStrResultsTests[] = " Tests "; | |
| static const char UnityStrResultsFailures[] = " Failures "; | |
| static const char UnityStrResultsIgnored[] = " Ignored "; | |
| static const char UnityStrDetail1Name[] = UNITY_DETAIL1_NAME " "; | |
| static const char UnityStrDetail2Name[] = " " UNITY_DETAIL2_NAME " "; | |
| /*----------------------------------------------- | |
| * 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'); | |
| } | |
| #ifdef UNITY_OUTPUT_COLOR | |
| /* print ANSI escape code */ | |
| else if (*pch == 27 && *(pch + 1) == '[') | |
| { | |
| while (*pch && *pch != 'm') | |
| { | |
| UNITY_OUTPUT_CHAR(*pch); | |
| pch++; | |
| } | |
| UNITY_OUTPUT_CHAR('m'); | |
| } | |
| #endif | |
| /* unprintable characters are shown as codes */ | |
| else | |
| { | |
| UNITY_OUTPUT_CHAR('\\'); | |
| UNITY_OUTPUT_CHAR('x'); | |
| UnityPrintNumberHex((UNITY_UINT)*pch, 2); | |
| } | |
| pch++; | |
| } | |
| } | |
| } | |
| void UnityPrintLen(const char* string, const UNITY_UINT32 length) | |
| { | |
| const char* pch = string; | |
| if (pch != NULL) | |
| { | |
| while (*pch && (UNITY_UINT32)(pch - string) < length) | |
| { | |
| /* printable characters plus CR & LF are printed */ | |
| if ((*pch <= 126) && (*pch >= 32)) | |
| { | |
| UNITY_OUTPUT_CHAR(*pch); | |
| } | |
| /* write escaped carriage returns */ | |
| else if (*pch == 13) | |
| { | |
| UNITY_OUTPUT_CHAR('\\'); | |
| UNITY_OUTPUT_CHAR('r'); | |
| } | |
| /* write escaped line feeds */ | |
| else if (*pch == 10) | |
| { | |
| UNITY_OUTPUT_CHAR('\\'); | |
| UNITY_OUTPUT_CHAR('n'); | |
| } | |
| /* unprintable characters are shown as codes */ | |
| else | |
| { | |
| UNITY_OUTPUT_CHAR('\\'); | |
| UNITY_OUTPUT_CHAR('x'); | |
| UnityPrintNumberHex((UNITY_UINT)*pch, 2); | |
| } | |
| pch++; | |
| } | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style) | |
| { | |
| if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) | |
| { | |
| UnityPrintNumber(number); | |
| } | |
| else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT) | |
| { | |
| UnityPrintNumberUnsigned((UNITY_UINT)number); | |
| } | |
| else | |
| { | |
| UNITY_OUTPUT_CHAR('0'); | |
| UNITY_OUTPUT_CHAR('x'); | |
| UnityPrintNumberHex((UNITY_UINT)number, (char)((style & 0xF) * 2)); | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityPrintNumber(const UNITY_INT number_to_print) | |
| { | |
| UNITY_UINT number = (UNITY_UINT)number_to_print; | |
| if (number_to_print < 0) | |
| { | |
| /* A negative number, including MIN negative */ | |
| UNITY_OUTPUT_CHAR('-'); | |
| number = (UNITY_UINT)(-number_to_print); | |
| } | |
| UnityPrintNumberUnsigned(number); | |
| } | |
| /*----------------------------------------------- | |
| * basically do an itoa using as little ram as possible */ | |
| void UnityPrintNumberUnsigned(const UNITY_UINT number) | |
| { | |
| UNITY_UINT divisor = 1; | |
| /* figure out initial divisor */ | |
| while (number / divisor > 9) | |
| { | |
| divisor *= 10; | |
| } | |
| /* now mod and print, then divide divisor */ | |
| do | |
| { | |
| UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10))); | |
| divisor /= 10; | |
| } while (divisor > 0); | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print) | |
| { | |
| int nibble; | |
| char nibbles = nibbles_to_print; | |
| if ((unsigned)nibbles > (2 * sizeof(number))) | |
| nibbles = 2 * sizeof(number); | |
| while (nibbles > 0) | |
| { | |
| nibbles--; | |
| nibble = (int)(number >> (nibbles * 4)) & 0x0F; | |
| if (nibble <= 9) | |
| { | |
| UNITY_OUTPUT_CHAR((char)('0' + nibble)); | |
| } | |
| else | |
| { | |
| UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble)); | |
| } | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number) | |
| { | |
| UNITY_UINT current_bit = (UNITY_UINT)1 << (UNITY_INT_WIDTH - 1); | |
| UNITY_INT32 i; | |
| for (i = 0; i < UNITY_INT_WIDTH; i++) | |
| { | |
| if (current_bit & mask) | |
| { | |
| if (current_bit & number) | |
| { | |
| UNITY_OUTPUT_CHAR('1'); | |
| } | |
| else | |
| { | |
| UNITY_OUTPUT_CHAR('0'); | |
| } | |
| } | |
| else | |
| { | |
| UNITY_OUTPUT_CHAR('X'); | |
| } | |
| current_bit = current_bit >> 1; | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| #ifndef UNITY_EXCLUDE_FLOAT_PRINT | |
| /* This function prints a floating-point value in a format similar to | |
| * printf("%.6g"). It can work with either single- or double-precision, | |
| * but for simplicity, it prints only 6 significant digits in either case. | |
| * Printing more than 6 digits accurately is hard (at least in the single- | |
| * precision case) and isn't attempted here. */ | |
| void UnityPrintFloat(const UNITY_DOUBLE input_number) | |
| { | |
| UNITY_DOUBLE number = input_number; | |
| /* print minus sign (including for negative zero) */ | |
| if (number < 0.0f || (number == 0.0f && 1.0f / number < 0.0f)) | |
| { | |
| UNITY_OUTPUT_CHAR('-'); | |
| number = -number; | |
| } | |
| /* handle zero, NaN, and +/- infinity */ | |
| if (number == 0.0f) UnityPrint("0"); | |
| else if (isnan(number)) UnityPrint("nan"); | |
| else if (isinf(number)) UnityPrint("inf"); | |
| else | |
| { | |
| int exponent = 0; | |
| int decimals, digits; | |
| UNITY_INT32 n; | |
| char buf[16]; | |
| /* scale up or down by powers of 10 */ | |
| while (number < 100000.0f / 1e6f) { number *= 1e6f; exponent -= 6; } | |
| while (number < 100000.0f) { number *= 10.0f; exponent--; } | |
| while (number > 1000000.0f * 1e6f) { number /= 1e6f; exponent += 6; } | |
| while (number > 1000000.0f) { number /= 10.0f; exponent++; } | |
| /* round to nearest integer */ | |
| n = ((UNITY_INT32)(number + number) + 1) / 2; | |
| if (n > 999999) | |
| { | |
| n = 100000; | |
| exponent++; | |
| } | |
| /* determine where to place decimal point */ | |
| decimals = (exponent <= 0 && exponent >= -9) ? -exponent : 5; | |
| exponent += decimals; | |
| /* truncate trailing zeroes after decimal point */ | |
| while (decimals > 0 && n % 10 == 0) | |
| { | |
| n /= 10; | |
| decimals--; | |
| } | |
| /* build up buffer in reverse order */ | |
| digits = 0; | |
| while (n != 0 || digits < decimals + 1) | |
| { | |
| buf[digits++] = (char)('0' + n % 10); | |
| n /= 10; | |
| } | |
| while (digits > 0) | |
| { | |
| if(digits == decimals) UNITY_OUTPUT_CHAR('.'); | |
| UNITY_OUTPUT_CHAR(buf[--digits]); | |
| } | |
| /* print exponent if needed */ | |
| if (exponent != 0) | |
| { | |
| UNITY_OUTPUT_CHAR('e'); | |
| if(exponent < 0) | |
| { | |
| UNITY_OUTPUT_CHAR('-'); | |
| exponent = -exponent; | |
| } | |
| else | |
| { | |
| UNITY_OUTPUT_CHAR('+'); | |
| } | |
| digits = 0; | |
| while (exponent != 0 || digits < 2) | |
| { | |
| buf[digits++] = (char)('0' + exponent % 10); | |
| exponent /= 10; | |
| } | |
| while (digits > 0) | |
| { | |
| UNITY_OUTPUT_CHAR(buf[--digits]); | |
| } | |
| } | |
| } | |
| } | |
| #endif /* ! UNITY_EXCLUDE_FLOAT_PRINT */ | |
| /*-----------------------------------------------*/ | |
| static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line) | |
| { | |
| UnityPrint(file); | |
| UNITY_OUTPUT_CHAR(':'); | |
| UnityPrintNumber((UNITY_INT)line); | |
| UNITY_OUTPUT_CHAR(':'); | |
| UnityPrint(Unity.CurrentTestName); | |
| UNITY_OUTPUT_CHAR(':'); | |
| } | |
| /*-----------------------------------------------*/ | |
| static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line) | |
| { | |
| UnityTestResultsBegin(Unity.TestFile, line); | |
| UnityPrint(UnityStrFail); | |
| UNITY_OUTPUT_CHAR(':'); | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityConcludeTest(void) | |
| { | |
| if (Unity.CurrentTestIgnored) | |
| { | |
| Unity.TestIgnores++; | |
| } | |
| else if (!Unity.CurrentTestFailed) | |
| { | |
| UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber); | |
| UnityPrint(UnityStrPass); | |
| } | |
| else | |
| { | |
| Unity.TestFailures++; | |
| } | |
| Unity.CurrentTestFailed = 0; | |
| Unity.CurrentTestIgnored = 0; | |
| UNITY_PRINT_EOL(); | |
| UNITY_FLUSH_CALL(); | |
| } | |
| /*-----------------------------------------------*/ | |
| static void UnityAddMsgIfSpecified(const char* msg) | |
| { | |
| if (msg) | |
| { | |
| UnityPrint(UnityStrSpacer); | |
| #ifndef UNITY_EXCLUDE_DETAILS | |
| if (Unity.CurrentDetail1) | |
| { | |
| UnityPrint(UnityStrDetail1Name); | |
| UnityPrint(Unity.CurrentDetail1); | |
| if (Unity.CurrentDetail2) | |
| { | |
| UnityPrint(UnityStrDetail2Name); | |
| UnityPrint(Unity.CurrentDetail2); | |
| } | |
| UnityPrint(UnityStrSpacer); | |
| } | |
| #endif | |
| UnityPrint(msg); | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual) | |
| { | |
| UnityPrint(UnityStrExpected); | |
| if (expected != NULL) | |
| { | |
| UNITY_OUTPUT_CHAR('\''); | |
| UnityPrint(expected); | |
| UNITY_OUTPUT_CHAR('\''); | |
| } | |
| else | |
| { | |
| UnityPrint(UnityStrNull); | |
| } | |
| UnityPrint(UnityStrWas); | |
| if (actual != NULL) | |
| { | |
| UNITY_OUTPUT_CHAR('\''); | |
| UnityPrint(actual); | |
| UNITY_OUTPUT_CHAR('\''); | |
| } | |
| else | |
| { | |
| UnityPrint(UnityStrNull); | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| static void UnityPrintExpectedAndActualStringsLen(const char* expected, | |
| const char* actual, | |
| const UNITY_UINT32 length) | |
| { | |
| UnityPrint(UnityStrExpected); | |
| if (expected != NULL) | |
| { | |
| UNITY_OUTPUT_CHAR('\''); | |
| UnityPrintLen(expected, length); | |
| UNITY_OUTPUT_CHAR('\''); | |
| } | |
| else | |
| { | |
| UnityPrint(UnityStrNull); | |
| } | |
| UnityPrint(UnityStrWas); | |
| if (actual != NULL) | |
| { | |
| UNITY_OUTPUT_CHAR('\''); | |
| UnityPrintLen(actual, length); | |
| UNITY_OUTPUT_CHAR('\''); | |
| } | |
| else | |
| { | |
| UnityPrint(UnityStrNull); | |
| } | |
| } | |
| /*----------------------------------------------- | |
| * Assertion & Control Helpers | |
| *-----------------------------------------------*/ | |
| static int UnityIsOneArrayNull(UNITY_INTERNAL_PTR expected, | |
| UNITY_INTERNAL_PTR actual, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const char* msg) | |
| { | |
| if (expected == actual) return 0; /* Both are NULL or same pointer */ | |
| /* print and return true if just expected is NULL */ | |
| if (expected == NULL) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrNullPointerForExpected); | |
| UnityAddMsgIfSpecified(msg); | |
| return 1; | |
| } | |
| /* print and return true if just actual is NULL */ | |
| if (actual == NULL) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrNullPointerForActual); | |
| UnityAddMsgIfSpecified(msg); | |
| return 1; | |
| } | |
| return 0; /* return false if neither is NULL */ | |
| } | |
| /*----------------------------------------------- | |
| * Assertion Functions | |
| *-----------------------------------------------*/ | |
| void UnityAssertBits(const UNITY_INT mask, | |
| const UNITY_INT expected, | |
| const UNITY_INT actual, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber) | |
| { | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| if ((mask & expected) != (mask & actual)) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrExpected); | |
| UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)expected); | |
| UnityPrint(UnityStrWas); | |
| UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)actual); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertEqualNumber(const UNITY_INT expected, | |
| const UNITY_INT actual, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const UNITY_DISPLAY_STYLE_T style) | |
| { | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| if (expected != actual) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrExpected); | |
| UnityPrintNumberByStyle(expected, style); | |
| UnityPrint(UnityStrWas); | |
| UnityPrintNumberByStyle(actual, style); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold, | |
| const UNITY_INT actual, | |
| const UNITY_COMPARISON_T compare, | |
| const char *msg, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const UNITY_DISPLAY_STYLE_T style) | |
| { | |
| int failed = 0; | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| if (threshold == actual && compare & UNITY_EQUAL_TO) return; | |
| if (threshold == actual) failed = 1; | |
| if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) | |
| { | |
| if (actual > threshold && compare & UNITY_SMALLER_THAN) failed = 1; | |
| if (actual < threshold && compare & UNITY_GREATER_THAN) failed = 1; | |
| } | |
| else /* UINT or HEX */ | |
| { | |
| if ((UNITY_UINT)actual > (UNITY_UINT)threshold && compare & UNITY_SMALLER_THAN) failed = 1; | |
| if ((UNITY_UINT)actual < (UNITY_UINT)threshold && compare & UNITY_GREATER_THAN) failed = 1; | |
| } | |
| if (failed) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrExpected); | |
| UnityPrintNumberByStyle(actual, style); | |
| if (compare & UNITY_GREATER_THAN) UnityPrint(UnityStrGt); | |
| if (compare & UNITY_SMALLER_THAN) UnityPrint(UnityStrLt); | |
| if (compare & UNITY_EQUAL_TO) UnityPrint(UnityStrOrEqual); | |
| UnityPrintNumberByStyle(threshold, style); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } | |
| #define UnityPrintPointlessAndBail() \ | |
| { \ | |
| UnityTestResultsFailBegin(lineNumber); \ | |
| UnityPrint(UnityStrPointless); \ | |
| UnityAddMsgIfSpecified(msg); \ | |
| UNITY_FAIL_AND_BAIL; } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, | |
| UNITY_INTERNAL_PTR actual, | |
| const UNITY_UINT32 num_elements, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const UNITY_DISPLAY_STYLE_T style, | |
| const UNITY_FLAGS_T flags) | |
| { | |
| UNITY_UINT32 elements = num_elements; | |
| unsigned int length = style & 0xF; | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| if (num_elements == 0) | |
| { | |
| UnityPrintPointlessAndBail(); | |
| } | |
| if (expected == actual) return; /* Both are NULL or same pointer */ | |
| if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) | |
| UNITY_FAIL_AND_BAIL; | |
| while ((elements > 0) && elements--) | |
| { | |
| UNITY_INT expect_val = 0; | |
| UNITY_INT actual_val = 0; | |
| switch (length) | |
| { | |
| case 1: | |
| expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected; | |
| actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual; | |
| break; | |
| case 2: | |
| expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected; | |
| actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual; | |
| break; | |
| #ifdef UNITY_SUPPORT_64 | |
| case 8: | |
| expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected; | |
| actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual; | |
| break; | |
| #endif | |
| default: /* length 4 bytes */ | |
| expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected; | |
| actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual; | |
| length = 4; | |
| break; | |
| } | |
| if (expect_val != actual_val) | |
| { | |
| if (style & UNITY_DISPLAY_RANGE_UINT && length < sizeof(expect_val)) | |
| { /* For UINT, remove sign extension (padding 1's) from signed type casts above */ | |
| UNITY_INT mask = 1; | |
| mask = (mask << 8 * length) - 1; | |
| expect_val &= mask; | |
| actual_val &= mask; | |
| } | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrElement); | |
| UnityPrintNumberUnsigned(num_elements - elements - 1); | |
| UnityPrint(UnityStrExpected); | |
| UnityPrintNumberByStyle(expect_val, style); | |
| UnityPrint(UnityStrWas); | |
| UnityPrintNumberByStyle(actual_val, style); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| if (flags == UNITY_ARRAY_TO_ARRAY) | |
| { | |
| expected = (UNITY_INTERNAL_PTR)(length + (const char*)expected); | |
| } | |
| actual = (UNITY_INTERNAL_PTR)(length + (const char*)actual); | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| #ifndef UNITY_EXCLUDE_FLOAT | |
| /* Wrap this define in a function with variable types as float or double */ | |
| #define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff) \ | |
| if (isinf(expected) && isinf(actual) && (((expected) < 0) == ((actual) < 0))) return 1; \ | |
| if (UNITY_NAN_CHECK) return 1; \ | |
| (diff) = (actual) - (expected); \ | |
| if ((diff) < 0) (diff) = -(diff); \ | |
| if ((delta) < 0) (delta) = -(delta); \ | |
| return !(isnan(diff) || isinf(diff) || ((diff) > (delta))) | |
| /* This first part of this condition will catch any NaN or Infinite values */ | |
| #ifndef UNITY_NAN_NOT_EQUAL_NAN | |
| #define UNITY_NAN_CHECK isnan(expected) && isnan(actual) | |
| #else | |
| #define UNITY_NAN_CHECK 0 | |
| #endif | |
| #ifndef UNITY_EXCLUDE_FLOAT_PRINT | |
| #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ | |
| { \ | |
| UnityPrint(UnityStrExpected); \ | |
| UnityPrintFloat(expected); \ | |
| UnityPrint(UnityStrWas); \ | |
| UnityPrintFloat(actual); } | |
| #else | |
| #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \ | |
| UnityPrint(UnityStrDelta) | |
| #endif /* UNITY_EXCLUDE_FLOAT_PRINT */ | |
| static int UnityFloatsWithin(UNITY_FLOAT delta, UNITY_FLOAT expected, UNITY_FLOAT actual) | |
| { | |
| UNITY_FLOAT diff; | |
| UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); | |
| } | |
| void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, | |
| UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, | |
| const UNITY_UINT32 num_elements, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const UNITY_FLAGS_T flags) | |
| { | |
| UNITY_UINT32 elements = num_elements; | |
| UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_expected = expected; | |
| UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_actual = actual; | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| if (elements == 0) | |
| { | |
| UnityPrintPointlessAndBail(); | |
| } | |
| if (expected == actual) return; /* Both are NULL or same pointer */ | |
| if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) | |
| UNITY_FAIL_AND_BAIL; | |
| while (elements--) | |
| { | |
| if (!UnityFloatsWithin(*ptr_expected * UNITY_FLOAT_PRECISION, *ptr_expected, *ptr_actual)) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrElement); | |
| UnityPrintNumberUnsigned(num_elements - elements - 1); | |
| UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)*ptr_expected, (UNITY_DOUBLE)*ptr_actual); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| if (flags == UNITY_ARRAY_TO_ARRAY) | |
| { | |
| ptr_expected++; | |
| } | |
| ptr_actual++; | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertFloatsWithin(const UNITY_FLOAT delta, | |
| const UNITY_FLOAT expected, | |
| const UNITY_FLOAT actual, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber) | |
| { | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| if (!UnityFloatsWithin(delta, expected, actual)) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)expected, (UNITY_DOUBLE)actual); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertFloatSpecial(const UNITY_FLOAT actual, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const UNITY_FLOAT_TRAIT_T style) | |
| { | |
| const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet}; | |
| UNITY_INT should_be_trait = ((UNITY_INT)style & 1); | |
| UNITY_INT is_trait = !should_be_trait; | |
| UNITY_INT trait_index = (UNITY_INT)(style >> 1); | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| switch (style) | |
| { | |
| case UNITY_FLOAT_IS_INF: | |
| case UNITY_FLOAT_IS_NOT_INF: | |
| is_trait = isinf(actual) && (actual > 0); | |
| break; | |
| case UNITY_FLOAT_IS_NEG_INF: | |
| case UNITY_FLOAT_IS_NOT_NEG_INF: | |
| is_trait = isinf(actual) && (actual < 0); | |
| break; | |
| case UNITY_FLOAT_IS_NAN: | |
| case UNITY_FLOAT_IS_NOT_NAN: | |
| is_trait = isnan(actual) ? 1 : 0; | |
| break; | |
| case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */ | |
| case UNITY_FLOAT_IS_NOT_DET: | |
| is_trait = !isinf(actual) && !isnan(actual); | |
| break; | |
| default: | |
| trait_index = 0; | |
| trait_names[0] = UnityStrInvalidFloatTrait; | |
| break; | |
| } | |
| if (is_trait != should_be_trait) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrExpected); | |
| if (!should_be_trait) | |
| UnityPrint(UnityStrNot); | |
| UnityPrint(trait_names[trait_index]); | |
| UnityPrint(UnityStrWas); | |
| #ifndef UNITY_EXCLUDE_FLOAT_PRINT | |
| UnityPrintFloat((UNITY_DOUBLE)actual); | |
| #else | |
| if (should_be_trait) | |
| UnityPrint(UnityStrNot); | |
| UnityPrint(trait_names[trait_index]); | |
| #endif | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } | |
| #endif /* not UNITY_EXCLUDE_FLOAT */ | |
| /*-----------------------------------------------*/ | |
| #ifndef UNITY_EXCLUDE_DOUBLE | |
| static int UnityDoublesWithin(UNITY_DOUBLE delta, UNITY_DOUBLE expected, UNITY_DOUBLE actual) | |
| { | |
| UNITY_DOUBLE diff; | |
| UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); | |
| } | |
| void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, | |
| UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, | |
| const UNITY_UINT32 num_elements, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const UNITY_FLAGS_T flags) | |
| { | |
| UNITY_UINT32 elements = num_elements; | |
| UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_expected = expected; | |
| UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_actual = actual; | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| if (elements == 0) | |
| { | |
| UnityPrintPointlessAndBail(); | |
| } | |
| if (expected == actual) return; /* Both are NULL or same pointer */ | |
| if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) | |
| UNITY_FAIL_AND_BAIL; | |
| while (elements--) | |
| { | |
| if (!UnityDoublesWithin(*ptr_expected * UNITY_DOUBLE_PRECISION, *ptr_expected, *ptr_actual)) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrElement); | |
| UnityPrintNumberUnsigned(num_elements - elements - 1); | |
| UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(*ptr_expected, *ptr_actual); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| if (flags == UNITY_ARRAY_TO_ARRAY) | |
| { | |
| ptr_expected++; | |
| } | |
| ptr_actual++; | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, | |
| const UNITY_DOUBLE expected, | |
| const UNITY_DOUBLE actual, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber) | |
| { | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| if (!UnityDoublesWithin(delta, expected, actual)) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const UNITY_FLOAT_TRAIT_T style) | |
| { | |
| const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet}; | |
| UNITY_INT should_be_trait = ((UNITY_INT)style & 1); | |
| UNITY_INT is_trait = !should_be_trait; | |
| UNITY_INT trait_index = (UNITY_INT)(style >> 1); | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| switch (style) | |
| { | |
| case UNITY_FLOAT_IS_INF: | |
| case UNITY_FLOAT_IS_NOT_INF: | |
| is_trait = isinf(actual) && (actual > 0); | |
| break; | |
| case UNITY_FLOAT_IS_NEG_INF: | |
| case UNITY_FLOAT_IS_NOT_NEG_INF: | |
| is_trait = isinf(actual) && (actual < 0); | |
| break; | |
| case UNITY_FLOAT_IS_NAN: | |
| case UNITY_FLOAT_IS_NOT_NAN: | |
| is_trait = isnan(actual) ? 1 : 0; | |
| break; | |
| case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */ | |
| case UNITY_FLOAT_IS_NOT_DET: | |
| is_trait = !isinf(actual) && !isnan(actual); | |
| break; | |
| default: | |
| trait_index = 0; | |
| trait_names[0] = UnityStrInvalidFloatTrait; | |
| break; | |
| } | |
| if (is_trait != should_be_trait) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrExpected); | |
| if (!should_be_trait) | |
| UnityPrint(UnityStrNot); | |
| UnityPrint(trait_names[trait_index]); | |
| UnityPrint(UnityStrWas); | |
| #ifndef UNITY_EXCLUDE_FLOAT_PRINT | |
| UnityPrintFloat(actual); | |
| #else | |
| if (should_be_trait) | |
| UnityPrint(UnityStrNot); | |
| UnityPrint(trait_names[trait_index]); | |
| #endif | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } | |
| #endif /* not UNITY_EXCLUDE_DOUBLE */ | |
| /*-----------------------------------------------*/ | |
| void UnityAssertNumbersWithin(const UNITY_UINT delta, | |
| const UNITY_INT expected, | |
| const UNITY_INT actual, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const UNITY_DISPLAY_STYLE_T style) | |
| { | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) | |
| { | |
| if (actual > expected) | |
| Unity.CurrentTestFailed = (UNITY_UINT)((UNITY_UINT)(actual - expected) > delta); | |
| else | |
| Unity.CurrentTestFailed = (UNITY_UINT)((UNITY_UINT)(expected - actual) > delta); | |
| } | |
| else | |
| { | |
| if ((UNITY_UINT)actual > (UNITY_UINT)expected) | |
| Unity.CurrentTestFailed = (UNITY_UINT)((UNITY_UINT)(actual - expected) > delta); | |
| else | |
| Unity.CurrentTestFailed = (UNITY_UINT)((UNITY_UINT)(expected - actual) > delta); | |
| } | |
| if (Unity.CurrentTestFailed) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrDelta); | |
| UnityPrintNumberByStyle((UNITY_INT)delta, style); | |
| UnityPrint(UnityStrExpected); | |
| UnityPrintNumberByStyle(expected, style); | |
| UnityPrint(UnityStrWas); | |
| UnityPrintNumberByStyle(actual, style); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertEqualString(const char* expected, | |
| const char* actual, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber) | |
| { | |
| UNITY_UINT32 i; | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| /* if both pointers not null compare the strings */ | |
| if (expected && actual) | |
| { | |
| for (i = 0; expected[i] || actual[i]; i++) | |
| { | |
| if (expected[i] != actual[i]) | |
| { | |
| Unity.CurrentTestFailed = 1; | |
| break; | |
| } | |
| } | |
| } | |
| else | |
| { /* handle case of one pointers being null (if both null, test should pass) */ | |
| if (expected != actual) | |
| { | |
| Unity.CurrentTestFailed = 1; | |
| } | |
| } | |
| if (Unity.CurrentTestFailed) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrintExpectedAndActualStrings(expected, actual); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertEqualStringLen(const char* expected, | |
| const char* actual, | |
| const UNITY_UINT32 length, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber) | |
| { | |
| UNITY_UINT32 i; | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| /* if both pointers not null compare the strings */ | |
| if (expected && actual) | |
| { | |
| for (i = 0; (i < length) && (expected[i] || actual[i]); i++) | |
| { | |
| if (expected[i] != actual[i]) | |
| { | |
| Unity.CurrentTestFailed = 1; | |
| break; | |
| } | |
| } | |
| } | |
| else | |
| { /* handle case of one pointers being null (if both null, test should pass) */ | |
| if (expected != actual) | |
| { | |
| Unity.CurrentTestFailed = 1; | |
| } | |
| } | |
| if (Unity.CurrentTestFailed) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrintExpectedAndActualStringsLen(expected, actual, length); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected, | |
| const char** actual, | |
| const UNITY_UINT32 num_elements, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const UNITY_FLAGS_T flags) | |
| { | |
| UNITY_UINT32 i = 0; | |
| UNITY_UINT32 j = 0; | |
| const char* expd = NULL; | |
| const char* act = NULL; | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| /* if no elements, it's an error */ | |
| if (num_elements == 0) | |
| { | |
| UnityPrintPointlessAndBail(); | |
| } | |
| if ((const void*)expected == (const void*)actual) | |
| { | |
| return; /* Both are NULL or same pointer */ | |
| } | |
| if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg)) | |
| { | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| if (flags != UNITY_ARRAY_TO_ARRAY) | |
| { | |
| expd = (const char*)expected; | |
| } | |
| do | |
| { | |
| act = actual[j]; | |
| if (flags == UNITY_ARRAY_TO_ARRAY) | |
| { | |
| expd = ((const char* const*)expected)[j]; | |
| } | |
| /* if both pointers not null compare the strings */ | |
| if (expd && act) | |
| { | |
| for (i = 0; expd[i] || act[i]; i++) | |
| { | |
| if (expd[i] != act[i]) | |
| { | |
| Unity.CurrentTestFailed = 1; | |
| break; | |
| } | |
| } | |
| } | |
| else | |
| { /* handle case of one pointers being null (if both null, test should pass) */ | |
| if (expd != act) | |
| { | |
| Unity.CurrentTestFailed = 1; | |
| } | |
| } | |
| if (Unity.CurrentTestFailed) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| if (num_elements > 1) | |
| { | |
| UnityPrint(UnityStrElement); | |
| UnityPrintNumberUnsigned(j); | |
| } | |
| UnityPrintExpectedAndActualStrings(expd, act); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| } while (++j < num_elements); | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityAssertEqualMemory(UNITY_INTERNAL_PTR expected, | |
| UNITY_INTERNAL_PTR actual, | |
| const UNITY_UINT32 length, | |
| const UNITY_UINT32 num_elements, | |
| const char* msg, | |
| const UNITY_LINE_TYPE lineNumber, | |
| const UNITY_FLAGS_T flags) | |
| { | |
| UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; | |
| UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual; | |
| UNITY_UINT32 elements = num_elements; | |
| UNITY_UINT32 bytes; | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| if ((elements == 0) || (length == 0)) | |
| { | |
| UnityPrintPointlessAndBail(); | |
| } | |
| if (expected == actual) return; /* Both are NULL or same pointer */ | |
| if (UnityIsOneArrayNull(expected, actual, lineNumber, msg)) | |
| UNITY_FAIL_AND_BAIL; | |
| while (elements--) | |
| { | |
| bytes = length; | |
| while (bytes--) | |
| { | |
| if (*ptr_exp != *ptr_act) | |
| { | |
| UnityTestResultsFailBegin(lineNumber); | |
| UnityPrint(UnityStrMemory); | |
| if (num_elements > 1) | |
| { | |
| UnityPrint(UnityStrElement); | |
| UnityPrintNumberUnsigned(num_elements - elements - 1); | |
| } | |
| UnityPrint(UnityStrByte); | |
| UnityPrintNumberUnsigned(length - bytes - 1); | |
| UnityPrint(UnityStrExpected); | |
| UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8); | |
| UnityPrint(UnityStrWas); | |
| UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8); | |
| UnityAddMsgIfSpecified(msg); | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| ptr_exp++; | |
| ptr_act++; | |
| } | |
| if (flags == UNITY_ARRAY_TO_VAL) | |
| { | |
| ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; | |
| } | |
| } | |
| } | |
| /*-----------------------------------------------*/ | |
| static union | |
| { | |
| UNITY_INT8 i8; | |
| UNITY_INT16 i16; | |
| UNITY_INT32 i32; | |
| #ifdef UNITY_SUPPORT_64 | |
| UNITY_INT64 i64; | |
| #endif | |
| #ifndef UNITY_EXCLUDE_FLOAT | |
| float f; | |
| #endif | |
| #ifndef UNITY_EXCLUDE_DOUBLE | |
| double d; | |
| #endif | |
| } UnityQuickCompare; | |
| UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size) | |
| { | |
| switch(size) | |
| { | |
| case 1: | |
| UnityQuickCompare.i8 = (UNITY_INT8)num; | |
| return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i8); | |
| case 2: | |
| UnityQuickCompare.i16 = (UNITY_INT16)num; | |
| return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i16); | |
| #ifdef UNITY_SUPPORT_64 | |
| case 8: | |
| UnityQuickCompare.i64 = (UNITY_INT64)num; | |
| return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i64); | |
| #endif | |
| default: /* 4 bytes */ | |
| UnityQuickCompare.i32 = (UNITY_INT32)num; | |
| return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i32); | |
| } | |
| } | |
| #ifndef UNITY_EXCLUDE_FLOAT | |
| UNITY_INTERNAL_PTR UnityFloatToPtr(const float num) | |
| { | |
| UnityQuickCompare.f = num; | |
| return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.f); | |
| } | |
| #endif | |
| #ifndef UNITY_EXCLUDE_DOUBLE | |
| UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num) | |
| { | |
| UnityQuickCompare.d = num; | |
| return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.d); | |
| } | |
| #endif | |
| /*----------------------------------------------- | |
| * Control Functions | |
| *-----------------------------------------------*/ | |
| void UnityFail(const char* msg, const UNITY_LINE_TYPE line) | |
| { | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| UnityAddin_SetMessage(msg, line); | |
| UnityTestResultsBegin(Unity.TestFile, line); | |
| UnityPrint(UnityStrFail); | |
| if (msg != NULL) | |
| { | |
| UNITY_OUTPUT_CHAR(':'); | |
| #ifndef UNITY_EXCLUDE_DETAILS | |
| if (Unity.CurrentDetail1) | |
| { | |
| UnityPrint(UnityStrDetail1Name); | |
| UnityPrint(Unity.CurrentDetail1); | |
| if (Unity.CurrentDetail2) | |
| { | |
| UnityPrint(UnityStrDetail2Name); | |
| UnityPrint(Unity.CurrentDetail2); | |
| } | |
| UnityPrint(UnityStrSpacer); | |
| } | |
| #endif | |
| if (msg[0] != ' ') | |
| { | |
| UNITY_OUTPUT_CHAR(' '); | |
| } | |
| UnityPrint(msg); | |
| } | |
| UNITY_FAIL_AND_BAIL; | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line) | |
| { | |
| RETURN_IF_FAIL_OR_IGNORE; | |
| UnityTestResultsBegin(Unity.TestFile, line); | |
| UnityPrint(UnityStrIgnore); | |
| if (msg != NULL) | |
| { | |
| UNITY_OUTPUT_CHAR(':'); | |
| UNITY_OUTPUT_CHAR(' '); | |
| UnityPrint(msg); | |
| UnityAddin_SetMessage(msg, line); | |
| } | |
| UNITY_IGNORE_AND_BAIL; | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum) | |
| { | |
| Unity.CurrentTestName = FuncName; | |
| Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum; | |
| Unity.NumberOfTests++; | |
| UNITY_CLR_DETAILS(); | |
| if (TEST_PROTECT()) | |
| { | |
| setUp(); | |
| Func(); | |
| } | |
| if (TEST_PROTECT()) | |
| { | |
| tearDown(); | |
| } | |
| UnityConcludeTest(); | |
| } | |
| /*-----------------------------------------------*/ | |
| void UnityBegin(const char* filename) | |
| { | |
| Unity.TestFile = filename; | |
| Unity.CurrentTestName = NULL; | |
| Unity.CurrentTestLineNumber = 0; | |
| Unity.NumberOfTests = 0; | |
| Unity.TestFailures = 0; | |
| Unity.TestIgnores = 0; | |
| Unity.CurrentTestFailed = 0; | |
| Unity.CurrentTestIgnored = 0; | |
| UNITY_CLR_DETAILS(); | |
| UNITY_OUTPUT_START(); | |
| } | |
| /*-----------------------------------------------*/ | |
| int UnityEnd(void) | |
| { | |
| UNITY_PRINT_EOL(); | |
| UnityPrint(UnityStrBreaker); | |
| UNITY_PRINT_EOL(); | |
| UnityPrintNumber((UNITY_INT)(Unity.NumberOfTests)); | |
| UnityPrint(UnityStrResultsTests); | |
| UnityPrintNumber((UNITY_INT)(Unity.TestFailures)); | |
| UnityPrint(UnityStrResultsFailures); | |
| UnityPrintNumber((UNITY_INT)(Unity.TestIgnores)); | |
| UnityPrint(UnityStrResultsIgnored); | |
| UNITY_PRINT_EOL(); | |
| if (Unity.TestFailures == 0U) | |
| { | |
| UnityPrint(UnityStrOk); | |
| } | |
| else | |
| { | |
| UnityPrint(UnityStrFail); | |
| #ifdef UNITY_DIFFERENTIATE_FINAL_FAIL | |
| UNITY_OUTPUT_CHAR('E'); UNITY_OUTPUT_CHAR('D'); | |
| #endif | |
| } | |
| UNITY_PRINT_EOL(); | |
| UNITY_FLUSH_CALL(); | |
| UNITY_OUTPUT_COMPLETE(); | |
| return (int)(Unity.TestFailures); | |
| } | |
| /*----------------------------------------------- | |
| * Command Line Argument Support | |
| *-----------------------------------------------*/ | |
| #ifdef UNITY_USE_COMMAND_LINE_ARGS | |
| char* UnityOptionIncludeNamed = NULL; | |
| char* UnityOptionExcludeNamed = NULL; | |
| int UnityVerbosity = 1; | |
| int UnityParseOptions(int argc, char** argv) | |
| { | |
| UnityOptionIncludeNamed = NULL; | |
| UnityOptionExcludeNamed = NULL; | |
| for (int i = 1; i < argc; i++) | |
| { | |
| if (argv[i][0] == '-') | |
| { | |
| switch (argv[i][1]) | |
| { | |
| case 'l': /* list tests */ | |
| return -1; | |
| case 'n': /* include tests with name including this string */ | |
| case 'f': /* an alias for -n */ | |
| if (argv[i][2] == '=') | |
| UnityOptionIncludeNamed = &argv[i][3]; | |
| else if (++i < argc) | |
| UnityOptionIncludeNamed = argv[i]; | |
| else | |
| { | |
| UnityPrint("ERROR: No Test String to Include Matches For"); | |
| UNITY_PRINT_EOL(); | |
| return 1; | |
| } | |
| break; | |
| case 'q': /* quiet */ | |
| UnityVerbosity = 0; | |
| break; | |
| case 'v': /* verbose */ | |
| UnityVerbosity = 2; | |
| break; | |
| case 'x': /* exclude tests with name including this string */ | |
| if (argv[i][2] == '=') | |
| UnityOptionExcludeNamed = &argv[i][3]; | |
| else if (++i < argc) | |
| UnityOptionExcludeNamed = argv[i]; | |
| else | |
| { | |
| UnityPrint("ERROR: No Test String to Exclude Matches For"); | |
| UNITY_PRINT_EOL(); | |
| return 1; | |
| } | |
| break; | |
| default: | |
| UnityPrint("ERROR: Unknown Option "); | |
| UNITY_OUTPUT_CHAR(argv[i][1]); | |
| UNITY_PRINT_EOL(); | |
| return 1; | |
| } | |
| } | |
| } | |
| return 0; | |
| } | |
| int IsStringInBiggerString(const char* longstring, const char* shortstring) | |
| { | |
| const char* lptr = longstring; | |
| const char* sptr = shortstring; | |
| const char* lnext = lptr; | |
| if (*sptr == '*') | |
| return 1; | |
| while (*lptr) | |
| { | |
| lnext = lptr + 1; | |
| /* If they current bytes match, go on to the next bytes */ | |
| while (*lptr && *sptr && (*lptr == *sptr)) | |
| { | |
| lptr++; | |
| sptr++; | |
| /* We're done if we match the entire string or up to a wildcard */ | |
| if (*sptr == '*') | |
| return 1; | |
| if (*sptr == ',') | |
| return 1; | |
| if (*sptr == '"') | |
| return 1; | |
| if (*sptr == '\'') | |
| return 1; | |
| if (*sptr == ':') | |
| return 2; | |
| if (*sptr == 0) | |
| return 1; | |
| } | |
| /* Otherwise we start in the long pointer 1 character further and try again */ | |
| lptr = lnext; | |
| sptr = shortstring; | |
| } | |
| return 0; | |
| } | |
| int UnityStringArgumentMatches(const char* str) | |
| { | |
| int retval; | |
| const char* ptr1; | |
| const char* ptr2; | |
| const char* ptrf; | |
| /* Go through the options and get the substrings for matching one at a time */ | |
| ptr1 = str; | |
| while (ptr1[0] != 0) | |
| { | |
| if ((ptr1[0] == '"') || (ptr1[0] == '\'')) | |
| ptr1++; | |
| /* look for the start of the next partial */ | |
| ptr2 = ptr1; | |
| ptrf = 0; | |
| do | |
| { | |
| ptr2++; | |
| if ((ptr2[0] == ':') && (ptr2[1] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ',')) | |
| ptrf = &ptr2[1]; | |
| } while ((ptr2[0] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ',')); | |
| while ((ptr2[0] != 0) && ((ptr2[0] == ':') || (ptr2[0] == '\'') || (ptr2[0] == '"') || (ptr2[0] == ','))) | |
| ptr2++; | |
| /* done if complete filename match */ | |
| retval = IsStringInBiggerString(Unity.TestFile, ptr1); | |
| if (retval == 1) | |
| return retval; | |
| /* done if testname match after filename partial match */ | |
| if ((retval == 2) && (ptrf != 0)) | |
| { | |
| if (IsStringInBiggerString(Unity.CurrentTestName, ptrf)) | |
| return 1; | |
| } | |
| /* done if complete testname match */ | |
| if (IsStringInBiggerString(Unity.CurrentTestName, ptr1) == 1) | |
| return 1; | |
| ptr1 = ptr2; | |
| } | |
| /* we couldn't find a match for any substrings */ | |
| return 0; | |
| } | |
| int UnityTestMatches(void) | |
| { | |
| /* Check if this test name matches the included test pattern */ | |
| int retval; | |
| if (UnityOptionIncludeNamed) | |
| { | |
| retval = UnityStringArgumentMatches(UnityOptionIncludeNamed); | |
| } | |
| else | |
| retval = 1; | |
| /* Check if this test name matches the excluded test pattern */ | |
| if (UnityOptionExcludeNamed) | |
| { | |
| if (UnityStringArgumentMatches(UnityOptionExcludeNamed)) | |
| retval = 0; | |
| } | |
| return retval; | |
| } | |
| #endif /* UNITY_USE_COMMAND_LINE_ARGS */ | |
| /*-----------------------------------------------*/ |