unity.c

00001 /* =========================================================================
00002     Unity Project - A Test Framework for C
00003     Copyright (c) 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams
00004     [Released under MIT License. Please refer to license.txt for details]
00005 ============================================================================ */
00006 
00007 #include "unity/unity.h"
00008 #include "utest/unity_handler.h"
00009 #include <stddef.h>
00010 
00011 /* If omitted from header, declare overrideable prototypes here so they're ready for use */
00012 #ifdef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION
00013 int UNITY_OUTPUT_CHAR(int);
00014 #endif
00015 #ifdef UNITY_OMIT_OUTPUT_FLUSH_HEADER_DECLARATION
00016 int UNITY_OUTPUT_FLUSH(void);
00017 #endif
00018 
00019 /* Helpful macros for us to use here */
00020 #define UNITY_FAIL_AND_BAIL   { UNITY_OUTPUT_CHAR('\n'); utest_unity_assert_failure(); }
00021 #define UNITY_IGNORE_AND_BAIL { UNITY_OUTPUT_CHAR('\n'); utest_unity_ignore_failure(); }
00022 
00023 /* return prematurely if we are already in failure or ignore state */
00024 #define UNITY_SKIP_EXECUTION  { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} }
00025 
00026 struct _Unity Unity;
00027 
00028 static const char UnityStrOk[]                     = "OK";
00029 static const char UnityStrPass[]                   = "PASS";
00030 static const char UnityStrFail[]                   = "FAIL";
00031 static const char UnityStrIgnore[]                 = "IGNORE";
00032 static const char UnityStrNull[]                   = "NULL";
00033 static const char UnityStrSpacer[]                 = ". ";
00034 static const char UnityStrExpected[]               = " Expected ";
00035 static const char UnityStrWas[]                    = " Was ";
00036 static const char UnityStrElement[]                = " Element ";
00037 static const char UnityStrByte[]                   = " Byte ";
00038 static const char UnityStrMemory[]                 = " Memory Mismatch.";
00039 static const char UnityStrDelta[]                  = " Values Not Within Delta ";
00040 static const char UnityStrPointless[]              = " You Asked Me To Compare Nothing, Which Was Pointless.";
00041 static const char UnityStrNullPointerForExpected[] = " Expected pointer to be NULL";
00042 static const char UnityStrNullPointerForActual[]   = " Actual pointer was NULL";
00043 static const char UnityStrNot[]                    = "Not ";
00044 static const char UnityStrInf[]                    = "Infinity";
00045 static const char UnityStrNegInf[]                 = "Negative Infinity";
00046 static const char UnityStrNaN[]                    = "NaN";
00047 static const char UnityStrDet[]                    = "Determinate";
00048 static const char UnityStrInvalidFloatTrait[]      = "Invalid Float Trait";
00049 const char UnityStrErrFloat[]                      = "Unity Floating Point Disabled";
00050 const char UnityStrErrDouble[]                     = "Unity Double Precision Disabled";
00051 const char UnityStrErr64[]                         = "Unity 64-bit Support Disabled";
00052 static const char UnityStrBreaker[]                = "-----------------------";
00053 static const char UnityStrResultsTests[]           = " Tests ";
00054 static const char UnityStrResultsFailures[]        = " Failures ";
00055 static const char UnityStrResultsIgnored[]         = " Ignored ";
00056 static const char UnityStrDetail1Name[]            = UNITY_DETAIL1_NAME " ";
00057 static const char UnityStrDetail2Name[]            = " " UNITY_DETAIL2_NAME " ";
00058 
00059 #ifdef UNITY_FLOAT_NEEDS_ZERO
00060 /* Dividing by these constants produces +/- infinity.
00061  * The rationale is given in UnityAssertFloatIsInf's body. */
00062 static const _UF f_zero = 0.0f;
00063 #endif
00064 
00065 /* compiler-generic print formatting masks */
00066 static const _U_UINT UnitySizeMask[] =
00067 {
00068     255u,         /* 0xFF */
00069     65535u,       /* 0xFFFF */
00070     65535u,
00071     4294967295u,  /* 0xFFFFFFFF */
00072     4294967295u,
00073     4294967295u,
00074     4294967295u
00075 #ifdef UNITY_SUPPORT_64
00076     ,0xFFFFFFFFFFFFFFFFull
00077 #endif
00078 };
00079 
00080 /*-----------------------------------------------
00081  * Pretty Printers & Test Result Output Handlers
00082  *-----------------------------------------------*/
00083 
00084 void UnityPrint(const char* string)
00085 {
00086     const char* pch = string;
00087 
00088     if (pch != NULL)
00089     {
00090         while (*pch)
00091         {
00092             /* printable characters plus CR & LF are printed */
00093             if ((*pch <= 126) && (*pch >= 32))
00094             {
00095                 UNITY_OUTPUT_CHAR(*pch);
00096             }
00097             /* write escaped carriage returns */
00098             else if (*pch == 13)
00099             {
00100                 UNITY_OUTPUT_CHAR('\\');
00101                 UNITY_OUTPUT_CHAR('r');
00102             }
00103             /* write escaped line feeds */
00104             else if (*pch == 10)
00105             {
00106                 UNITY_OUTPUT_CHAR('\\');
00107                 UNITY_OUTPUT_CHAR('n');
00108             }
00109             /* unprintable characters are shown as codes */
00110             else
00111             {
00112                 UNITY_OUTPUT_CHAR('\\');
00113                 UnityPrintNumberHex((_U_UINT)*pch, 2);
00114             }
00115             pch++;
00116         }
00117     }
00118 }
00119 
00120 void UnityPrintLen(const char* string, const _UU32 length);
00121 void UnityPrintLen(const char* string, const _UU32 length)
00122 {
00123     const char* pch = string;
00124 
00125     if (pch != NULL)
00126     {
00127         while (*pch && (_UU32)(pch - string) < length)
00128         {
00129             /* printable characters plus CR & LF are printed */
00130             if ((*pch <= 126) && (*pch >= 32))
00131             {
00132                 UNITY_OUTPUT_CHAR(*pch);
00133             }
00134             /* write escaped carriage returns */
00135             else if (*pch == 13)
00136             {
00137                 UNITY_OUTPUT_CHAR('\\');
00138                 UNITY_OUTPUT_CHAR('r');
00139             }
00140             /* write escaped line feeds */
00141             else if (*pch == 10)
00142             {
00143                 UNITY_OUTPUT_CHAR('\\');
00144                 UNITY_OUTPUT_CHAR('n');
00145             }
00146             /* unprintable characters are shown as codes */
00147             else
00148             {
00149                 UNITY_OUTPUT_CHAR('\\');
00150                 UnityPrintNumberHex((_U_UINT)*pch, 2);
00151             }
00152             pch++;
00153         }
00154     }
00155 }
00156 
00157 /*-----------------------------------------------*/
00158 void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style)
00159 {
00160     if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
00161     {
00162         UnityPrintNumber(number);
00163     }
00164     else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
00165     {
00166         UnityPrintNumberUnsigned(  (_U_UINT)number  &  UnitySizeMask[((_U_UINT)style & (_U_UINT)0x0F) - 1]  );
00167     }
00168     else
00169     {
00170         UnityPrintNumberHex((_U_UINT)number, (char)((style & 0x000F) << 1));
00171     }
00172 }
00173 
00174 /*-----------------------------------------------*/
00175 void UnityPrintNumber(const _U_SINT number_to_print)
00176 {
00177     _U_UINT number = (_U_UINT)number_to_print;
00178 
00179     if (number_to_print < 0)
00180     {
00181         /* A negative number, including MIN negative */
00182         UNITY_OUTPUT_CHAR('-');
00183         number = (_U_UINT)(-number_to_print);
00184     }
00185     UnityPrintNumberUnsigned(number);
00186 }
00187 
00188 /*-----------------------------------------------
00189  * basically do an itoa using as little ram as possible */
00190 void UnityPrintNumberUnsigned(const _U_UINT number)
00191 {
00192     _U_UINT divisor = 1;
00193 
00194     /* figure out initial divisor */
00195     while (number / divisor > 9)
00196     {
00197         divisor *= 10;
00198     }
00199 
00200     /* now mod and print, then divide divisor */
00201     do
00202     {
00203         UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
00204         divisor /= 10;
00205     }
00206     while (divisor > 0);
00207 }
00208 
00209 /*-----------------------------------------------*/
00210 void UnityPrintNumberHex(const _U_UINT number, const char nibbles_to_print)
00211 {
00212     _U_UINT nibble;
00213     char nibbles = nibbles_to_print;
00214     UNITY_OUTPUT_CHAR('0');
00215     UNITY_OUTPUT_CHAR('x');
00216 
00217     while (nibbles > 0)
00218     {
00219         nibble = (number >> (--nibbles << 2)) & 0x0000000F;
00220         if (nibble <= 9)
00221         {
00222             UNITY_OUTPUT_CHAR((char)('0' + nibble));
00223         }
00224         else
00225         {
00226             UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble));
00227         }
00228     }
00229 }
00230 
00231 /*-----------------------------------------------*/
00232 void UnityPrintMask(const _U_UINT mask, const _U_UINT number)
00233 {
00234     _U_UINT current_bit = (_U_UINT)1 << (UNITY_INT_WIDTH - 1);
00235     _US32 i;
00236 
00237     for (i = 0; i < UNITY_INT_WIDTH; i++)
00238     {
00239         if (current_bit & mask)
00240         {
00241             if (current_bit & number)
00242             {
00243                 UNITY_OUTPUT_CHAR('1');
00244             }
00245             else
00246             {
00247                 UNITY_OUTPUT_CHAR('0');
00248             }
00249         }
00250         else
00251         {
00252             UNITY_OUTPUT_CHAR('.');
00253         }
00254         current_bit = current_bit >> 1;
00255     }
00256 }
00257 
00258 /*-----------------------------------------------*/
00259 #ifdef UNITY_FLOAT_VERBOSE
00260 #include <stdio.h>
00261 
00262 #ifndef UNITY_VERBOSE_NUMBER_MAX_LENGTH
00263 # ifdef UNITY_DOUBLE_VERBOSE
00264 #  define UNITY_VERBOSE_NUMBER_MAX_LENGTH 317
00265 # else
00266 #  define UNITY_VERBOSE_NUMBER_MAX_LENGTH 47
00267 # endif
00268 #endif
00269 
00270 void UnityPrintFloat(_UF number)
00271 {
00272     char TempBuffer[UNITY_VERBOSE_NUMBER_MAX_LENGTH + 1];
00273     snprintf(TempBuffer, sizeof(TempBuffer), "%.6f", number);
00274     UnityPrint(TempBuffer);
00275 }
00276 #endif
00277 
00278 /*-----------------------------------------------*/
00279 
00280 void UnityPrintFail(void);
00281 void UnityPrintFail(void)
00282 {
00283     UnityPrint(UnityStrFail);
00284 }
00285 
00286 void UnityPrintOk(void);
00287 void UnityPrintOk(void)
00288 {
00289     UnityPrint(UnityStrOk);
00290 }
00291 
00292 /*-----------------------------------------------*/
00293 static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line);
00294 static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line)
00295 {
00296 #ifndef UNITY_FIXTURES
00297     UnityPrint(file);
00298     UNITY_OUTPUT_CHAR(':');
00299     UnityPrintNumber((_U_SINT)line);
00300     UNITY_OUTPUT_CHAR(':');
00301     UnityPrint(Unity.CurrentTestName);
00302     UNITY_OUTPUT_CHAR(':');
00303 #else
00304     UNITY_UNUSED(file);
00305     UNITY_UNUSED(line);
00306 #endif
00307 }
00308 
00309 /*-----------------------------------------------*/
00310 static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line);
00311 static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line)
00312 {
00313 #ifndef UNITY_FIXTURES
00314     UnityTestResultsBegin(Unity.TestFile, line);
00315 #else
00316     UNITY_UNUSED(line);
00317 #endif
00318     UnityPrint(UnityStrFail);
00319     UNITY_OUTPUT_CHAR(':');
00320 }
00321 
00322 /*-----------------------------------------------*/
00323 void UnityConcludeTest(void)
00324 {
00325     if (Unity.CurrentTestIgnored)
00326     {
00327         Unity.TestIgnores++;
00328     }
00329     else if (!Unity.CurrentTestFailed)
00330     {
00331         UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber);
00332         UnityPrint(UnityStrPass);
00333     }
00334     else
00335     {
00336         Unity.TestFailures++;
00337     }
00338 
00339     Unity.CurrentTestFailed = 0;
00340     Unity.CurrentTestIgnored = 0;
00341     UNITY_PRINT_EOL();
00342     UNITY_OUTPUT_FLUSH();
00343 }
00344 
00345 /*-----------------------------------------------*/
00346 static void UnityAddMsgIfSpecified(const char* msg);
00347 static void UnityAddMsgIfSpecified(const char* msg)
00348 {
00349     if (msg)
00350     {
00351         UnityPrint(UnityStrSpacer);
00352 #ifndef UNITY_EXCLUDE_DETAILS
00353         if (Unity.CurrentDetail1)
00354         {
00355             UnityPrint(UnityStrDetail1Name);
00356             UnityPrint(Unity.CurrentDetail1);
00357             if (Unity.CurrentDetail2)
00358             {
00359                 UnityPrint(UnityStrDetail2Name);
00360                 UnityPrint(Unity.CurrentDetail2);
00361             }
00362             UnityPrint(UnityStrSpacer);
00363         }
00364 #endif
00365         UnityPrint(msg);
00366     }
00367 }
00368 
00369 /*-----------------------------------------------*/
00370 static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual);
00371 static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual)
00372 {
00373     UnityPrint(UnityStrExpected);
00374     if (expected != NULL)
00375     {
00376         UNITY_OUTPUT_CHAR('\'');
00377         UnityPrint(expected);
00378         UNITY_OUTPUT_CHAR('\'');
00379     }
00380     else
00381     {
00382       UnityPrint(UnityStrNull);
00383     }
00384     UnityPrint(UnityStrWas);
00385     if (actual != NULL)
00386     {
00387         UNITY_OUTPUT_CHAR('\'');
00388         UnityPrint(actual);
00389         UNITY_OUTPUT_CHAR('\'');
00390     }
00391     else
00392     {
00393       UnityPrint(UnityStrNull);
00394     }
00395 }
00396 
00397 /*-----------------------------------------------*/
00398 static void UnityPrintExpectedAndActualStringsLen(const char* expected, const char* actual, const _UU32 length)
00399 {
00400     UnityPrint(UnityStrExpected);
00401     if (expected != NULL)
00402     {
00403         UNITY_OUTPUT_CHAR('\'');
00404         UnityPrintLen(expected, length);
00405         UNITY_OUTPUT_CHAR('\'');
00406     }
00407     else
00408     {
00409       UnityPrint(UnityStrNull);
00410     }
00411     UnityPrint(UnityStrWas);
00412     if (actual != NULL)
00413     {
00414         UNITY_OUTPUT_CHAR('\'');
00415         UnityPrintLen(actual, length);
00416         UNITY_OUTPUT_CHAR('\'');
00417     }
00418     else
00419     {
00420       UnityPrint(UnityStrNull);
00421     }
00422 }
00423 
00424 
00425 
00426 /*-----------------------------------------------
00427  * Assertion & Control Helpers
00428  *-----------------------------------------------*/
00429 
00430 static int UnityCheckArraysForNull(UNITY_INTERNAL_PTR expected, UNITY_INTERNAL_PTR actual, const UNITY_LINE_TYPE lineNumber, const char* msg)
00431 {
00432     /* return true if they are both NULL */
00433     if ((expected == NULL) && (actual == NULL))
00434         return 1;
00435 
00436     /* throw error if just expected is NULL */
00437     if (expected == NULL)
00438     {
00439         UnityTestResultsFailBegin(lineNumber);
00440         UnityPrint(UnityStrNullPointerForExpected);
00441         UnityAddMsgIfSpecified(msg);
00442         UNITY_FAIL_AND_BAIL;
00443     }
00444 
00445     /* throw error if just actual is NULL */
00446     if (actual == NULL)
00447     {
00448         UnityTestResultsFailBegin(lineNumber);
00449         UnityPrint(UnityStrNullPointerForActual);
00450         UnityAddMsgIfSpecified(msg);
00451         UNITY_FAIL_AND_BAIL;
00452     }
00453 
00454     /* return false if neither is NULL */
00455     return 0;
00456 }
00457 
00458 /*-----------------------------------------------
00459  * Assertion Functions
00460  *-----------------------------------------------*/
00461 
00462 void UnityAssertBits(const _U_SINT mask,
00463                      const _U_SINT expected,
00464                      const _U_SINT actual,
00465                      const char* msg,
00466                      const UNITY_LINE_TYPE lineNumber)
00467 {
00468     UNITY_SKIP_EXECUTION;
00469 
00470     if ((mask & expected) != (mask & actual))
00471     {
00472         UnityTestResultsFailBegin(lineNumber);
00473         UnityPrint(UnityStrExpected);
00474         UnityPrintMask((_U_UINT)mask, (_U_UINT)expected);
00475         UnityPrint(UnityStrWas);
00476         UnityPrintMask((_U_UINT)mask, (_U_UINT)actual);
00477         UnityAddMsgIfSpecified(msg);
00478         UNITY_FAIL_AND_BAIL;
00479     }
00480 }
00481 
00482 /*-----------------------------------------------*/
00483 void UnityAssertEqualNumber(const _U_SINT expected,
00484                             const _U_SINT actual,
00485                             const char* msg,
00486                             const UNITY_LINE_TYPE lineNumber,
00487                             const UNITY_DISPLAY_STYLE_T style)
00488 {
00489     UNITY_SKIP_EXECUTION;
00490 
00491     if (expected != actual)
00492     {
00493         UnityTestResultsFailBegin(lineNumber);
00494         UnityPrint(UnityStrExpected);
00495         UnityPrintNumberByStyle(expected, style);
00496         UnityPrint(UnityStrWas);
00497         UnityPrintNumberByStyle(actual, style);
00498         UnityAddMsgIfSpecified(msg);
00499         UNITY_FAIL_AND_BAIL;
00500     }
00501 }
00502 
00503 #define UnityPrintPointlessAndBail()       \
00504 {                                          \
00505     UnityTestResultsFailBegin(lineNumber); \
00506     UnityPrint(UnityStrPointless);         \
00507     UnityAddMsgIfSpecified(msg);           \
00508     UNITY_FAIL_AND_BAIL; }
00509 
00510 /*-----------------------------------------------*/
00511 void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
00512                               UNITY_INTERNAL_PTR actual,
00513                               const _UU32 num_elements,
00514                               const char* msg,
00515                               const UNITY_LINE_TYPE lineNumber,
00516                               const UNITY_DISPLAY_STYLE_T style)
00517 {
00518     _UU32 elements = num_elements;
00519     UNITY_INTERNAL_PTR ptr_exp = (UNITY_INTERNAL_PTR)expected;
00520     UNITY_INTERNAL_PTR ptr_act = (UNITY_INTERNAL_PTR)actual;
00521 
00522     UNITY_SKIP_EXECUTION;
00523 
00524     if (elements == 0)
00525     {
00526         UnityPrintPointlessAndBail();
00527     }
00528 
00529     if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
00530         return;
00531 
00532     /* If style is UNITY_DISPLAY_STYLE_INT, we'll fall into the default case rather than the INT16 or INT32 (etc) case
00533      * as UNITY_DISPLAY_STYLE_INT includes a flag for UNITY_DISPLAY_RANGE_AUTO, which the width-specific
00534      * variants do not. Therefore remove this flag. */
00535     switch(style & (UNITY_DISPLAY_STYLE_T)(~UNITY_DISPLAY_RANGE_AUTO))
00536     {
00537         case UNITY_DISPLAY_STYLE_HEX8:
00538         case UNITY_DISPLAY_STYLE_INT8:
00539         case UNITY_DISPLAY_STYLE_UINT8:
00540             while (elements--)
00541             {
00542                 if (*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US8*)ptr_act)
00543                 {
00544                     UnityTestResultsFailBegin(lineNumber);
00545                     UnityPrint(UnityStrElement);
00546                     UnityPrintNumberUnsigned(num_elements - elements - 1);
00547                     UnityPrint(UnityStrExpected);
00548                     UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_exp, style);
00549                     UnityPrint(UnityStrWas);
00550                     UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_act, style);
00551                     UnityAddMsgIfSpecified(msg);
00552                     UNITY_FAIL_AND_BAIL;
00553                 }
00554                 ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 1);
00555                 ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 1);
00556             }
00557             break;
00558         case UNITY_DISPLAY_STYLE_HEX16:
00559         case UNITY_DISPLAY_STYLE_INT16:
00560         case UNITY_DISPLAY_STYLE_UINT16:
00561             while (elements--)
00562             {
00563                 if (*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US16*)ptr_act)
00564                 {
00565                     UnityTestResultsFailBegin(lineNumber);
00566                     UnityPrint(UnityStrElement);
00567                     UnityPrintNumberUnsigned(num_elements - elements - 1);
00568                     UnityPrint(UnityStrExpected);
00569                     UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_exp, style);
00570                     UnityPrint(UnityStrWas);
00571                     UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_act, style);
00572                     UnityAddMsgIfSpecified(msg);
00573                     UNITY_FAIL_AND_BAIL;
00574                 }
00575                 ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 2);
00576                 ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 2);
00577             }
00578             break;
00579 #ifdef UNITY_SUPPORT_64
00580         case UNITY_DISPLAY_STYLE_HEX64:
00581         case UNITY_DISPLAY_STYLE_INT64:
00582         case UNITY_DISPLAY_STYLE_UINT64:
00583             while (elements--)
00584             {
00585                 if (*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US64*)ptr_act)
00586                 {
00587                     UnityTestResultsFailBegin(lineNumber);
00588                     UnityPrint(UnityStrElement);
00589                     UnityPrintNumberUnsigned(num_elements - elements - 1);
00590                     UnityPrint(UnityStrExpected);
00591                     UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_exp, style);
00592                     UnityPrint(UnityStrWas);
00593                     UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_act, style);
00594                     UnityAddMsgIfSpecified(msg);
00595                     UNITY_FAIL_AND_BAIL;
00596                 }
00597                 ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 8);
00598                 ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 8);
00599             }
00600             break;
00601 #endif
00602         default:
00603             while (elements--)
00604             {
00605                 if (*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US32*)ptr_act)
00606                 {
00607                     UnityTestResultsFailBegin(lineNumber);
00608                     UnityPrint(UnityStrElement);
00609                     UnityPrintNumberUnsigned(num_elements - elements - 1);
00610                     UnityPrint(UnityStrExpected);
00611                     UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_exp, style);
00612                     UnityPrint(UnityStrWas);
00613                     UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_act, style);
00614                     UnityAddMsgIfSpecified(msg);
00615                     UNITY_FAIL_AND_BAIL;
00616                 }
00617                 ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 4);
00618                 ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 4);
00619             }
00620             break;
00621     }
00622 }
00623 
00624 /*-----------------------------------------------*/
00625 #ifndef UNITY_EXCLUDE_FLOAT
00626 void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const _UF* expected,
00627                                 UNITY_PTR_ATTRIBUTE const _UF* actual,
00628                                 const _UU32 num_elements,
00629                                 const char* msg,
00630                                 const UNITY_LINE_TYPE lineNumber)
00631 {
00632     _UU32 elements = num_elements;
00633     UNITY_PTR_ATTRIBUTE const _UF* ptr_expected = expected;
00634     UNITY_PTR_ATTRIBUTE const _UF* ptr_actual = actual;
00635     _UF diff, tol;
00636 
00637     UNITY_SKIP_EXECUTION;
00638 
00639     if (elements == 0)
00640     {
00641         UnityPrintPointlessAndBail();
00642     }
00643 
00644     if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
00645         return;
00646 
00647     while (elements--)
00648     {
00649         diff = *ptr_expected - *ptr_actual;
00650         if (diff < 0.0f)
00651             diff = 0.0f - diff;
00652         tol = UNITY_FLOAT_PRECISION * *ptr_expected;
00653         if (tol < 0.0f)
00654             tol = 0.0f - tol;
00655 
00656         /* This first part of this condition will catch any NaN or Infinite values */
00657         if (isnan(diff) || isinf(diff) || (diff > tol))
00658         {
00659             UnityTestResultsFailBegin(lineNumber);
00660             UnityPrint(UnityStrElement);
00661             UnityPrintNumberUnsigned(num_elements - elements - 1);
00662 #ifdef UNITY_FLOAT_VERBOSE
00663             UnityPrint(UnityStrExpected);
00664             UnityPrintFloat(*ptr_expected);
00665             UnityPrint(UnityStrWas);
00666             UnityPrintFloat(*ptr_actual);
00667 #else
00668             UnityPrint(UnityStrDelta);
00669 #endif
00670             UnityAddMsgIfSpecified(msg);
00671             UNITY_FAIL_AND_BAIL;
00672         }
00673         ptr_expected++;
00674         ptr_actual++;
00675     }
00676 }
00677 
00678 /*-----------------------------------------------*/
00679 void UnityAssertFloatsWithin(const _UF delta,
00680                              const _UF expected,
00681                              const _UF actual,
00682                              const char* msg,
00683                              const UNITY_LINE_TYPE lineNumber)
00684 {
00685     _UF diff = actual - expected;
00686     _UF pos_delta = delta;
00687 
00688     UNITY_SKIP_EXECUTION;
00689 
00690     if (diff < 0.0f)
00691     {
00692         diff = 0.0f - diff;
00693     }
00694     if (pos_delta < 0.0f)
00695     {
00696         pos_delta = 0.0f - pos_delta;
00697     }
00698 
00699     /* This first part of this condition will catch any NaN or Infinite values */
00700     if (isnan(diff) || isinf(diff) || (pos_delta < diff))
00701     {
00702         UnityTestResultsFailBegin(lineNumber);
00703 #ifdef UNITY_FLOAT_VERBOSE
00704         UnityPrint(UnityStrExpected);
00705         UnityPrintFloat(expected);
00706         UnityPrint(UnityStrWas);
00707         UnityPrintFloat(actual);
00708 #else
00709         UnityPrint(UnityStrDelta);
00710 #endif
00711         UnityAddMsgIfSpecified(msg);
00712         UNITY_FAIL_AND_BAIL;
00713     }
00714 }
00715 
00716 /*-----------------------------------------------*/
00717 void UnityAssertFloatSpecial(const _UF actual,
00718                              const char* msg,
00719                              const UNITY_LINE_TYPE lineNumber,
00720                              const UNITY_FLOAT_TRAIT_T style)
00721 {
00722     const char* trait_names[] = { UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet };
00723     _U_SINT should_be_trait   = ((_U_SINT)style & 1);
00724     _U_SINT is_trait          = !should_be_trait;
00725     _U_SINT trait_index       = (_U_SINT)(style >> 1);
00726 
00727     UNITY_SKIP_EXECUTION;
00728 
00729     switch(style)
00730     {
00731         /* To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly
00732          * We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise */
00733         case UNITY_FLOAT_IS_INF:
00734         case UNITY_FLOAT_IS_NOT_INF:
00735             is_trait = isinf(actual) & ispos(actual);
00736             break;
00737         case UNITY_FLOAT_IS_NEG_INF:
00738         case UNITY_FLOAT_IS_NOT_NEG_INF:
00739             is_trait = isinf(actual) & isneg(actual);
00740             break;
00741 
00742         /* NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN. */
00743         case UNITY_FLOAT_IS_NAN:
00744         case UNITY_FLOAT_IS_NOT_NAN:
00745             is_trait = isnan(actual);
00746             break;
00747 
00748         /* A determinate number is non infinite and not NaN. (therefore the opposite of the two above) */
00749         case UNITY_FLOAT_IS_DET:
00750         case UNITY_FLOAT_IS_NOT_DET:
00751             if (isinf(actual) | isnan(actual))
00752                 is_trait = 0;
00753             else
00754                 is_trait = 1;
00755             break;
00756 
00757         default:
00758             trait_index = 0;
00759             trait_names[0] = UnityStrInvalidFloatTrait;
00760             break;
00761     }
00762 
00763     if (is_trait != should_be_trait)
00764     {
00765         UnityTestResultsFailBegin(lineNumber);
00766         UnityPrint(UnityStrExpected);
00767         if (!should_be_trait)
00768             UnityPrint(UnityStrNot);
00769         UnityPrint(trait_names[trait_index]);
00770         UnityPrint(UnityStrWas);
00771 #ifdef UNITY_FLOAT_VERBOSE
00772         UnityPrintFloat(actual);
00773 #else
00774         if (should_be_trait)
00775             UnityPrint(UnityStrNot);
00776         UnityPrint(trait_names[trait_index]);
00777 #endif
00778         UnityAddMsgIfSpecified(msg);
00779         UNITY_FAIL_AND_BAIL;
00780     }
00781 }
00782 
00783 #endif /* not UNITY_EXCLUDE_FLOAT */
00784 
00785 /*-----------------------------------------------*/
00786 #ifndef UNITY_EXCLUDE_DOUBLE
00787 void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const _UD* expected,
00788                                  UNITY_PTR_ATTRIBUTE const _UD* actual,
00789                                  const _UU32 num_elements,
00790                                  const char* msg,
00791                                  const UNITY_LINE_TYPE lineNumber)
00792 {
00793     _UU32 elements = num_elements;
00794     UNITY_PTR_ATTRIBUTE const _UD* ptr_expected = expected;
00795     UNITY_PTR_ATTRIBUTE const _UD* ptr_actual = actual;
00796     _UD diff, tol;
00797 
00798     UNITY_SKIP_EXECUTION;
00799 
00800     if (elements == 0)
00801     {
00802         UnityPrintPointlessAndBail();
00803     }
00804 
00805     if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
00806         return;
00807 
00808     while (elements--)
00809     {
00810         diff = *ptr_expected - *ptr_actual;
00811         if (diff < 0.0)
00812           diff = 0.0 - diff;
00813         tol = UNITY_DOUBLE_PRECISION * *ptr_expected;
00814         if (tol < 0.0)
00815             tol = 0.0 - tol;
00816 
00817         /* This first part of this condition will catch any NaN or Infinite values */
00818         if (isnan(diff) || isinf(diff) || (diff > tol))
00819         {
00820             UnityTestResultsFailBegin(lineNumber);
00821             UnityPrint(UnityStrElement);
00822             UnityPrintNumberUnsigned(num_elements - elements - 1);
00823 #ifdef UNITY_DOUBLE_VERBOSE
00824             UnityPrint(UnityStrExpected);
00825             UnityPrintFloat((float)(*ptr_expected));
00826             UnityPrint(UnityStrWas);
00827             UnityPrintFloat((float)(*ptr_actual));
00828 #else
00829             UnityPrint(UnityStrDelta);
00830 #endif
00831             UnityAddMsgIfSpecified(msg);
00832             UNITY_FAIL_AND_BAIL;
00833         }
00834         ptr_expected++;
00835         ptr_actual++;
00836     }
00837 }
00838 
00839 /*-----------------------------------------------*/
00840 void UnityAssertDoublesWithin(const _UD delta,
00841                               const _UD expected,
00842                               const _UD actual,
00843                               const char* msg,
00844                               const UNITY_LINE_TYPE lineNumber)
00845 {
00846     _UD diff = actual - expected;
00847     _UD pos_delta = delta;
00848 
00849     UNITY_SKIP_EXECUTION;
00850 
00851     if (diff < 0.0)
00852     {
00853         diff = 0.0 - diff;
00854     }
00855     if (pos_delta < 0.0)
00856     {
00857         pos_delta = 0.0 - pos_delta;
00858     }
00859 
00860     /* This first part of this condition will catch any NaN or Infinite values */
00861     if (isnan(diff) || isinf(diff) || (pos_delta < diff))
00862     {
00863         UnityTestResultsFailBegin(lineNumber);
00864 #ifdef UNITY_DOUBLE_VERBOSE
00865         UnityPrint(UnityStrExpected);
00866         UnityPrintFloat((float)expected);
00867         UnityPrint(UnityStrWas);
00868         UnityPrintFloat((float)actual);
00869 #else
00870         UnityPrint(UnityStrDelta);
00871 #endif
00872         UnityAddMsgIfSpecified(msg);
00873         UNITY_FAIL_AND_BAIL;
00874     }
00875 }
00876 
00877 /*-----------------------------------------------*/
00878 
00879 void UnityAssertDoubleSpecial(const _UD actual,
00880                               const char* msg,
00881                               const UNITY_LINE_TYPE lineNumber,
00882                               const UNITY_FLOAT_TRAIT_T style)
00883 {
00884     const char* trait_names[] = { UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet };
00885     _U_SINT should_be_trait   = ((_U_SINT)style & 1);
00886     _U_SINT is_trait          = !should_be_trait;
00887     _U_SINT trait_index       = (_U_SINT)(style >> 1);
00888 
00889     UNITY_SKIP_EXECUTION;
00890 
00891      switch(style)
00892     {
00893         /* To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly
00894          * We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise */
00895         case UNITY_FLOAT_IS_INF:
00896         case UNITY_FLOAT_IS_NOT_INF:
00897             is_trait = isinf(actual) & ispos(actual);
00898             break;
00899         case UNITY_FLOAT_IS_NEG_INF:
00900         case UNITY_FLOAT_IS_NOT_NEG_INF:
00901             is_trait = isinf(actual) & isneg(actual);
00902             break;
00903 
00904         /* NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN. */
00905         case UNITY_FLOAT_IS_NAN:
00906         case UNITY_FLOAT_IS_NOT_NAN:
00907             is_trait = isnan(actual);
00908             break;
00909 
00910         /* A determinate number is non infinite and not NaN. (therefore the opposite of the two above) */
00911         case UNITY_FLOAT_IS_DET:
00912         case UNITY_FLOAT_IS_NOT_DET:
00913             if (isinf(actual) | isnan(actual))
00914                 is_trait = 0;
00915             else
00916                 is_trait = 1;
00917             break;
00918 
00919         default:
00920             trait_index = 0;
00921             trait_names[0] = UnityStrInvalidFloatTrait;
00922             break;
00923     }
00924 
00925     if (is_trait != should_be_trait)
00926     {
00927         UnityTestResultsFailBegin(lineNumber);
00928         UnityPrint(UnityStrExpected);
00929         if (!should_be_trait)
00930             UnityPrint(UnityStrNot);
00931         UnityPrint(trait_names[trait_index]);
00932         UnityPrint(UnityStrWas);
00933 #ifdef UNITY_DOUBLE_VERBOSE
00934         UnityPrintFloat(actual);
00935 #else
00936         if (should_be_trait)
00937             UnityPrint(UnityStrNot);
00938         UnityPrint(trait_names[trait_index]);
00939 #endif
00940         UnityAddMsgIfSpecified(msg);
00941         UNITY_FAIL_AND_BAIL;
00942     }
00943 }
00944 
00945 
00946 #endif /* not UNITY_EXCLUDE_DOUBLE */
00947 
00948 /*-----------------------------------------------*/
00949 void UnityAssertNumbersWithin( const _U_UINT delta,
00950                                const _U_SINT expected,
00951                                const _U_SINT actual,
00952                                const char* msg,
00953                                const UNITY_LINE_TYPE lineNumber,
00954                                const UNITY_DISPLAY_STYLE_T style)
00955 {
00956     UNITY_SKIP_EXECUTION;
00957 
00958     if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
00959     {
00960         if (actual > expected)
00961             Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > delta);
00962         else
00963             Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > delta);
00964     }
00965     else
00966     {
00967         if ((_U_UINT)actual > (_U_UINT)expected)
00968             Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > delta);
00969         else
00970             Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > delta);
00971     }
00972 
00973     if (Unity.CurrentTestFailed)
00974     {
00975         UnityTestResultsFailBegin(lineNumber);
00976         UnityPrint(UnityStrDelta);
00977         UnityPrintNumberByStyle((_U_SINT)delta, style);
00978         UnityPrint(UnityStrExpected);
00979         UnityPrintNumberByStyle(expected, style);
00980         UnityPrint(UnityStrWas);
00981         UnityPrintNumberByStyle(actual, style);
00982         UnityAddMsgIfSpecified(msg);
00983         UNITY_FAIL_AND_BAIL;
00984     }
00985 }
00986 
00987 /*-----------------------------------------------*/
00988 void UnityAssertEqualString(const char* expected,
00989                             const char* actual,
00990                             const char* msg,
00991                             const UNITY_LINE_TYPE lineNumber)
00992 {
00993     _UU32 i;
00994 
00995     UNITY_SKIP_EXECUTION;
00996 
00997     /* if both pointers not null compare the strings */
00998     if (expected && actual)
00999     {
01000         for (i = 0; expected[i] || actual[i]; i++)
01001         {
01002             if (expected[i] != actual[i])
01003             {
01004                 Unity.CurrentTestFailed = 1;
01005                 break;
01006             }
01007         }
01008     }
01009     else
01010     { /* handle case of one pointers being null (if both null, test should pass) */
01011         if (expected != actual)
01012         {
01013             Unity.CurrentTestFailed = 1;
01014         }
01015     }
01016 
01017     if (Unity.CurrentTestFailed)
01018     {
01019       UnityTestResultsFailBegin(lineNumber);
01020       UnityPrintExpectedAndActualStrings(expected, actual);
01021       UnityAddMsgIfSpecified(msg);
01022       UNITY_FAIL_AND_BAIL;
01023     }
01024 }
01025 
01026 /*-----------------------------------------------*/
01027 void UnityAssertEqualStringLen(const char* expected,
01028                             const char* actual,
01029                             const _UU32 length,
01030                             const char* msg,
01031                             const UNITY_LINE_TYPE lineNumber)
01032 {
01033     _UU32 i;
01034 
01035     UNITY_SKIP_EXECUTION;
01036 
01037     /* if both pointers not null compare the strings */
01038     if (expected && actual)
01039     {
01040         for (i = 0; (expected[i] || actual[i]) && i < length; i++)
01041         {
01042             if (expected[i] != actual[i])
01043             {
01044                 Unity.CurrentTestFailed = 1;
01045                 break;
01046             }
01047         }
01048     }
01049     else
01050     { /* handle case of one pointers being null (if both null, test should pass) */
01051         if (expected != actual)
01052         {
01053             Unity.CurrentTestFailed = 1;
01054         }
01055     }
01056 
01057     if (Unity.CurrentTestFailed)
01058     {
01059       UnityTestResultsFailBegin(lineNumber);
01060       UnityPrintExpectedAndActualStringsLen(expected, actual, length);
01061       UnityAddMsgIfSpecified(msg);
01062       UNITY_FAIL_AND_BAIL;
01063     }
01064 }
01065 
01066 
01067 /*-----------------------------------------------*/
01068 void UnityAssertEqualStringArray( const char** expected,
01069                                   const char** actual,
01070                                   const _UU32 num_elements,
01071                                   const char* msg,
01072                                   const UNITY_LINE_TYPE lineNumber)
01073 {
01074     _UU32 i, j = 0;
01075 
01076     UNITY_SKIP_EXECUTION;
01077 
01078     /* if no elements, it's an error */
01079     if (num_elements == 0)
01080     {
01081         UnityPrintPointlessAndBail();
01082     }
01083 
01084     if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
01085         return;
01086 
01087     do
01088     {
01089         /* if both pointers not null compare the strings */
01090         if (expected[j] && actual[j])
01091         {
01092             for (i = 0; expected[j][i] || actual[j][i]; i++)
01093             {
01094                 if (expected[j][i] != actual[j][i])
01095                 {
01096                     Unity.CurrentTestFailed = 1;
01097                     break;
01098                 }
01099             }
01100         }
01101         else
01102         { /* handle case of one pointers being null (if both null, test should pass) */
01103             if (expected[j] != actual[j])
01104             {
01105                 Unity.CurrentTestFailed = 1;
01106             }
01107         }
01108 
01109         if (Unity.CurrentTestFailed)
01110         {
01111             UnityTestResultsFailBegin(lineNumber);
01112             if (num_elements > 1)
01113             {
01114                 UnityPrint(UnityStrElement);
01115                 UnityPrintNumberUnsigned(j);
01116             }
01117             UnityPrintExpectedAndActualStrings((const char*)(expected[j]), (const char*)(actual[j]));
01118             UnityAddMsgIfSpecified(msg);
01119             UNITY_FAIL_AND_BAIL;
01120         }
01121     } while (++j < num_elements);
01122 }
01123 
01124 /*-----------------------------------------------*/
01125 void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected,
01126                              UNITY_INTERNAL_PTR actual,
01127                              const _UU32 length,
01128                              const _UU32 num_elements,
01129                              const char* msg,
01130                              const UNITY_LINE_TYPE lineNumber)
01131 {
01132     UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected;
01133     UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual;
01134     _UU32 elements = num_elements;
01135     _UU32 bytes;
01136 
01137     UNITY_SKIP_EXECUTION;
01138 
01139     if ((elements == 0) || (length == 0))
01140     {
01141         UnityPrintPointlessAndBail();
01142     }
01143 
01144     if (UnityCheckArraysForNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg) == 1)
01145         return;
01146 
01147     while (elements--)
01148     {
01149         /* /////////////////////////////////// */
01150         bytes = length;
01151         while (bytes--)
01152         {
01153             if (*ptr_exp != *ptr_act)
01154             {
01155                 UnityTestResultsFailBegin(lineNumber);
01156                 UnityPrint(UnityStrMemory);
01157                 if (num_elements > 1)
01158                 {
01159                     UnityPrint(UnityStrElement);
01160                     UnityPrintNumberUnsigned(num_elements - elements - 1);
01161                 }
01162                 UnityPrint(UnityStrByte);
01163                 UnityPrintNumberUnsigned(length - bytes - 1);
01164                 UnityPrint(UnityStrExpected);
01165                 UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8);
01166                 UnityPrint(UnityStrWas);
01167                 UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8);
01168                 UnityAddMsgIfSpecified(msg);
01169                 UNITY_FAIL_AND_BAIL;
01170             }
01171             ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 1);
01172             ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 1);
01173         }
01174         /* /////////////////////////////////// */
01175 
01176     }
01177 }
01178 
01179 /*-----------------------------------------------
01180  * Control Functions
01181  *-----------------------------------------------*/
01182 
01183 void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
01184 {
01185     UNITY_SKIP_EXECUTION;
01186 
01187     UnityTestResultsBegin(Unity.TestFile, line);
01188     UnityPrintFail();
01189     if (msg != NULL)
01190     {
01191         UNITY_OUTPUT_CHAR(':');
01192 
01193 #ifndef UNITY_EXCLUDE_DETAILS
01194         if (Unity.CurrentDetail1)
01195         {
01196             UnityPrint(UnityStrDetail1Name);
01197             UnityPrint(Unity.CurrentDetail1);
01198             if (Unity.CurrentDetail2)
01199             {
01200                 UnityPrint(UnityStrDetail2Name);
01201                 UnityPrint(Unity.CurrentDetail2);
01202             }
01203             UnityPrint(UnityStrSpacer);
01204         }
01205 #endif
01206         if (msg[0] != ' ')
01207         {
01208             UNITY_OUTPUT_CHAR(' ');
01209         }
01210         UnityPrint(msg);
01211     }
01212     UNITY_FAIL_AND_BAIL;
01213 }
01214 
01215 /*-----------------------------------------------*/
01216 void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line)
01217 {
01218     UNITY_SKIP_EXECUTION;
01219 
01220     UnityTestResultsBegin(Unity.TestFile, line);
01221     UnityPrint(UnityStrIgnore);
01222     if (msg != NULL)
01223     {
01224       UNITY_OUTPUT_CHAR(':');
01225       UNITY_OUTPUT_CHAR(' ');
01226       UnityPrint(msg);
01227     }
01228     UNITY_IGNORE_AND_BAIL;
01229 }
01230 
01231 /*-----------------------------------------------*/
01232 #if defined(UNITY_WEAK_ATTRIBUTE)
01233     UNITY_WEAK_ATTRIBUTE void setUp(void) { }
01234     UNITY_WEAK_ATTRIBUTE void tearDown(void) { }
01235 #elif defined(UNITY_WEAK_PRAGMA)
01236 #   pragma weak setUp
01237     void setUp(void) { }
01238 #   pragma weak tearDown
01239     void tearDown(void) { }
01240 #endif
01241 /*-----------------------------------------------*/
01242 void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)
01243 {
01244     Unity.CurrentTestName = FuncName;
01245     Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum;
01246     Unity.NumberOfTests++;
01247     UNITY_CLR_DETAILS();
01248     if (TEST_PROTECT())
01249     {
01250         setUp();
01251         Func();
01252     }
01253     if (TEST_PROTECT() && !(Unity.CurrentTestIgnored))
01254     {
01255         tearDown();
01256     }
01257     UnityConcludeTest();
01258 }
01259 
01260 /*-----------------------------------------------*/
01261 void UnityBegin(const char* filename)
01262 {
01263     Unity.TestFile = filename;
01264     Unity.CurrentTestName = NULL;
01265     Unity.CurrentTestLineNumber = 0;
01266     Unity.NumberOfTests = 0;
01267     Unity.TestFailures = 0;
01268     Unity.TestIgnores = 0;
01269     Unity.CurrentTestFailed = 0;
01270     Unity.CurrentTestIgnored = 0;
01271 
01272     UNITY_CLR_DETAILS();
01273     UNITY_OUTPUT_START();
01274 }
01275 
01276 /*-----------------------------------------------*/
01277 int UnityEnd(void)
01278 {
01279     UNITY_PRINT_EOL();
01280     UnityPrint(UnityStrBreaker);
01281     UNITY_PRINT_EOL();
01282     UnityPrintNumber((_U_SINT)(Unity.NumberOfTests));
01283     UnityPrint(UnityStrResultsTests);
01284     UnityPrintNumber((_U_SINT)(Unity.TestFailures));
01285     UnityPrint(UnityStrResultsFailures);
01286     UnityPrintNumber((_U_SINT)(Unity.TestIgnores));
01287     UnityPrint(UnityStrResultsIgnored);
01288     UNITY_PRINT_EOL();
01289     if (Unity.TestFailures == 0U)
01290     {
01291         UnityPrintOk();
01292     }
01293     else
01294     {
01295         UnityPrintFail();
01296 #ifdef UNITY_DIFFERENTIATE_FINAL_FAIL
01297         UNITY_OUTPUT_CHAR('E'); UNITY_OUTPUT_CHAR('D');
01298 #endif
01299     }
01300     UNITY_PRINT_EOL();
01301     UNITY_OUTPUT_FLUSH();
01302     UNITY_OUTPUT_COMPLETE();
01303     return (int)(Unity.TestFailures);
01304 }
01305 
01306 /*-----------------------------------------------*/