luna - cjson/tests/unity/src/unity.c

   1/* =========================================================================
   2    Unity Project - A Test Framework for C
   3    Copyright (c) 2007-14 Mike Karlesky, Mark VanderVoord, Greg Williams
   4    [Released under MIT License. Please refer to license.txt for details]
   5============================================================================ */
   6
   7#define UNITY_INCLUDE_SETUP_STUBS
   8#include "unity.h"
   9#include <stddef.h>
  10
  11/* If omitted from header, declare overridable prototypes here so they're ready for use */
  12#ifdef UNITY_OMIT_OUTPUT_CHAR_HEADER_DECLARATION
  13void UNITY_OUTPUT_CHAR(int);
  14#endif
  15
  16/* Helpful macros for us to use here in Assert functions */
  17#define UNITY_FAIL_AND_BAIL   { Unity.CurrentTestFailed  = 1; TEST_ABORT(); }
  18#define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; TEST_ABORT(); }
  19#define RETURN_IF_FAIL_OR_IGNORE if (Unity.CurrentTestFailed || Unity.CurrentTestIgnored) return
  20
  21struct UNITY_STORAGE_T Unity;
  22
  23#ifdef UNITY_OUTPUT_COLOR
  24static const char UnityStrOk[]                     = "\033[42mOK\033[00m";
  25static const char UnityStrPass[]                   = "\033[42mPASS\033[00m";
  26static const char UnityStrFail[]                   = "\033[41mFAIL\033[00m";
  27static const char UnityStrIgnore[]                 = "\033[43mIGNORE\033[00m";
  28#else
  29static const char UnityStrOk[]                     = "OK";
  30static const char UnityStrPass[]                   = "PASS";
  31static const char UnityStrFail[]                   = "FAIL";
  32static const char UnityStrIgnore[]                 = "IGNORE";
  33#endif
  34static const char UnityStrNull[]                   = "NULL";
  35static const char UnityStrSpacer[]                 = ". ";
  36static const char UnityStrExpected[]               = " Expected ";
  37static const char UnityStrWas[]                    = " Was ";
  38static const char UnityStrGt[]                     = " to be greater than ";
  39static const char UnityStrLt[]                     = " to be less than ";
  40static const char UnityStrOrEqual[]                = "or equal to ";
  41static const char UnityStrElement[]                = " Element ";
  42static const char UnityStrByte[]                   = " Byte ";
  43static const char UnityStrMemory[]                 = " Memory Mismatch.";
  44static const char UnityStrDelta[]                  = " Values Not Within Delta ";
  45static const char UnityStrPointless[]              = " You Asked Me To Compare Nothing, Which Was Pointless.";
  46static const char UnityStrNullPointerForExpected[] = " Expected pointer to be NULL";
  47static const char UnityStrNullPointerForActual[]   = " Actual pointer was NULL";
  48#ifndef UNITY_EXCLUDE_FLOAT
  49static const char UnityStrNot[]                    = "Not ";
  50static const char UnityStrInf[]                    = "Infinity";
  51static const char UnityStrNegInf[]                 = "Negative Infinity";
  52static const char UnityStrNaN[]                    = "NaN";
  53static const char UnityStrDet[]                    = "Determinate";
  54static const char UnityStrInvalidFloatTrait[]      = "Invalid Float Trait";
  55#endif
  56const char UnityStrErrFloat[]                      = "Unity Floating Point Disabled";
  57const char UnityStrErrDouble[]                     = "Unity Double Precision Disabled";
  58const char UnityStrErr64[]                         = "Unity 64-bit Support Disabled";
  59static const char UnityStrBreaker[]                = "-----------------------";
  60static const char UnityStrResultsTests[]           = " Tests ";
  61static const char UnityStrResultsFailures[]        = " Failures ";
  62static const char UnityStrResultsIgnored[]         = " Ignored ";
  63static const char UnityStrDetail1Name[]            = UNITY_DETAIL1_NAME " ";
  64static const char UnityStrDetail2Name[]            = " " UNITY_DETAIL2_NAME " ";
  65
  66/*-----------------------------------------------
  67 * Pretty Printers & Test Result Output Handlers
  68 *-----------------------------------------------*/
  69
  70void UnityPrint(const char* string)
  71{
  72    const char* pch = string;
  73
  74    if (pch != NULL)
  75    {
  76        while (*pch)
  77        {
  78            /* printable characters plus CR & LF are printed */
  79            if ((*pch <= 126) && (*pch >= 32))
  80            {
  81                UNITY_OUTPUT_CHAR(*pch);
  82            }
  83            /* write escaped carriage returns */
  84            else if (*pch == 13)
  85            {
  86                UNITY_OUTPUT_CHAR('\\');
  87                UNITY_OUTPUT_CHAR('r');
  88            }
  89            /* write escaped line feeds */
  90            else if (*pch == 10)
  91            {
  92                UNITY_OUTPUT_CHAR('\\');
  93                UNITY_OUTPUT_CHAR('n');
  94            }
  95#ifdef UNITY_OUTPUT_COLOR
  96            /* print ANSI escape code */
  97            else if (*pch == 27 && *(pch + 1) == '[')
  98            {
  99                while (*pch && *pch != 'm')
 100                {
 101                    UNITY_OUTPUT_CHAR(*pch);
 102                    pch++;
 103                }
 104                UNITY_OUTPUT_CHAR('m');
 105            }
 106#endif
 107            /* unprintable characters are shown as codes */
 108            else
 109            {
 110                UNITY_OUTPUT_CHAR('\\');
 111                UNITY_OUTPUT_CHAR('x');
 112                UnityPrintNumberHex((UNITY_UINT)*pch, 2);
 113            }
 114            pch++;
 115        }
 116    }
 117}
 118
 119void UnityPrintLen(const char* string, const UNITY_UINT32 length)
 120{
 121    const char* pch = string;
 122
 123    if (pch != NULL)
 124    {
 125        while (*pch && (UNITY_UINT32)(pch - string) < length)
 126        {
 127            /* printable characters plus CR & LF are printed */
 128            if ((*pch <= 126) && (*pch >= 32))
 129            {
 130                UNITY_OUTPUT_CHAR(*pch);
 131            }
 132            /* write escaped carriage returns */
 133            else if (*pch == 13)
 134            {
 135                UNITY_OUTPUT_CHAR('\\');
 136                UNITY_OUTPUT_CHAR('r');
 137            }
 138            /* write escaped line feeds */
 139            else if (*pch == 10)
 140            {
 141                UNITY_OUTPUT_CHAR('\\');
 142                UNITY_OUTPUT_CHAR('n');
 143            }
 144            /* unprintable characters are shown as codes */
 145            else
 146            {
 147                UNITY_OUTPUT_CHAR('\\');
 148                UNITY_OUTPUT_CHAR('x');
 149                UnityPrintNumberHex((UNITY_UINT)*pch, 2);
 150            }
 151            pch++;
 152        }
 153    }
 154}
 155
 156/*-----------------------------------------------*/
 157void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style)
 158{
 159    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
 160    {
 161        UnityPrintNumber(number);
 162    }
 163    else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
 164    {
 165        UnityPrintNumberUnsigned((UNITY_UINT)number);
 166    }
 167    else
 168    {
 169        UNITY_OUTPUT_CHAR('0');
 170        UNITY_OUTPUT_CHAR('x');
 171        UnityPrintNumberHex((UNITY_UINT)number, (char)((style & 0xF) * 2));
 172    }
 173}
 174
 175/*-----------------------------------------------*/
 176void UnityPrintNumber(const UNITY_INT number_to_print)
 177{
 178    UNITY_UINT number = (UNITY_UINT)number_to_print;
 179
 180    if (number_to_print < 0)
 181    {
 182        /* A negative number, including MIN negative */
 183        UNITY_OUTPUT_CHAR('-');
 184        number = (UNITY_UINT)(-number_to_print);
 185    }
 186    UnityPrintNumberUnsigned(number);
 187}
 188
 189/*-----------------------------------------------
 190 * basically do an itoa using as little ram as possible */
 191void UnityPrintNumberUnsigned(const UNITY_UINT number)
 192{
 193    UNITY_UINT divisor = 1;
 194
 195    /* figure out initial divisor */
 196    while (number / divisor > 9)
 197    {
 198        divisor *= 10;
 199    }
 200
 201    /* now mod and print, then divide divisor */
 202    do
 203    {
 204        UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10)));
 205        divisor /= 10;
 206    } while (divisor > 0);
 207}
 208
 209/*-----------------------------------------------*/
 210void UnityPrintNumberHex(const UNITY_UINT number, const char nibbles_to_print)
 211{
 212    int nibble;
 213    char nibbles = nibbles_to_print;
 214    if ((unsigned)nibbles > (2 * sizeof(number)))
 215        nibbles = 2 * sizeof(number);
 216
 217    while (nibbles > 0)
 218    {
 219        nibbles--;
 220        nibble = (int)(number >> (nibbles * 4)) & 0x0F;
 221        if (nibble <= 9)
 222        {
 223            UNITY_OUTPUT_CHAR((char)('0' + nibble));
 224        }
 225        else
 226        {
 227            UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble));
 228        }
 229    }
 230}
 231
 232/*-----------------------------------------------*/
 233void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number)
 234{
 235    UNITY_UINT current_bit = (UNITY_UINT)1 << (UNITY_INT_WIDTH - 1);
 236    UNITY_INT32 i;
 237
 238    for (i = 0; i < UNITY_INT_WIDTH; i++)
 239    {
 240        if (current_bit & mask)
 241        {
 242            if (current_bit & number)
 243            {
 244                UNITY_OUTPUT_CHAR('1');
 245            }
 246            else
 247            {
 248                UNITY_OUTPUT_CHAR('0');
 249            }
 250        }
 251        else
 252        {
 253            UNITY_OUTPUT_CHAR('X');
 254        }
 255        current_bit = current_bit >> 1;
 256    }
 257}
 258
 259/*-----------------------------------------------*/
 260#ifndef UNITY_EXCLUDE_FLOAT_PRINT
 261/* This function prints a floating-point value in a format similar to
 262 * printf("%.6g").  It can work with either single- or double-precision,
 263 * but for simplicity, it prints only 6 significant digits in either case.
 264 * Printing more than 6 digits accurately is hard (at least in the single-
 265 * precision case) and isn't attempted here. */
 266void UnityPrintFloat(const UNITY_DOUBLE input_number)
 267{
 268    UNITY_DOUBLE number = input_number;
 269
 270    /* print minus sign (including for negative zero) */
 271    if (number < (double)0.0f || (number == (double)0.0f && (double)1.0f / number < (double)0.0f))
 272    {
 273        UNITY_OUTPUT_CHAR('-');
 274        number = -number;
 275    }
 276
 277    /* handle zero, NaN, and +/- infinity */
 278    if (number == (double)0.0f) UnityPrint("0");
 279    else if (isnan(number)) UnityPrint("nan");
 280    else if (isinf(number)) UnityPrint("inf");
 281    else
 282    {
 283        int exponent = 0;
 284        int decimals, digits;
 285        UNITY_INT32 n;
 286        char buf[16];
 287
 288        /* scale up or down by powers of 10 */
 289        while (number < (double)(100000.0f / 1e6f))  { number *= (double)1e6f; exponent -= 6; }
 290        while (number < (double)100000.0f)         { number *= (double)10.0f; exponent--; }
 291        while (number > (double)(1000000.0f * 1e6f)) { number /= (double)1e6f; exponent += 6; }
 292        while (number > (double)1000000.0f)        { number /= (double)10.0f; exponent++; }
 293
 294        /* round to nearest integer */
 295        n = ((UNITY_INT32)(number + number) + 1) / 2;
 296        if (n > 999999)
 297        {
 298            n = 100000;
 299            exponent++;
 300        }
 301
 302        /* determine where to place decimal point */
 303        decimals = (exponent <= 0 && exponent >= -9) ? -exponent : 5;
 304        exponent += decimals;
 305
 306        /* truncate trailing zeroes after decimal point */
 307        while (decimals > 0 && n % 10 == 0)
 308        {
 309            n /= 10;
 310            decimals--;
 311        }
 312
 313        /* build up buffer in reverse order */
 314        digits = 0;
 315        while (n != 0 || digits < decimals + 1)
 316        {
 317            buf[digits++] = (char)('0' + n % 10);
 318            n /= 10;
 319        }
 320        while (digits > 0)
 321        {
 322            if(digits == decimals) UNITY_OUTPUT_CHAR('.');
 323            UNITY_OUTPUT_CHAR(buf[--digits]);
 324        }
 325
 326        /* print exponent if needed */
 327        if (exponent != 0)
 328        {
 329            UNITY_OUTPUT_CHAR('e');
 330
 331            if(exponent < 0)
 332            {
 333                UNITY_OUTPUT_CHAR('-');
 334                exponent = -exponent;
 335            }
 336            else
 337            {
 338                UNITY_OUTPUT_CHAR('+');
 339            }
 340
 341            digits = 0;
 342            while (exponent != 0 || digits < 2)
 343            {
 344                buf[digits++] = (char)('0' + exponent % 10);
 345                exponent /= 10;
 346            }
 347            while (digits > 0)
 348            {
 349                UNITY_OUTPUT_CHAR(buf[--digits]);
 350            }
 351        }
 352    }
 353}
 354#endif /* ! UNITY_EXCLUDE_FLOAT_PRINT */
 355
 356/*-----------------------------------------------*/
 357static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line)
 358{
 359    UnityPrint(file);
 360    UNITY_OUTPUT_CHAR(':');
 361    UnityPrintNumber((UNITY_INT)line);
 362    UNITY_OUTPUT_CHAR(':');
 363    UnityPrint(Unity.CurrentTestName);
 364    UNITY_OUTPUT_CHAR(':');
 365}
 366
 367/*-----------------------------------------------*/
 368static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line)
 369{
 370    UnityTestResultsBegin(Unity.TestFile, line);
 371    UnityPrint(UnityStrFail);
 372    UNITY_OUTPUT_CHAR(':');
 373}
 374
 375/*-----------------------------------------------*/
 376void UnityConcludeTest(void)
 377{
 378    if (Unity.CurrentTestIgnored)
 379    {
 380        Unity.TestIgnores++;
 381    }
 382    else if (!Unity.CurrentTestFailed)
 383    {
 384        UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber);
 385        UnityPrint(UnityStrPass);
 386    }
 387    else
 388    {
 389        Unity.TestFailures++;
 390    }
 391
 392    Unity.CurrentTestFailed = 0;
 393    Unity.CurrentTestIgnored = 0;
 394    UNITY_PRINT_EOL();
 395    UNITY_FLUSH_CALL();
 396}
 397
 398/*-----------------------------------------------*/
 399static void UnityAddMsgIfSpecified(const char* msg)
 400{
 401    if (msg)
 402    {
 403        UnityPrint(UnityStrSpacer);
 404#ifndef UNITY_EXCLUDE_DETAILS
 405        if (Unity.CurrentDetail1)
 406        {
 407            UnityPrint(UnityStrDetail1Name);
 408            UnityPrint(Unity.CurrentDetail1);
 409            if (Unity.CurrentDetail2)
 410            {
 411                UnityPrint(UnityStrDetail2Name);
 412                UnityPrint(Unity.CurrentDetail2);
 413            }
 414            UnityPrint(UnityStrSpacer);
 415        }
 416#endif
 417        UnityPrint(msg);
 418    }
 419}
 420
 421/*-----------------------------------------------*/
 422static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual)
 423{
 424    UnityPrint(UnityStrExpected);
 425    if (expected != NULL)
 426    {
 427        UNITY_OUTPUT_CHAR('\'');
 428        UnityPrint(expected);
 429        UNITY_OUTPUT_CHAR('\'');
 430    }
 431    else
 432    {
 433        UnityPrint(UnityStrNull);
 434    }
 435    UnityPrint(UnityStrWas);
 436    if (actual != NULL)
 437    {
 438        UNITY_OUTPUT_CHAR('\'');
 439        UnityPrint(actual);
 440        UNITY_OUTPUT_CHAR('\'');
 441    }
 442    else
 443    {
 444        UnityPrint(UnityStrNull);
 445    }
 446}
 447
 448/*-----------------------------------------------*/
 449static void UnityPrintExpectedAndActualStringsLen(const char* expected,
 450                                                  const char* actual,
 451                                                  const UNITY_UINT32 length)
 452{
 453    UnityPrint(UnityStrExpected);
 454    if (expected != NULL)
 455    {
 456        UNITY_OUTPUT_CHAR('\'');
 457        UnityPrintLen(expected, length);
 458        UNITY_OUTPUT_CHAR('\'');
 459    }
 460    else
 461    {
 462        UnityPrint(UnityStrNull);
 463    }
 464    UnityPrint(UnityStrWas);
 465    if (actual != NULL)
 466    {
 467        UNITY_OUTPUT_CHAR('\'');
 468        UnityPrintLen(actual, length);
 469        UNITY_OUTPUT_CHAR('\'');
 470    }
 471    else
 472    {
 473        UnityPrint(UnityStrNull);
 474    }
 475}
 476
 477/*-----------------------------------------------
 478 * Assertion & Control Helpers
 479 *-----------------------------------------------*/
 480
 481static int UnityIsOneArrayNull(UNITY_INTERNAL_PTR expected,
 482                               UNITY_INTERNAL_PTR actual,
 483                               const UNITY_LINE_TYPE lineNumber,
 484                               const char* msg)
 485{
 486    if (expected == actual) return 0; /* Both are NULL or same pointer */
 487
 488    /* print and return true if just expected is NULL */
 489    if (expected == NULL)
 490    {
 491        UnityTestResultsFailBegin(lineNumber);
 492        UnityPrint(UnityStrNullPointerForExpected);
 493        UnityAddMsgIfSpecified(msg);
 494        return 1;
 495    }
 496
 497    /* print and return true if just actual is NULL */
 498    if (actual == NULL)
 499    {
 500        UnityTestResultsFailBegin(lineNumber);
 501        UnityPrint(UnityStrNullPointerForActual);
 502        UnityAddMsgIfSpecified(msg);
 503        return 1;
 504    }
 505
 506    return 0; /* return false if neither is NULL */
 507}
 508
 509/*-----------------------------------------------
 510 * Assertion Functions
 511 *-----------------------------------------------*/
 512
 513void UnityAssertBits(const UNITY_INT mask,
 514                     const UNITY_INT expected,
 515                     const UNITY_INT actual,
 516                     const char* msg,
 517                     const UNITY_LINE_TYPE lineNumber)
 518{
 519    RETURN_IF_FAIL_OR_IGNORE;
 520
 521    if ((mask & expected) != (mask & actual))
 522    {
 523        UnityTestResultsFailBegin(lineNumber);
 524        UnityPrint(UnityStrExpected);
 525        UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)expected);
 526        UnityPrint(UnityStrWas);
 527        UnityPrintMask((UNITY_UINT)mask, (UNITY_UINT)actual);
 528        UnityAddMsgIfSpecified(msg);
 529        UNITY_FAIL_AND_BAIL;
 530    }
 531}
 532
 533/*-----------------------------------------------*/
 534void UnityAssertEqualNumber(const UNITY_INT expected,
 535                            const UNITY_INT actual,
 536                            const char* msg,
 537                            const UNITY_LINE_TYPE lineNumber,
 538                            const UNITY_DISPLAY_STYLE_T style)
 539{
 540    RETURN_IF_FAIL_OR_IGNORE;
 541
 542    if (expected != actual)
 543    {
 544        UnityTestResultsFailBegin(lineNumber);
 545        UnityPrint(UnityStrExpected);
 546        UnityPrintNumberByStyle(expected, style);
 547        UnityPrint(UnityStrWas);
 548        UnityPrintNumberByStyle(actual, style);
 549        UnityAddMsgIfSpecified(msg);
 550        UNITY_FAIL_AND_BAIL;
 551    }
 552}
 553
 554/*-----------------------------------------------*/
 555void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold,
 556                                           const UNITY_INT actual,
 557                                           const UNITY_COMPARISON_T compare,
 558                                           const char *msg,
 559                                           const UNITY_LINE_TYPE lineNumber,
 560                                           const UNITY_DISPLAY_STYLE_T style)
 561{
 562    int failed = 0;
 563    RETURN_IF_FAIL_OR_IGNORE;
 564
 565    if (threshold == actual && compare & UNITY_EQUAL_TO) return;
 566    if (threshold == actual) failed = 1;
 567
 568    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
 569    {
 570        if (actual > threshold && compare & UNITY_SMALLER_THAN) failed = 1;
 571        if (actual < threshold && compare & UNITY_GREATER_THAN) failed = 1;
 572    }
 573    else /* UINT or HEX */
 574    {
 575        if ((UNITY_UINT)actual > (UNITY_UINT)threshold && compare & UNITY_SMALLER_THAN) failed = 1;
 576        if ((UNITY_UINT)actual < (UNITY_UINT)threshold && compare & UNITY_GREATER_THAN) failed = 1;
 577    }
 578
 579    if (failed)
 580    {
 581        UnityTestResultsFailBegin(lineNumber);
 582        UnityPrint(UnityStrExpected);
 583        UnityPrintNumberByStyle(actual, style);
 584        if (compare & UNITY_GREATER_THAN) UnityPrint(UnityStrGt);
 585        if (compare & UNITY_SMALLER_THAN) UnityPrint(UnityStrLt);
 586        if (compare & UNITY_EQUAL_TO)     UnityPrint(UnityStrOrEqual);
 587        UnityPrintNumberByStyle(threshold, style);
 588        UnityAddMsgIfSpecified(msg);
 589        UNITY_FAIL_AND_BAIL;
 590    }
 591}
 592
 593#define UnityPrintPointlessAndBail()       \
 594{                                          \
 595    UnityTestResultsFailBegin(lineNumber); \
 596    UnityPrint(UnityStrPointless);         \
 597    UnityAddMsgIfSpecified(msg);           \
 598    UNITY_FAIL_AND_BAIL; }
 599
 600/*-----------------------------------------------*/
 601void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
 602                              UNITY_INTERNAL_PTR actual,
 603                              const UNITY_UINT32 num_elements,
 604                              const char* msg,
 605                              const UNITY_LINE_TYPE lineNumber,
 606                              const UNITY_DISPLAY_STYLE_T style,
 607                              const UNITY_FLAGS_T flags)
 608{
 609    UNITY_UINT32 elements = num_elements;
 610    unsigned int length   = style & 0xF;
 611
 612    RETURN_IF_FAIL_OR_IGNORE;
 613
 614    if (num_elements == 0)
 615    {
 616        UnityPrintPointlessAndBail();
 617    }
 618
 619    if (expected == actual) return; /* Both are NULL or same pointer */
 620    if (UnityIsOneArrayNull(expected, actual, lineNumber, msg))
 621        UNITY_FAIL_AND_BAIL;
 622
 623    while (elements--)
 624    {
 625        UNITY_INT expect_val;
 626        UNITY_INT actual_val;
 627        switch (length)
 628        {
 629            case 1:
 630                expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)expected;
 631                actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT8*)actual;
 632                break;
 633            case 2:
 634                expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)expected;
 635                actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT16*)actual;
 636                break;
 637#ifdef UNITY_SUPPORT_64
 638            case 8:
 639                expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)expected;
 640                actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT64*)actual;
 641                break;
 642#endif
 643            default: /* length 4 bytes */
 644                expect_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)expected;
 645                actual_val = *(UNITY_PTR_ATTRIBUTE const UNITY_INT32*)actual;
 646                length = 4;
 647                break;
 648        }
 649
 650        if (expect_val != actual_val)
 651        {
 652            if (style & UNITY_DISPLAY_RANGE_UINT && length < sizeof(expect_val))
 653            {   /* For UINT, remove sign extension (padding 1's) from signed type casts above */
 654                UNITY_INT mask = 1;
 655                mask = (mask << 8 * length) - 1;
 656                expect_val &= mask;
 657                actual_val &= mask;
 658            }
 659            UnityTestResultsFailBegin(lineNumber);
 660            UnityPrint(UnityStrElement);
 661            UnityPrintNumberUnsigned(num_elements - elements - 1);
 662            UnityPrint(UnityStrExpected);
 663            UnityPrintNumberByStyle(expect_val, style);
 664            UnityPrint(UnityStrWas);
 665            UnityPrintNumberByStyle(actual_val, style);
 666            UnityAddMsgIfSpecified(msg);
 667            UNITY_FAIL_AND_BAIL;
 668        }
 669        if (flags == UNITY_ARRAY_TO_ARRAY)
 670        {
 671            expected = (UNITY_INTERNAL_PTR)(length + (const char*)expected);
 672        }
 673        actual   = (UNITY_INTERNAL_PTR)(length + (const char*)actual);
 674    }
 675}
 676
 677/*-----------------------------------------------*/
 678#ifndef UNITY_EXCLUDE_FLOAT
 679/* Wrap this define in a function with variable types as float or double */
 680#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff)                       \
 681    if (isinf(expected) && isinf(actual) && ((expected < 0) == (actual < 0))) return 1;   \
 682    if (UNITY_NAN_CHECK) return 1;                                                        \
 683    diff = actual - expected;                                                             \
 684    if (diff < 0) diff = -diff;                                                           \
 685    if (delta < 0) delta = -delta;                                                        \
 686    return !(isnan(diff) || isinf(diff) || (diff > delta))
 687    /* This first part of this condition will catch any NaN or Infinite values */
 688#ifndef UNITY_NAN_NOT_EQUAL_NAN
 689  #define UNITY_NAN_CHECK isnan(expected) && isnan(actual)
 690#else
 691  #define UNITY_NAN_CHECK 0
 692#endif
 693
 694#ifndef UNITY_EXCLUDE_FLOAT_PRINT
 695  #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \
 696  {                                                               \
 697    UnityPrint(UnityStrExpected);                                 \
 698    UnityPrintFloat(expected);                                    \
 699    UnityPrint(UnityStrWas);                                      \
 700    UnityPrintFloat(actual); }
 701#else
 702  #define UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual) \
 703    UnityPrint(UnityStrDelta)
 704#endif /* UNITY_EXCLUDE_FLOAT_PRINT */
 705
 706static int UnityFloatsWithin(UNITY_FLOAT delta, UNITY_FLOAT expected, UNITY_FLOAT actual)
 707{
 708    UNITY_FLOAT diff;
 709    UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff);
 710}
 711
 712void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected,
 713                                UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual,
 714                                const UNITY_UINT32 num_elements,
 715                                const char* msg,
 716                                const UNITY_LINE_TYPE lineNumber,
 717                                const UNITY_FLAGS_T flags)
 718{
 719    UNITY_UINT32 elements = num_elements;
 720    UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_expected = expected;
 721    UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_actual = actual;
 722
 723    RETURN_IF_FAIL_OR_IGNORE;
 724
 725    if (elements == 0)
 726    {
 727        UnityPrintPointlessAndBail();
 728    }
 729
 730    if (expected == actual) return; /* Both are NULL or same pointer */
 731    if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg))
 732        UNITY_FAIL_AND_BAIL;
 733
 734    while (elements--)
 735    {
 736        if (!UnityFloatsWithin(*ptr_expected * UNITY_FLOAT_PRECISION, *ptr_expected, *ptr_actual))
 737        {
 738            UnityTestResultsFailBegin(lineNumber);
 739            UnityPrint(UnityStrElement);
 740            UnityPrintNumberUnsigned(num_elements - elements - 1);
 741            UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)*ptr_expected, (UNITY_DOUBLE)*ptr_actual);
 742            UnityAddMsgIfSpecified(msg);
 743            UNITY_FAIL_AND_BAIL;
 744        }
 745        if (flags == UNITY_ARRAY_TO_ARRAY)
 746        {
 747            ptr_expected++;
 748        }
 749        ptr_actual++;
 750    }
 751}
 752
 753/*-----------------------------------------------*/
 754void UnityAssertFloatsWithin(const UNITY_FLOAT delta,
 755                             const UNITY_FLOAT expected,
 756                             const UNITY_FLOAT actual,
 757                             const char* msg,
 758                             const UNITY_LINE_TYPE lineNumber)
 759{
 760    RETURN_IF_FAIL_OR_IGNORE;
 761
 762
 763    if (!UnityFloatsWithin(delta, expected, actual))
 764    {
 765        UnityTestResultsFailBegin(lineNumber);
 766        UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)expected, (UNITY_DOUBLE)actual);
 767        UnityAddMsgIfSpecified(msg);
 768        UNITY_FAIL_AND_BAIL;
 769    }
 770}
 771
 772/*-----------------------------------------------*/
 773void UnityAssertFloatSpecial(const UNITY_FLOAT actual,
 774                             const char* msg,
 775                             const UNITY_LINE_TYPE lineNumber,
 776                             const UNITY_FLOAT_TRAIT_T style)
 777{
 778    const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet};
 779    UNITY_INT should_be_trait = ((UNITY_INT)style & 1);
 780    UNITY_INT is_trait        = !should_be_trait;
 781    UNITY_INT trait_index     = (UNITY_INT)(style >> 1);
 782
 783    RETURN_IF_FAIL_OR_IGNORE;
 784
 785    switch (style)
 786    {
 787        case UNITY_FLOAT_IS_INF:
 788        case UNITY_FLOAT_IS_NOT_INF:
 789            is_trait = isinf(actual) && (actual > 0);
 790            break;
 791        case UNITY_FLOAT_IS_NEG_INF:
 792        case UNITY_FLOAT_IS_NOT_NEG_INF:
 793            is_trait = isinf(actual) && (actual < 0);
 794            break;
 795
 796        case UNITY_FLOAT_IS_NAN:
 797        case UNITY_FLOAT_IS_NOT_NAN:
 798            is_trait = isnan(actual) ? 1 : 0;
 799            break;
 800
 801        case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */
 802        case UNITY_FLOAT_IS_NOT_DET:
 803            is_trait = !isinf(actual) && !isnan(actual);
 804            break;
 805
 806        default:
 807            trait_index = 0;
 808            trait_names[0] = UnityStrInvalidFloatTrait;
 809            break;
 810    }
 811
 812    if (is_trait != should_be_trait)
 813    {
 814        UnityTestResultsFailBegin(lineNumber);
 815        UnityPrint(UnityStrExpected);
 816        if (!should_be_trait)
 817            UnityPrint(UnityStrNot);
 818        UnityPrint(trait_names[trait_index]);
 819        UnityPrint(UnityStrWas);
 820#ifndef UNITY_EXCLUDE_FLOAT_PRINT
 821        UnityPrintFloat((UNITY_DOUBLE)actual);
 822#else
 823        if (should_be_trait)
 824            UnityPrint(UnityStrNot);
 825        UnityPrint(trait_names[trait_index]);
 826#endif
 827        UnityAddMsgIfSpecified(msg);
 828        UNITY_FAIL_AND_BAIL;
 829    }
 830}
 831
 832#endif /* not UNITY_EXCLUDE_FLOAT */
 833
 834/*-----------------------------------------------*/
 835#ifndef UNITY_EXCLUDE_DOUBLE
 836static int UnityDoublesWithin(UNITY_DOUBLE delta, UNITY_DOUBLE expected, UNITY_DOUBLE actual)
 837{
 838    UNITY_DOUBLE diff;
 839    UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff);
 840}
 841
 842void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected,
 843                                 UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual,
 844                                 const UNITY_UINT32 num_elements,
 845                                 const char* msg,
 846                                 const UNITY_LINE_TYPE lineNumber,
 847                                 const UNITY_FLAGS_T flags)
 848{
 849    UNITY_UINT32 elements = num_elements;
 850    UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_expected = expected;
 851    UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_actual = actual;
 852
 853    RETURN_IF_FAIL_OR_IGNORE;
 854
 855    if (elements == 0)
 856    {
 857        UnityPrintPointlessAndBail();
 858    }
 859
 860    if (expected == actual) return; /* Both are NULL or same pointer */
 861    if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg))
 862        UNITY_FAIL_AND_BAIL;
 863
 864    while (elements--)
 865    {
 866        if (!UnityDoublesWithin(*ptr_expected * UNITY_DOUBLE_PRECISION, *ptr_expected, *ptr_actual))
 867        {
 868            UnityTestResultsFailBegin(lineNumber);
 869            UnityPrint(UnityStrElement);
 870            UnityPrintNumberUnsigned(num_elements - elements - 1);
 871            UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(*ptr_expected, *ptr_actual);
 872            UnityAddMsgIfSpecified(msg);
 873            UNITY_FAIL_AND_BAIL;
 874        }
 875        if (flags == UNITY_ARRAY_TO_ARRAY)
 876        {
 877            ptr_expected++;
 878        }
 879        ptr_actual++;
 880    }
 881}
 882
 883/*-----------------------------------------------*/
 884void UnityAssertDoublesWithin(const UNITY_DOUBLE delta,
 885                              const UNITY_DOUBLE expected,
 886                              const UNITY_DOUBLE actual,
 887                              const char* msg,
 888                              const UNITY_LINE_TYPE lineNumber)
 889{
 890    RETURN_IF_FAIL_OR_IGNORE;
 891
 892    if (!UnityDoublesWithin(delta, expected, actual))
 893    {
 894        UnityTestResultsFailBegin(lineNumber);
 895        UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual);
 896        UnityAddMsgIfSpecified(msg);
 897        UNITY_FAIL_AND_BAIL;
 898    }
 899}
 900
 901/*-----------------------------------------------*/
 902
 903void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual,
 904                              const char* msg,
 905                              const UNITY_LINE_TYPE lineNumber,
 906                              const UNITY_FLOAT_TRAIT_T style)
 907{
 908    const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet};
 909    UNITY_INT should_be_trait = ((UNITY_INT)style & 1);
 910    UNITY_INT is_trait        = !should_be_trait;
 911    UNITY_INT trait_index     = (UNITY_INT)(style >> 1);
 912
 913    RETURN_IF_FAIL_OR_IGNORE;
 914
 915    switch (style)
 916    {
 917        case UNITY_FLOAT_IS_INF:
 918        case UNITY_FLOAT_IS_NOT_INF:
 919            is_trait = isinf(actual) && (actual > 0);
 920            break;
 921        case UNITY_FLOAT_IS_NEG_INF:
 922        case UNITY_FLOAT_IS_NOT_NEG_INF:
 923            is_trait = isinf(actual) && (actual < 0);
 924            break;
 925
 926        case UNITY_FLOAT_IS_NAN:
 927        case UNITY_FLOAT_IS_NOT_NAN:
 928            is_trait = isnan(actual) ? 1 : 0;
 929            break;
 930
 931        case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */
 932        case UNITY_FLOAT_IS_NOT_DET:
 933            is_trait = !isinf(actual) && !isnan(actual);
 934            break;
 935
 936        default:
 937            trait_index = 0;
 938            trait_names[0] = UnityStrInvalidFloatTrait;
 939            break;
 940    }
 941
 942    if (is_trait != should_be_trait)
 943    {
 944        UnityTestResultsFailBegin(lineNumber);
 945        UnityPrint(UnityStrExpected);
 946        if (!should_be_trait)
 947            UnityPrint(UnityStrNot);
 948        UnityPrint(trait_names[trait_index]);
 949        UnityPrint(UnityStrWas);
 950#ifndef UNITY_EXCLUDE_FLOAT_PRINT
 951        UnityPrintFloat(actual);
 952#else
 953        if (should_be_trait)
 954            UnityPrint(UnityStrNot);
 955        UnityPrint(trait_names[trait_index]);
 956#endif
 957        UnityAddMsgIfSpecified(msg);
 958        UNITY_FAIL_AND_BAIL;
 959    }
 960}
 961
 962#endif /* not UNITY_EXCLUDE_DOUBLE */
 963
 964/*-----------------------------------------------*/
 965void UnityAssertNumbersWithin(const UNITY_UINT delta,
 966                              const UNITY_INT expected,
 967                              const UNITY_INT actual,
 968                              const char* msg,
 969                              const UNITY_LINE_TYPE lineNumber,
 970                              const UNITY_DISPLAY_STYLE_T style)
 971{
 972    RETURN_IF_FAIL_OR_IGNORE;
 973
 974    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
 975    {
 976        if (actual > expected)
 977          Unity.CurrentTestFailed = (UNITY_UINT)((UNITY_UINT)(actual - expected) > delta);
 978        else
 979            Unity.CurrentTestFailed = (UNITY_UINT)((UNITY_UINT)(expected - actual) > delta);
 980    }
 981    else
 982    {
 983        if ((UNITY_UINT)actual > (UNITY_UINT)expected)
 984            Unity.CurrentTestFailed = (UNITY_UINT)((UNITY_UINT)(actual - expected) > delta);
 985        else
 986            Unity.CurrentTestFailed = (UNITY_UINT)((UNITY_UINT)(expected - actual) > delta);
 987    }
 988
 989    if (Unity.CurrentTestFailed)
 990    {
 991        UnityTestResultsFailBegin(lineNumber);
 992        UnityPrint(UnityStrDelta);
 993        UnityPrintNumberByStyle((UNITY_INT)delta, style);
 994        UnityPrint(UnityStrExpected);
 995        UnityPrintNumberByStyle(expected, style);
 996        UnityPrint(UnityStrWas);
 997        UnityPrintNumberByStyle(actual, style);
 998        UnityAddMsgIfSpecified(msg);
 999        UNITY_FAIL_AND_BAIL;
1000    }
1001}
1002
1003/*-----------------------------------------------*/
1004void UnityAssertEqualString(const char* expected,
1005                            const char* actual,
1006                            const char* msg,
1007                            const UNITY_LINE_TYPE lineNumber)
1008{
1009    UNITY_UINT32 i;
1010
1011    RETURN_IF_FAIL_OR_IGNORE;
1012
1013    /* if both pointers not null compare the strings */
1014    if (expected && actual)
1015    {
1016        for (i = 0; expected[i] || actual[i]; i++)
1017        {
1018            if (expected[i] != actual[i])
1019            {
1020                Unity.CurrentTestFailed = 1;
1021                break;
1022            }
1023        }
1024    }
1025    else
1026    { /* handle case of one pointers being null (if both null, test should pass) */
1027        if (expected != actual)
1028        {
1029            Unity.CurrentTestFailed = 1;
1030        }
1031    }
1032
1033    if (Unity.CurrentTestFailed)
1034    {
1035        UnityTestResultsFailBegin(lineNumber);
1036        UnityPrintExpectedAndActualStrings(expected, actual);
1037        UnityAddMsgIfSpecified(msg);
1038        UNITY_FAIL_AND_BAIL;
1039    }
1040}
1041
1042/*-----------------------------------------------*/
1043void UnityAssertEqualStringLen(const char* expected,
1044                               const char* actual,
1045                               const UNITY_UINT32 length,
1046                               const char* msg,
1047                               const UNITY_LINE_TYPE lineNumber)
1048{
1049    UNITY_UINT32 i;
1050
1051    RETURN_IF_FAIL_OR_IGNORE;
1052
1053    /* if both pointers not null compare the strings */
1054    if (expected && actual)
1055    {
1056        for (i = 0; (i < length) && (expected[i] || actual[i]); i++)
1057        {
1058            if (expected[i] != actual[i])
1059            {
1060                Unity.CurrentTestFailed = 1;
1061                break;
1062            }
1063        }
1064    }
1065    else
1066    { /* handle case of one pointers being null (if both null, test should pass) */
1067        if (expected != actual)
1068        {
1069            Unity.CurrentTestFailed = 1;
1070        }
1071    }
1072
1073    if (Unity.CurrentTestFailed)
1074    {
1075        UnityTestResultsFailBegin(lineNumber);
1076        UnityPrintExpectedAndActualStringsLen(expected, actual, length);
1077        UnityAddMsgIfSpecified(msg);
1078        UNITY_FAIL_AND_BAIL;
1079    }
1080}
1081
1082/*-----------------------------------------------*/
1083void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
1084                                 const char** actual,
1085                                 const UNITY_UINT32 num_elements,
1086                                 const char* msg,
1087                                 const UNITY_LINE_TYPE lineNumber,
1088                                 const UNITY_FLAGS_T flags)
1089{
1090    UNITY_UINT32 i = 0;
1091    UNITY_UINT32 j = 0;
1092    const char* expd = NULL;
1093    const char* act = NULL;
1094
1095    RETURN_IF_FAIL_OR_IGNORE;
1096
1097    /* if no elements, it's an error */
1098    if (num_elements == 0)
1099    {
1100        UnityPrintPointlessAndBail();
1101    }
1102
1103    if ((const void*)expected == (const void*)actual)
1104    {
1105        return; /* Both are NULL or same pointer */
1106    }
1107
1108    if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg))
1109    {
1110        UNITY_FAIL_AND_BAIL;
1111    }
1112
1113    if (flags != UNITY_ARRAY_TO_ARRAY)
1114    {
1115        expd = (const char*)expected;
1116    }
1117
1118    do
1119    {
1120        act = actual[j];
1121        if (flags == UNITY_ARRAY_TO_ARRAY)
1122        {
1123            expd = ((const char* const*)expected)[j];
1124        }
1125
1126        /* if both pointers not null compare the strings */
1127        if (expd && act)
1128        {
1129            for (i = 0; expd[i] || act[i]; i++)
1130            {
1131                if (expd[i] != act[i])
1132                {
1133                    Unity.CurrentTestFailed = 1;
1134                    break;
1135                }
1136            }
1137        }
1138        else
1139        { /* handle case of one pointers being null (if both null, test should pass) */
1140            if (expd != act)
1141            {
1142                Unity.CurrentTestFailed = 1;
1143            }
1144        }
1145
1146        if (Unity.CurrentTestFailed)
1147        {
1148            UnityTestResultsFailBegin(lineNumber);
1149            if (num_elements > 1)
1150            {
1151                UnityPrint(UnityStrElement);
1152                UnityPrintNumberUnsigned(j);
1153            }
1154            UnityPrintExpectedAndActualStrings(expd, act);
1155            UnityAddMsgIfSpecified(msg);
1156            UNITY_FAIL_AND_BAIL;
1157        }
1158    } while (++j < num_elements);
1159}
1160
1161/*-----------------------------------------------*/
1162void UnityAssertEqualMemory(UNITY_INTERNAL_PTR expected,
1163                            UNITY_INTERNAL_PTR actual,
1164                            const UNITY_UINT32 length,
1165                            const UNITY_UINT32 num_elements,
1166                            const char* msg,
1167                            const UNITY_LINE_TYPE lineNumber,
1168                            const UNITY_FLAGS_T flags)
1169{
1170    UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected;
1171    UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual;
1172    UNITY_UINT32 elements = num_elements;
1173    UNITY_UINT32 bytes;
1174
1175    RETURN_IF_FAIL_OR_IGNORE;
1176
1177    if ((elements == 0) || (length == 0))
1178    {
1179        UnityPrintPointlessAndBail();
1180    }
1181
1182    if (expected == actual) return; /* Both are NULL or same pointer */
1183    if (UnityIsOneArrayNull(expected, actual, lineNumber, msg))
1184        UNITY_FAIL_AND_BAIL;
1185
1186    while (elements--)
1187    {
1188        bytes = length;
1189        while (bytes--)
1190        {
1191            if (*ptr_exp != *ptr_act)
1192            {
1193                UnityTestResultsFailBegin(lineNumber);
1194                UnityPrint(UnityStrMemory);
1195                if (num_elements > 1)
1196                {
1197                    UnityPrint(UnityStrElement);
1198                    UnityPrintNumberUnsigned(num_elements - elements - 1);
1199                }
1200                UnityPrint(UnityStrByte);
1201                UnityPrintNumberUnsigned(length - bytes - 1);
1202                UnityPrint(UnityStrExpected);
1203                UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8);
1204                UnityPrint(UnityStrWas);
1205                UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8);
1206                UnityAddMsgIfSpecified(msg);
1207                UNITY_FAIL_AND_BAIL;
1208            }
1209            ptr_exp++;
1210            ptr_act++;
1211        }
1212        if (flags == UNITY_ARRAY_TO_VAL)
1213        {
1214            ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected;
1215        }
1216    }
1217}
1218
1219/*-----------------------------------------------*/
1220
1221static union
1222{
1223    UNITY_INT8 i8;
1224    UNITY_INT16 i16;
1225    UNITY_INT32 i32;
1226#ifdef UNITY_SUPPORT_64
1227    UNITY_INT64 i64;
1228#endif
1229#ifndef UNITY_EXCLUDE_FLOAT
1230    float f;
1231#endif
1232#ifndef UNITY_EXCLUDE_DOUBLE
1233    double d;
1234#endif
1235} UnityQuickCompare;
1236
1237UNITY_INTERNAL_PTR UnityNumToPtr(const UNITY_INT num, const UNITY_UINT8 size)
1238{
1239    switch(size)
1240    {
1241        case 1:
1242          UnityQuickCompare.i8 = (UNITY_INT8)num;
1243          return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i8);
1244
1245        case 2:
1246          UnityQuickCompare.i16 = (UNITY_INT16)num;
1247          return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i16);
1248
1249#ifdef UNITY_SUPPORT_64
1250        case 8:
1251          UnityQuickCompare.i64 = (UNITY_INT64)num;
1252          return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i64);
1253#endif
1254        default: /* 4 bytes */
1255          UnityQuickCompare.i32 = (UNITY_INT32)num;
1256          return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.i32);
1257    }
1258}
1259
1260#ifndef UNITY_EXCLUDE_FLOAT
1261UNITY_INTERNAL_PTR UnityFloatToPtr(const float num)
1262{
1263    UnityQuickCompare.f = num;
1264    return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.f);
1265}
1266#endif
1267
1268#ifndef UNITY_EXCLUDE_DOUBLE
1269UNITY_INTERNAL_PTR UnityDoubleToPtr(const double num)
1270{
1271    UnityQuickCompare.d = num;
1272    return (UNITY_INTERNAL_PTR)(&UnityQuickCompare.d);
1273}
1274#endif
1275
1276/*-----------------------------------------------
1277 * Control Functions
1278 *-----------------------------------------------*/
1279
1280void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
1281{
1282    RETURN_IF_FAIL_OR_IGNORE;
1283
1284    UnityTestResultsBegin(Unity.TestFile, line);
1285    UnityPrint(UnityStrFail);
1286    if (msg != NULL)
1287    {
1288        UNITY_OUTPUT_CHAR(':');
1289
1290#ifndef UNITY_EXCLUDE_DETAILS
1291        if (Unity.CurrentDetail1)
1292        {
1293            UnityPrint(UnityStrDetail1Name);
1294            UnityPrint(Unity.CurrentDetail1);
1295            if (Unity.CurrentDetail2)
1296            {
1297                UnityPrint(UnityStrDetail2Name);
1298                UnityPrint(Unity.CurrentDetail2);
1299            }
1300            UnityPrint(UnityStrSpacer);
1301        }
1302#endif
1303        if (msg[0] != ' ')
1304        {
1305            UNITY_OUTPUT_CHAR(' ');
1306        }
1307        UnityPrint(msg);
1308    }
1309
1310    UNITY_FAIL_AND_BAIL;
1311}
1312
1313/*-----------------------------------------------*/
1314void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line)
1315{
1316    RETURN_IF_FAIL_OR_IGNORE;
1317
1318    UnityTestResultsBegin(Unity.TestFile, line);
1319    UnityPrint(UnityStrIgnore);
1320    if (msg != NULL)
1321    {
1322        UNITY_OUTPUT_CHAR(':');
1323        UNITY_OUTPUT_CHAR(' ');
1324        UnityPrint(msg);
1325    }
1326    UNITY_IGNORE_AND_BAIL;
1327}
1328
1329/*-----------------------------------------------*/
1330void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum)
1331{
1332    Unity.CurrentTestName = FuncName;
1333    Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum;
1334    Unity.NumberOfTests++;
1335    UNITY_CLR_DETAILS();
1336    if (TEST_PROTECT())
1337    {
1338        setUp();
1339        Func();
1340    }
1341    if (TEST_PROTECT())
1342    {
1343        tearDown();
1344    }
1345    UnityConcludeTest();
1346}
1347
1348/*-----------------------------------------------*/
1349void UnityBegin(const char* filename)
1350{
1351    Unity.TestFile = filename;
1352    Unity.CurrentTestName = NULL;
1353    Unity.CurrentTestLineNumber = 0;
1354    Unity.NumberOfTests = 0;
1355    Unity.TestFailures = 0;
1356    Unity.TestIgnores = 0;
1357    Unity.CurrentTestFailed = 0;
1358    Unity.CurrentTestIgnored = 0;
1359
1360    UNITY_CLR_DETAILS();
1361    UNITY_OUTPUT_START();
1362}
1363
1364/*-----------------------------------------------*/
1365int UnityEnd(void)
1366{
1367    UNITY_PRINT_EOL();
1368    UnityPrint(UnityStrBreaker);
1369    UNITY_PRINT_EOL();
1370    UnityPrintNumber((UNITY_INT)(Unity.NumberOfTests));
1371    UnityPrint(UnityStrResultsTests);
1372    UnityPrintNumber((UNITY_INT)(Unity.TestFailures));
1373    UnityPrint(UnityStrResultsFailures);
1374    UnityPrintNumber((UNITY_INT)(Unity.TestIgnores));
1375    UnityPrint(UnityStrResultsIgnored);
1376    UNITY_PRINT_EOL();
1377    if (Unity.TestFailures == 0U)
1378    {
1379        UnityPrint(UnityStrOk);
1380    }
1381    else
1382    {
1383        UnityPrint(UnityStrFail);
1384#ifdef UNITY_DIFFERENTIATE_FINAL_FAIL
1385        UNITY_OUTPUT_CHAR('E'); UNITY_OUTPUT_CHAR('D');
1386#endif
1387    }
1388    UNITY_PRINT_EOL();
1389    UNITY_FLUSH_CALL();
1390    UNITY_OUTPUT_COMPLETE();
1391    return (int)(Unity.TestFailures);
1392}
1393
1394/*-----------------------------------------------
1395 * Command Line Argument Support
1396 *-----------------------------------------------*/
1397#ifdef UNITY_USE_COMMAND_LINE_ARGS
1398
1399char* UnityOptionIncludeNamed = NULL;
1400char* UnityOptionExcludeNamed = NULL;
1401int UnityVerbosity            = 1;
1402
1403int UnityParseOptions(int argc, char** argv)
1404{
1405    UnityOptionIncludeNamed = NULL;
1406    UnityOptionExcludeNamed = NULL;
1407
1408    for (int i = 1; i < argc; i++)
1409    {
1410        if (argv[i][0] == '-')
1411        {
1412            switch (argv[i][1])
1413            {
1414                case 'l': /* list tests */
1415                    return -1;
1416                case 'n': /* include tests with name including this string */
1417                case 'f': /* an alias for -n */
1418                    if (argv[i][2] == '=')
1419                        UnityOptionIncludeNamed = &argv[i][3];
1420                    else if (++i < argc)
1421                        UnityOptionIncludeNamed = argv[i];
1422                    else
1423                    {
1424                        UnityPrint("ERROR: No Test String to Include Matches For");
1425                        UNITY_PRINT_EOL();
1426                        return 1;
1427                    }
1428                    break;
1429                case 'q': /* quiet */
1430                    UnityVerbosity = 0;
1431                    break;
1432                case 'v': /* verbose */
1433                    UnityVerbosity = 2;
1434                    break;
1435                case 'x': /* exclude tests with name including this string */
1436                    if (argv[i][2] == '=')
1437                        UnityOptionExcludeNamed = &argv[i][3];
1438                    else if (++i < argc)
1439                        UnityOptionExcludeNamed = argv[i];
1440                    else
1441                    {
1442                        UnityPrint("ERROR: No Test String to Exclude Matches For");
1443                        UNITY_PRINT_EOL();
1444                        return 1;
1445                    }
1446                    break;
1447                default:
1448                    UnityPrint("ERROR: Unknown Option ");
1449                    UNITY_OUTPUT_CHAR(argv[i][1]);
1450                    UNITY_PRINT_EOL();
1451                    return 1;
1452            }
1453        }
1454    }
1455
1456    return 0;
1457}
1458
1459int IsStringInBiggerString(const char* longstring, const char* shortstring)
1460{
1461    const char* lptr = longstring;
1462    const char* sptr = shortstring;
1463    const char* lnext = lptr;
1464
1465    if (*sptr == '*')
1466        return 1;
1467
1468    while (*lptr)
1469    {
1470        lnext = lptr + 1;
1471
1472        /* If they current bytes match, go on to the next bytes */
1473        while (*lptr && *sptr && (*lptr == *sptr))
1474        {
1475            lptr++;
1476            sptr++;
1477
1478            /* We're done if we match the entire string or up to a wildcard */
1479            if (*sptr == '*')
1480                return 1;
1481            if (*sptr == ',')
1482                return 1;
1483            if (*sptr == '"')
1484                return 1;
1485            if (*sptr == '\'')
1486                return 1;
1487            if (*sptr == ':')
1488                return 2;
1489            if (*sptr == 0)
1490                return 1;
1491        }
1492
1493        /* Otherwise we start in the long pointer 1 character further and try again */
1494        lptr = lnext;
1495        sptr = shortstring;
1496    }
1497    return 0;
1498}
1499
1500int UnityStringArgumentMatches(const char* str)
1501{
1502    int retval;
1503    const char* ptr1;
1504    const char* ptr2;
1505    const char* ptrf;
1506
1507    /* Go through the options and get the substrings for matching one at a time */
1508    ptr1 = str;
1509    while (ptr1[0] != 0)
1510    {
1511        if ((ptr1[0] == '"') || (ptr1[0] == '\''))
1512            ptr1++;
1513
1514        /* look for the start of the next partial */
1515        ptr2 = ptr1;
1516        ptrf = 0;
1517        do
1518        {
1519            ptr2++;
1520            if ((ptr2[0] == ':') && (ptr2[1] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ','))
1521                ptrf = &ptr2[1];
1522        } while ((ptr2[0] != 0) && (ptr2[0] != '\'') && (ptr2[0] != '"') && (ptr2[0] != ','));
1523        while ((ptr2[0] != 0) && ((ptr2[0] == ':') || (ptr2[0] == '\'') || (ptr2[0] == '"') || (ptr2[0] == ',')))
1524            ptr2++;
1525
1526        /* done if complete filename match */
1527        retval = IsStringInBiggerString(Unity.TestFile, ptr1);
1528        if (retval == 1)
1529            return retval;
1530
1531        /* done if testname match after filename partial match */
1532        if ((retval == 2) && (ptrf != 0))
1533        {
1534            if (IsStringInBiggerString(Unity.CurrentTestName, ptrf))
1535                return 1;
1536        }
1537
1538        /* done if complete testname match */
1539        if (IsStringInBiggerString(Unity.CurrentTestName, ptr1) == 1)
1540            return 1;
1541
1542        ptr1 = ptr2;
1543    }
1544
1545    /* we couldn't find a match for any substrings */
1546    return 0;
1547}
1548
1549int UnityTestMatches(void)
1550{
1551    /* Check if this test name matches the included test pattern */
1552    int retval;
1553    if (UnityOptionIncludeNamed)
1554    {
1555        retval = UnityStringArgumentMatches(UnityOptionIncludeNamed);
1556    }
1557    else
1558        retval = 1;
1559
1560    /* Check if this test name matches the excluded test pattern */
1561    if (UnityOptionExcludeNamed)
1562    {
1563        if (UnityStringArgumentMatches(UnityOptionExcludeNamed))
1564            retval = 0;
1565    }
1566    return retval;
1567}
1568
1569#endif /* UNITY_USE_COMMAND_LINE_ARGS */
1570/*-----------------------------------------------*/