unity.c (40771B)
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 #include "unity.h" 8 #include <stddef.h> 9 10 #define UNITY_FAIL_AND_BAIL { Unity.CurrentTestFailed = 1; longjmp(Unity.AbortFrame, 1); } 11 #define UNITY_IGNORE_AND_BAIL { Unity.CurrentTestIgnored = 1; longjmp(Unity.AbortFrame, 1); } 12 /// return prematurely if we are already in failure or ignore state 13 #define UNITY_SKIP_EXECUTION { if ((Unity.CurrentTestFailed != 0) || (Unity.CurrentTestIgnored != 0)) {return;} } 14 #define UNITY_PRINT_EOL { UNITY_OUTPUT_CHAR('\n'); } 15 16 struct _Unity Unity; 17 18 const char UnityStrOk[] = "OK"; 19 const char UnityStrPass[] = "PASS"; 20 const char UnityStrFail[] = "FAIL"; 21 const char UnityStrIgnore[] = "IGNORE"; 22 const char UnityStrNull[] = "NULL"; 23 const char UnityStrSpacer[] = ". "; 24 const char UnityStrExpected[] = " Expected "; 25 const char UnityStrWas[] = " Was "; 26 const char UnityStrTo[] = " To "; 27 const char UnityStrElement[] = " Element "; 28 const char UnityStrByte[] = " Byte "; 29 const char UnityStrMemory[] = " Memory Mismatch."; 30 const char UnityStrDelta[] = " Values Not Within Delta "; 31 const char UnityStrPointless[] = " You Asked Me To Compare Nothing, Which Was Pointless."; 32 const char UnityStrNullPointerForExpected[] = " Expected pointer to be NULL"; 33 const char UnityStrNullPointerForActual[] = " Actual pointer was NULL"; 34 const char UnityStrNot[] = "Not "; 35 const char UnityStrInf[] = "Infinity"; 36 const char UnityStrNegInf[] = "Negative Infinity"; 37 const char UnityStrNaN[] = "NaN"; 38 const char UnityStrDet[] = "Determinate"; 39 const char UnityStrErrFloat[] = "Unity Floating Point Disabled"; 40 const char UnityStrErrDouble[] = "Unity Double Precision Disabled"; 41 const char UnityStrErr64[] = "Unity 64-bit Support Disabled"; 42 const char UnityStrBreaker[] = "-----------------------"; 43 const char UnityStrResultsTests[] = " Tests "; 44 const char UnityStrResultsFailures[] = " Failures "; 45 const char UnityStrResultsIgnored[] = " Ignored "; 46 47 #ifndef UNITY_EXCLUDE_FLOAT 48 // Dividing by these constants produces +/- infinity. 49 // The rationale is given in UnityAssertFloatIsInf's body. 50 static const _UF f_zero = 0.0f; 51 #ifndef UNITY_EXCLUDE_DOUBLE 52 static const _UD d_zero = 0.0; 53 #endif 54 #endif 55 56 // compiler-generic print formatting masks 57 const _U_UINT UnitySizeMask[] = 58 { 59 255u, // 0xFF 60 65535u, // 0xFFFF 61 65535u, 62 4294967295u, // 0xFFFFFFFF 63 4294967295u, 64 4294967295u, 65 4294967295u 66 #ifdef UNITY_SUPPORT_64 67 ,0xFFFFFFFFFFFFFFFF 68 #endif 69 }; 70 71 void UnityPrintFail(void); 72 void UnityPrintOk(void); 73 74 //----------------------------------------------- 75 // Pretty Printers & Test Result Output Handlers 76 //----------------------------------------------- 77 78 void UnityPrint(const char* string) 79 { 80 const char* pch = string; 81 82 if (pch != NULL) 83 { 84 while (*pch) 85 { 86 // printable characters plus CR & LF are printed 87 if ((*pch <= 126) && (*pch >= 32)) 88 { 89 UNITY_OUTPUT_CHAR(*pch); 90 } 91 //write escaped carriage returns 92 else if (*pch == 13) 93 { 94 UNITY_OUTPUT_CHAR('\\'); 95 UNITY_OUTPUT_CHAR('r'); 96 } 97 //write escaped line feeds 98 else if (*pch == 10) 99 { 100 UNITY_OUTPUT_CHAR('\\'); 101 UNITY_OUTPUT_CHAR('n'); 102 } 103 // unprintable characters are shown as codes 104 else 105 { 106 UNITY_OUTPUT_CHAR('\\'); 107 UnityPrintNumberHex((_U_UINT)*pch, 2); 108 } 109 pch++; 110 } 111 } 112 } 113 114 void UnityPrintLen(const char* string, const _UU32 length); 115 void UnityPrintLen(const char* string, const _UU32 length) 116 { 117 const char* pch = string; 118 119 if (pch != NULL) 120 { 121 while (*pch && (_UU32)(pch - string) < length) 122 { 123 // printable characters plus CR & LF are printed 124 if ((*pch <= 126) && (*pch >= 32)) 125 { 126 UNITY_OUTPUT_CHAR(*pch); 127 } 128 //write escaped carriage returns 129 else if (*pch == 13) 130 { 131 UNITY_OUTPUT_CHAR('\\'); 132 UNITY_OUTPUT_CHAR('r'); 133 } 134 //write escaped line feeds 135 else if (*pch == 10) 136 { 137 UNITY_OUTPUT_CHAR('\\'); 138 UNITY_OUTPUT_CHAR('n'); 139 } 140 // unprintable characters are shown as codes 141 else 142 { 143 UNITY_OUTPUT_CHAR('\\'); 144 UnityPrintNumberHex((_U_UINT)*pch, 2); 145 } 146 pch++; 147 } 148 } 149 } 150 151 //----------------------------------------------- 152 void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T style) 153 { 154 if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) 155 { 156 UnityPrintNumber(number); 157 } 158 else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT) 159 { 160 UnityPrintNumberUnsigned( (_U_UINT)number & UnitySizeMask[((_U_UINT)style & (_U_UINT)0x0F) - 1] ); 161 } 162 else 163 { 164 UnityPrintNumberHex((_U_UINT)number, (char)((style & 0x000F) << 1)); 165 } 166 } 167 168 //----------------------------------------------- 169 /// basically do an itoa using as little ram as possible 170 void UnityPrintNumber(const _U_SINT number_to_print) 171 { 172 _U_SINT divisor = 1; 173 _U_SINT next_divisor; 174 _U_UINT number; 175 176 if (number_to_print == (1l << (UNITY_LONG_WIDTH-1))) 177 { 178 //The largest representable negative number 179 UNITY_OUTPUT_CHAR('-'); 180 number = (1ul << (UNITY_LONG_WIDTH-1)); 181 } 182 else if (number_to_print < 0) 183 { 184 //Some other negative number 185 UNITY_OUTPUT_CHAR('-'); 186 number = (_U_UINT)(-number_to_print); 187 } 188 else 189 { 190 //Positive number 191 number = (_U_UINT)number_to_print; 192 } 193 194 // figure out initial divisor 195 while (number / divisor > 9) 196 { 197 next_divisor = divisor * 10; 198 if (next_divisor > divisor) 199 divisor = next_divisor; 200 else 201 break; 202 } 203 204 // now mod and print, then divide divisor 205 do 206 { 207 UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10))); 208 divisor /= 10; 209 } 210 while (divisor > 0); 211 } 212 213 //----------------------------------------------- 214 /// basically do an itoa using as little ram as possible 215 void UnityPrintNumberUnsigned(const _U_UINT number) 216 { 217 _U_UINT divisor = 1; 218 _U_UINT next_divisor; 219 220 // figure out initial divisor 221 while (number / divisor > 9) 222 { 223 next_divisor = divisor * 10; 224 if (next_divisor > divisor) 225 divisor = next_divisor; 226 else 227 break; 228 } 229 230 // now mod and print, then divide divisor 231 do 232 { 233 UNITY_OUTPUT_CHAR((char)('0' + (number / divisor % 10))); 234 divisor /= 10; 235 } 236 while (divisor > 0); 237 } 238 239 //----------------------------------------------- 240 void UnityPrintNumberHex(const _U_UINT number, const char nibbles_to_print) 241 { 242 _U_UINT nibble; 243 char nibbles = nibbles_to_print; 244 UNITY_OUTPUT_CHAR('0'); 245 UNITY_OUTPUT_CHAR('x'); 246 247 while (nibbles > 0) 248 { 249 nibble = (number >> (--nibbles << 2)) & 0x0000000F; 250 if (nibble <= 9) 251 { 252 UNITY_OUTPUT_CHAR((char)('0' + nibble)); 253 } 254 else 255 { 256 UNITY_OUTPUT_CHAR((char)('A' - 10 + nibble)); 257 } 258 } 259 } 260 261 //----------------------------------------------- 262 void UnityPrintMask(const _U_UINT mask, const _U_UINT number) 263 { 264 _U_UINT current_bit = (_U_UINT)1 << (UNITY_INT_WIDTH - 1); 265 _US32 i; 266 267 for (i = 0; i < UNITY_INT_WIDTH; i++) 268 { 269 if (current_bit & mask) 270 { 271 if (current_bit & number) 272 { 273 UNITY_OUTPUT_CHAR('1'); 274 } 275 else 276 { 277 UNITY_OUTPUT_CHAR('0'); 278 } 279 } 280 else 281 { 282 UNITY_OUTPUT_CHAR('X'); 283 } 284 current_bit = current_bit >> 1; 285 } 286 } 287 288 //----------------------------------------------- 289 #ifdef UNITY_FLOAT_VERBOSE 290 #include <string.h> 291 void UnityPrintFloat(_UF number) 292 { 293 char TempBuffer[32]; 294 sprintf(TempBuffer, "%.6f", number); 295 UnityPrint(TempBuffer); 296 } 297 #endif 298 299 //----------------------------------------------- 300 301 void UnityPrintFail(void); 302 void UnityPrintFail(void) 303 { 304 UnityPrint(UnityStrFail); 305 } 306 307 void UnityPrintOk(void); 308 void UnityPrintOk(void) 309 { 310 UnityPrint(UnityStrOk); 311 } 312 313 //----------------------------------------------- 314 static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line); 315 static void UnityTestResultsBegin(const char* file, const UNITY_LINE_TYPE line) 316 { 317 #ifndef UNITY_FIXTURES 318 UnityPrint(file); 319 UNITY_OUTPUT_CHAR(':'); 320 UnityPrintNumber((_U_SINT)line); 321 UNITY_OUTPUT_CHAR(':'); 322 UnityPrint(Unity.CurrentTestName); 323 UNITY_OUTPUT_CHAR(':'); 324 #else 325 UNITY_UNUSED(file); 326 UNITY_UNUSED(line); 327 #endif 328 } 329 330 //----------------------------------------------- 331 static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line); 332 static void UnityTestResultsFailBegin(const UNITY_LINE_TYPE line) 333 { 334 #ifndef UNITY_FIXTURES 335 UnityTestResultsBegin(Unity.TestFile, line); 336 #else 337 UNITY_UNUSED(line); 338 #endif 339 UnityPrint(UnityStrFail); 340 UNITY_OUTPUT_CHAR(':'); 341 } 342 343 //----------------------------------------------- 344 void UnityConcludeTest(void) 345 { 346 if (Unity.CurrentTestIgnored) 347 { 348 Unity.TestIgnores++; 349 } 350 else if (!Unity.CurrentTestFailed) 351 { 352 UnityTestResultsBegin(Unity.TestFile, Unity.CurrentTestLineNumber); 353 UnityPrint(UnityStrPass); 354 } 355 else 356 { 357 Unity.TestFailures++; 358 } 359 360 Unity.CurrentTestFailed = 0; 361 Unity.CurrentTestIgnored = 0; 362 UNITY_PRINT_EOL; 363 } 364 365 //----------------------------------------------- 366 static void UnityAddMsgIfSpecified(const char* msg); 367 static void UnityAddMsgIfSpecified(const char* msg) 368 { 369 if (msg) 370 { 371 UnityPrint(UnityStrSpacer); 372 UnityPrint(msg); 373 } 374 } 375 376 //----------------------------------------------- 377 static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual); 378 static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual) 379 { 380 UnityPrint(UnityStrExpected); 381 if (expected != NULL) 382 { 383 UNITY_OUTPUT_CHAR('\''); 384 UnityPrint(expected); 385 UNITY_OUTPUT_CHAR('\''); 386 } 387 else 388 { 389 UnityPrint(UnityStrNull); 390 } 391 UnityPrint(UnityStrWas); 392 if (actual != NULL) 393 { 394 UNITY_OUTPUT_CHAR('\''); 395 UnityPrint(actual); 396 UNITY_OUTPUT_CHAR('\''); 397 } 398 else 399 { 400 UnityPrint(UnityStrNull); 401 } 402 } 403 404 //----------------------------------------------- 405 static void UnityPrintExpectedAndActualStringsLen(const char* expected, const char* actual, const _UU32 length) 406 { 407 UnityPrint(UnityStrExpected); 408 if (expected != NULL) 409 { 410 UNITY_OUTPUT_CHAR('\''); 411 UnityPrintLen(expected, length); 412 UNITY_OUTPUT_CHAR('\''); 413 } 414 else 415 { 416 UnityPrint(UnityStrNull); 417 } 418 UnityPrint(UnityStrWas); 419 if (actual != NULL) 420 { 421 UNITY_OUTPUT_CHAR('\''); 422 UnityPrintLen(actual, length); 423 UNITY_OUTPUT_CHAR('\''); 424 } 425 else 426 { 427 UnityPrint(UnityStrNull); 428 } 429 } 430 431 432 433 //----------------------------------------------- 434 // Assertion & Control Helpers 435 //----------------------------------------------- 436 437 static int UnityCheckArraysForNull(UNITY_PTR_ATTRIBUTE const void* expected, UNITY_PTR_ATTRIBUTE const void* actual, const UNITY_LINE_TYPE lineNumber, const char* msg) 438 { 439 //return true if they are both NULL 440 if ((expected == NULL) && (actual == NULL)) 441 return 1; 442 443 //throw error if just expected is NULL 444 if (expected == NULL) 445 { 446 UnityTestResultsFailBegin(lineNumber); 447 UnityPrint(UnityStrNullPointerForExpected); 448 UnityAddMsgIfSpecified(msg); 449 UNITY_FAIL_AND_BAIL; 450 } 451 452 //throw error if just actual is NULL 453 if (actual == NULL) 454 { 455 UnityTestResultsFailBegin(lineNumber); 456 UnityPrint(UnityStrNullPointerForActual); 457 UnityAddMsgIfSpecified(msg); 458 UNITY_FAIL_AND_BAIL; 459 } 460 461 //return false if neither is NULL 462 return 0; 463 } 464 465 //----------------------------------------------- 466 // Assertion Functions 467 //----------------------------------------------- 468 469 void UnityAssertBits(const _U_SINT mask, 470 const _U_SINT expected, 471 const _U_SINT actual, 472 const char* msg, 473 const UNITY_LINE_TYPE lineNumber) 474 { 475 UNITY_SKIP_EXECUTION; 476 477 if ((mask & expected) != (mask & actual)) 478 { 479 UnityTestResultsFailBegin(lineNumber); 480 UnityPrint(UnityStrExpected); 481 UnityPrintMask((_U_UINT)mask, (_U_UINT)expected); 482 UnityPrint(UnityStrWas); 483 UnityPrintMask((_U_UINT)mask, (_U_UINT)actual); 484 UnityAddMsgIfSpecified(msg); 485 UNITY_FAIL_AND_BAIL; 486 } 487 } 488 489 //----------------------------------------------- 490 void UnityAssertEqualNumber(const _U_SINT expected, 491 const _U_SINT actual, 492 const char* msg, 493 const UNITY_LINE_TYPE lineNumber, 494 const UNITY_DISPLAY_STYLE_T style) 495 { 496 UNITY_SKIP_EXECUTION; 497 498 if (expected != actual) 499 { 500 UnityTestResultsFailBegin(lineNumber); 501 UnityPrint(UnityStrExpected); 502 UnityPrintNumberByStyle(expected, style); 503 UnityPrint(UnityStrWas); 504 UnityPrintNumberByStyle(actual, style); 505 UnityAddMsgIfSpecified(msg); 506 UNITY_FAIL_AND_BAIL; 507 } 508 } 509 510 //----------------------------------------------- 511 void UnityAssertEqualIntArray(UNITY_PTR_ATTRIBUTE const void* expected, 512 UNITY_PTR_ATTRIBUTE const void* actual, 513 const _UU32 num_elements, 514 const char* msg, 515 const UNITY_LINE_TYPE lineNumber, 516 const UNITY_DISPLAY_STYLE_T style) 517 { 518 _UU32 elements = num_elements; 519 UNITY_PTR_ATTRIBUTE const void* ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)expected; 520 UNITY_PTR_ATTRIBUTE const void* ptr_act = (UNITY_PTR_ATTRIBUTE const void*)actual; 521 522 UNITY_SKIP_EXECUTION; 523 524 if (elements == 0) 525 { 526 UnityTestResultsFailBegin(lineNumber); 527 UnityPrint(UnityStrPointless); 528 UnityAddMsgIfSpecified(msg); 529 UNITY_FAIL_AND_BAIL; 530 } 531 532 if (UnityCheckArraysForNull((UNITY_PTR_ATTRIBUTE const void*)expected, (UNITY_PTR_ATTRIBUTE const void*)actual, lineNumber, msg) == 1) 533 return; 534 535 // If style is UNITY_DISPLAY_STYLE_INT, we'll fall into the default case rather than the INT16 or INT32 (etc) case 536 // as UNITY_DISPLAY_STYLE_INT includes a flag for UNITY_DISPLAY_RANGE_AUTO, which the width-specific 537 // variants do not. Therefore remove this flag. 538 switch(style & (UNITY_DISPLAY_STYLE_T)(~UNITY_DISPLAY_RANGE_AUTO)) 539 { 540 case UNITY_DISPLAY_STYLE_HEX8: 541 case UNITY_DISPLAY_STYLE_INT8: 542 case UNITY_DISPLAY_STYLE_UINT8: 543 while (elements--) 544 { 545 if (*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US8*)ptr_act) 546 { 547 UnityTestResultsFailBegin(lineNumber); 548 UnityPrint(UnityStrElement); 549 UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); 550 UnityPrint(UnityStrExpected); 551 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_exp, style); 552 UnityPrint(UnityStrWas); 553 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US8*)ptr_act, style); 554 UnityAddMsgIfSpecified(msg); 555 UNITY_FAIL_AND_BAIL; 556 } 557 ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_exp + 1); 558 ptr_act = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_act + 1); 559 } 560 break; 561 case UNITY_DISPLAY_STYLE_HEX16: 562 case UNITY_DISPLAY_STYLE_INT16: 563 case UNITY_DISPLAY_STYLE_UINT16: 564 while (elements--) 565 { 566 if (*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US16*)ptr_act) 567 { 568 UnityTestResultsFailBegin(lineNumber); 569 UnityPrint(UnityStrElement); 570 UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); 571 UnityPrint(UnityStrExpected); 572 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_exp, style); 573 UnityPrint(UnityStrWas); 574 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US16*)ptr_act, style); 575 UnityAddMsgIfSpecified(msg); 576 UNITY_FAIL_AND_BAIL; 577 } 578 ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_exp + 2); 579 ptr_act = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_act + 2); 580 } 581 break; 582 #ifdef UNITY_SUPPORT_64 583 case UNITY_DISPLAY_STYLE_HEX64: 584 case UNITY_DISPLAY_STYLE_INT64: 585 case UNITY_DISPLAY_STYLE_UINT64: 586 while (elements--) 587 { 588 if (*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US64*)ptr_act) 589 { 590 UnityTestResultsFailBegin(lineNumber); 591 UnityPrint(UnityStrElement); 592 UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); 593 UnityPrint(UnityStrExpected); 594 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_exp, style); 595 UnityPrint(UnityStrWas); 596 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US64*)ptr_act, style); 597 UnityAddMsgIfSpecified(msg); 598 UNITY_FAIL_AND_BAIL; 599 } 600 ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_exp + 8); 601 ptr_act = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_act + 8); 602 } 603 break; 604 #endif 605 default: 606 while (elements--) 607 { 608 if (*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_exp != *(UNITY_PTR_ATTRIBUTE const _US32*)ptr_act) 609 { 610 UnityTestResultsFailBegin(lineNumber); 611 UnityPrint(UnityStrElement); 612 UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); 613 UnityPrint(UnityStrExpected); 614 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_exp, style); 615 UnityPrint(UnityStrWas); 616 UnityPrintNumberByStyle(*(UNITY_PTR_ATTRIBUTE const _US32*)ptr_act, style); 617 UnityAddMsgIfSpecified(msg); 618 UNITY_FAIL_AND_BAIL; 619 } 620 ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_exp + 4); 621 ptr_act = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_act + 4); 622 } 623 break; 624 } 625 } 626 627 //----------------------------------------------- 628 #ifndef UNITY_EXCLUDE_FLOAT 629 void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const _UF* expected, 630 UNITY_PTR_ATTRIBUTE const _UF* actual, 631 const _UU32 num_elements, 632 const char* msg, 633 const UNITY_LINE_TYPE lineNumber) 634 { 635 _UU32 elements = num_elements; 636 UNITY_PTR_ATTRIBUTE const _UF* ptr_expected = expected; 637 UNITY_PTR_ATTRIBUTE const _UF* ptr_actual = actual; 638 _UF diff, tol; 639 640 UNITY_SKIP_EXECUTION; 641 642 if (elements == 0) 643 { 644 UnityTestResultsFailBegin(lineNumber); 645 UnityPrint(UnityStrPointless); 646 UnityAddMsgIfSpecified(msg); 647 UNITY_FAIL_AND_BAIL; 648 } 649 650 if (UnityCheckArraysForNull((UNITY_PTR_ATTRIBUTE const void*)expected, (UNITY_PTR_ATTRIBUTE const void*)actual, lineNumber, msg) == 1) 651 return; 652 653 while (elements--) 654 { 655 diff = *ptr_expected - *ptr_actual; 656 if (diff < 0.0f) 657 diff = 0.0f - diff; 658 tol = UNITY_FLOAT_PRECISION * *ptr_expected; 659 if (tol < 0.0f) 660 tol = 0.0f - tol; 661 662 //This first part of this condition will catch any NaN or Infinite values 663 if ((diff * 0.0f != 0.0f) || (diff > tol)) 664 { 665 UnityTestResultsFailBegin(lineNumber); 666 UnityPrint(UnityStrElement); 667 UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); 668 #ifdef UNITY_FLOAT_VERBOSE 669 UnityPrint(UnityStrExpected); 670 UnityPrintFloat(*ptr_expected); 671 UnityPrint(UnityStrWas); 672 UnityPrintFloat(*ptr_actual); 673 #else 674 UnityPrint(UnityStrDelta); 675 #endif 676 UnityAddMsgIfSpecified(msg); 677 UNITY_FAIL_AND_BAIL; 678 } 679 ptr_expected++; 680 ptr_actual++; 681 } 682 } 683 684 //----------------------------------------------- 685 void UnityAssertFloatsWithin(const _UF delta, 686 const _UF expected, 687 const _UF actual, 688 const char* msg, 689 const UNITY_LINE_TYPE lineNumber) 690 { 691 _UF diff = actual - expected; 692 _UF pos_delta = delta; 693 694 UNITY_SKIP_EXECUTION; 695 696 if (diff < 0.0f) 697 { 698 diff = 0.0f - diff; 699 } 700 if (pos_delta < 0.0f) 701 { 702 pos_delta = 0.0f - pos_delta; 703 } 704 705 //This first part of this condition will catch any NaN or Infinite values 706 if ((diff * 0.0f != 0.0f) || (pos_delta < diff)) 707 { 708 UnityTestResultsFailBegin(lineNumber); 709 #ifdef UNITY_FLOAT_VERBOSE 710 UnityPrint(UnityStrExpected); 711 UnityPrintFloat(expected); 712 UnityPrint(UnityStrWas); 713 UnityPrintFloat(actual); 714 #else 715 UnityPrint(UnityStrDelta); 716 #endif 717 UnityAddMsgIfSpecified(msg); 718 UNITY_FAIL_AND_BAIL; 719 } 720 } 721 722 //----------------------------------------------- 723 void UnityAssertFloatSpecial(const _UF actual, 724 const char* msg, 725 const UNITY_LINE_TYPE lineNumber, 726 const UNITY_FLOAT_TRAIT_T style) 727 { 728 const char* trait_names[] = { UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet }; 729 _U_SINT should_be_trait = ((_U_SINT)style & 1); 730 _U_SINT is_trait = !should_be_trait; 731 _U_SINT trait_index = style >> 1; 732 733 UNITY_SKIP_EXECUTION; 734 735 switch(style) 736 { 737 //To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly 738 //We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise 739 case UNITY_FLOAT_IS_INF: 740 case UNITY_FLOAT_IS_NOT_INF: 741 is_trait = ((1.0f / f_zero) == actual) ? 1 : 0; 742 break; 743 case UNITY_FLOAT_IS_NEG_INF: 744 case UNITY_FLOAT_IS_NOT_NEG_INF: 745 is_trait = ((-1.0f / f_zero) == actual) ? 1 : 0; 746 break; 747 748 //NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN. 749 case UNITY_FLOAT_IS_NAN: 750 case UNITY_FLOAT_IS_NOT_NAN: 751 is_trait = (actual == actual) ? 0 : 1; 752 break; 753 754 //A determinate number is non infinite and not NaN. (therefore the opposite of the two above) 755 case UNITY_FLOAT_IS_DET: 756 case UNITY_FLOAT_IS_NOT_DET: 757 if ( (actual != actual) || ((1.0f / f_zero) == actual) || ((-1.0f / f_zero) == actual) ) 758 is_trait = 0; 759 else 760 is_trait = 1; 761 break; 762 default: 763 ; 764 } 765 766 if (is_trait != should_be_trait) 767 { 768 UnityTestResultsFailBegin(lineNumber); 769 UnityPrint(UnityStrExpected); 770 if (!should_be_trait) 771 UnityPrint(UnityStrNot); 772 UnityPrint(trait_names[trait_index]); 773 UnityPrint(UnityStrWas); 774 #ifdef UNITY_FLOAT_VERBOSE 775 UnityPrintFloat(actual); 776 #else 777 if (should_be_trait) 778 UnityPrint(UnityStrNot); 779 UnityPrint(trait_names[trait_index]); 780 #endif 781 UnityAddMsgIfSpecified(msg); 782 UNITY_FAIL_AND_BAIL; 783 } 784 } 785 786 #endif //not UNITY_EXCLUDE_FLOAT 787 788 //----------------------------------------------- 789 #ifndef UNITY_EXCLUDE_DOUBLE 790 void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const _UD* expected, 791 UNITY_PTR_ATTRIBUTE const _UD* actual, 792 const _UU32 num_elements, 793 const char* msg, 794 const UNITY_LINE_TYPE lineNumber) 795 { 796 _UU32 elements = num_elements; 797 UNITY_PTR_ATTRIBUTE const _UD* ptr_expected = expected; 798 UNITY_PTR_ATTRIBUTE const _UD* ptr_actual = actual; 799 _UD diff, tol; 800 801 UNITY_SKIP_EXECUTION; 802 803 if (elements == 0) 804 { 805 UnityTestResultsFailBegin(lineNumber); 806 UnityPrint(UnityStrPointless); 807 UnityAddMsgIfSpecified(msg); 808 UNITY_FAIL_AND_BAIL; 809 } 810 811 if (UnityCheckArraysForNull((UNITY_PTR_ATTRIBUTE void*)expected, (UNITY_PTR_ATTRIBUTE void*)actual, lineNumber, msg) == 1) 812 return; 813 814 while (elements--) 815 { 816 diff = *ptr_expected - *ptr_actual; 817 if (diff < 0.0) 818 diff = 0.0 - diff; 819 tol = UNITY_DOUBLE_PRECISION * *ptr_expected; 820 if (tol < 0.0) 821 tol = 0.0 - tol; 822 823 //This first part of this condition will catch any NaN or Infinite values 824 if ((diff * 0.0 != 0.0) || (diff > tol)) 825 { 826 UnityTestResultsFailBegin(lineNumber); 827 UnityPrint(UnityStrElement); 828 UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); 829 #ifdef UNITY_DOUBLE_VERBOSE 830 UnityPrint(UnityStrExpected); 831 UnityPrintFloat((float)(*ptr_expected)); 832 UnityPrint(UnityStrWas); 833 UnityPrintFloat((float)(*ptr_actual)); 834 #else 835 UnityPrint(UnityStrDelta); 836 #endif 837 UnityAddMsgIfSpecified(msg); 838 UNITY_FAIL_AND_BAIL; 839 } 840 ptr_expected++; 841 ptr_actual++; 842 } 843 } 844 845 //----------------------------------------------- 846 void UnityAssertDoublesWithin(const _UD delta, 847 const _UD expected, 848 const _UD actual, 849 const char* msg, 850 const UNITY_LINE_TYPE lineNumber) 851 { 852 _UD diff = actual - expected; 853 _UD pos_delta = delta; 854 855 UNITY_SKIP_EXECUTION; 856 857 if (diff < 0.0) 858 { 859 diff = 0.0 - diff; 860 } 861 if (pos_delta < 0.0) 862 { 863 pos_delta = 0.0 - pos_delta; 864 } 865 866 //This first part of this condition will catch any NaN or Infinite values 867 if ((diff * 0.0 != 0.0) || (pos_delta < diff)) 868 { 869 UnityTestResultsFailBegin(lineNumber); 870 #ifdef UNITY_DOUBLE_VERBOSE 871 UnityPrint(UnityStrExpected); 872 UnityPrintFloat((float)expected); 873 UnityPrint(UnityStrWas); 874 UnityPrintFloat((float)actual); 875 #else 876 UnityPrint(UnityStrDelta); 877 #endif 878 UnityAddMsgIfSpecified(msg); 879 UNITY_FAIL_AND_BAIL; 880 } 881 } 882 883 //----------------------------------------------- 884 885 void UnityAssertDoubleSpecial(const _UD actual, 886 const char* msg, 887 const UNITY_LINE_TYPE lineNumber, 888 const UNITY_FLOAT_TRAIT_T style) 889 { 890 const char* trait_names[] = { UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet }; 891 _U_SINT should_be_trait = ((_U_SINT)style & 1); 892 _U_SINT is_trait = !should_be_trait; 893 _U_SINT trait_index = style >> 1; 894 895 UNITY_SKIP_EXECUTION; 896 897 switch(style) 898 { 899 //To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly 900 //We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise 901 case UNITY_FLOAT_IS_INF: 902 case UNITY_FLOAT_IS_NOT_INF: 903 is_trait = ((1.0 / d_zero) == actual) ? 1 : 0; 904 break; 905 case UNITY_FLOAT_IS_NEG_INF: 906 case UNITY_FLOAT_IS_NOT_NEG_INF: 907 is_trait = ((-1.0 / d_zero) == actual) ? 1 : 0; 908 break; 909 910 //NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN. 911 case UNITY_FLOAT_IS_NAN: 912 case UNITY_FLOAT_IS_NOT_NAN: 913 is_trait = (actual == actual) ? 0 : 1; 914 break; 915 916 //A determinate number is non infinite and not NaN. (therefore the opposite of the two above) 917 case UNITY_FLOAT_IS_DET: 918 case UNITY_FLOAT_IS_NOT_DET: 919 if ( (actual != actual) || ((1.0 / d_zero) == actual) || ((-1.0 / d_zero) == actual) ) 920 is_trait = 0; 921 else 922 is_trait = 1; 923 break; 924 default: 925 ; 926 } 927 928 if (is_trait != should_be_trait) 929 { 930 UnityTestResultsFailBegin(lineNumber); 931 UnityPrint(UnityStrExpected); 932 if (!should_be_trait) 933 UnityPrint(UnityStrNot); 934 UnityPrint(trait_names[trait_index]); 935 UnityPrint(UnityStrWas); 936 #ifdef UNITY_DOUBLE_VERBOSE 937 UnityPrintFloat(actual); 938 #else 939 if (should_be_trait) 940 UnityPrint(UnityStrNot); 941 UnityPrint(trait_names[trait_index]); 942 #endif 943 UnityAddMsgIfSpecified(msg); 944 UNITY_FAIL_AND_BAIL; 945 } 946 } 947 948 949 #endif // not UNITY_EXCLUDE_DOUBLE 950 951 //----------------------------------------------- 952 void UnityAssertNumbersWithin( const _U_SINT delta, 953 const _U_SINT expected, 954 const _U_SINT actual, 955 const char* msg, 956 const UNITY_LINE_TYPE lineNumber, 957 const UNITY_DISPLAY_STYLE_T style) 958 { 959 UNITY_SKIP_EXECUTION; 960 961 if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) 962 { 963 if (actual > expected) 964 Unity.CurrentTestFailed = ((actual - expected) > delta); 965 else 966 Unity.CurrentTestFailed = ((expected - actual) > delta); 967 } 968 else 969 { 970 if ((_U_UINT)actual > (_U_UINT)expected) 971 Unity.CurrentTestFailed = ((_U_UINT)(actual - expected) > (_U_UINT)delta); 972 else 973 Unity.CurrentTestFailed = ((_U_UINT)(expected - actual) > (_U_UINT)delta); 974 } 975 976 if (Unity.CurrentTestFailed) 977 { 978 UnityTestResultsFailBegin(lineNumber); 979 UnityPrint(UnityStrDelta); 980 UnityPrintNumberByStyle(delta, style); 981 UnityPrint(UnityStrExpected); 982 UnityPrintNumberByStyle(expected, style); 983 UnityPrint(UnityStrWas); 984 UnityPrintNumberByStyle(actual, style); 985 UnityAddMsgIfSpecified(msg); 986 UNITY_FAIL_AND_BAIL; 987 } 988 } 989 990 //----------------------------------------------- 991 void UnityAssertEqualString(const char* expected, 992 const char* actual, 993 const char* msg, 994 const UNITY_LINE_TYPE lineNumber) 995 { 996 _UU32 i; 997 998 UNITY_SKIP_EXECUTION; 999 1000 // if both pointers not null compare the strings 1001 if (expected && actual) 1002 { 1003 for (i = 0; expected[i] || actual[i]; i++) 1004 { 1005 if (expected[i] != actual[i]) 1006 { 1007 Unity.CurrentTestFailed = 1; 1008 break; 1009 } 1010 } 1011 } 1012 else 1013 { // handle case of one pointers being null (if both null, test should pass) 1014 if (expected != actual) 1015 { 1016 Unity.CurrentTestFailed = 1; 1017 } 1018 } 1019 1020 if (Unity.CurrentTestFailed) 1021 { 1022 UnityTestResultsFailBegin(lineNumber); 1023 UnityPrintExpectedAndActualStrings(expected, actual); 1024 UnityAddMsgIfSpecified(msg); 1025 UNITY_FAIL_AND_BAIL; 1026 } 1027 } 1028 1029 //----------------------------------------------- 1030 void UnityAssertEqualStringLen(const char* expected, 1031 const char* actual, 1032 const _UU32 length, 1033 const char* msg, 1034 const UNITY_LINE_TYPE lineNumber) 1035 { 1036 _UU32 i; 1037 1038 UNITY_SKIP_EXECUTION; 1039 1040 // if both pointers not null compare the strings 1041 if (expected && actual) 1042 { 1043 for (i = 0; (expected[i] || actual[i]) && i < length; i++) 1044 { 1045 if (expected[i] != actual[i]) 1046 { 1047 Unity.CurrentTestFailed = 1; 1048 break; 1049 } 1050 } 1051 } 1052 else 1053 { // handle case of one pointers being null (if both null, test should pass) 1054 if (expected != actual) 1055 { 1056 Unity.CurrentTestFailed = 1; 1057 } 1058 } 1059 1060 if (Unity.CurrentTestFailed) 1061 { 1062 UnityTestResultsFailBegin(lineNumber); 1063 UnityPrintExpectedAndActualStringsLen(expected, actual, length); 1064 UnityAddMsgIfSpecified(msg); 1065 UNITY_FAIL_AND_BAIL; 1066 } 1067 } 1068 1069 1070 //----------------------------------------------- 1071 void UnityAssertEqualStringArray( const char** expected, 1072 const char** actual, 1073 const _UU32 num_elements, 1074 const char* msg, 1075 const UNITY_LINE_TYPE lineNumber) 1076 { 1077 _UU32 i, j = 0; 1078 1079 UNITY_SKIP_EXECUTION; 1080 1081 // if no elements, it's an error 1082 if (num_elements == 0) 1083 { 1084 UnityTestResultsFailBegin(lineNumber); 1085 UnityPrint(UnityStrPointless); 1086 UnityAddMsgIfSpecified(msg); 1087 UNITY_FAIL_AND_BAIL; 1088 } 1089 1090 if (UnityCheckArraysForNull((UNITY_PTR_ATTRIBUTE void*)expected, (UNITY_PTR_ATTRIBUTE void*)actual, lineNumber, msg) == 1) 1091 return; 1092 1093 do 1094 { 1095 // if both pointers not null compare the strings 1096 if (expected[j] && actual[j]) 1097 { 1098 for (i = 0; expected[j][i] || actual[j][i]; i++) 1099 { 1100 if (expected[j][i] != actual[j][i]) 1101 { 1102 Unity.CurrentTestFailed = 1; 1103 break; 1104 } 1105 } 1106 } 1107 else 1108 { // handle case of one pointers being null (if both null, test should pass) 1109 if (expected[j] != actual[j]) 1110 { 1111 Unity.CurrentTestFailed = 1; 1112 } 1113 } 1114 1115 if (Unity.CurrentTestFailed) 1116 { 1117 UnityTestResultsFailBegin(lineNumber); 1118 if (num_elements > 1) 1119 { 1120 UnityPrint(UnityStrElement); 1121 UnityPrintNumberByStyle((j), UNITY_DISPLAY_STYLE_UINT); 1122 } 1123 UnityPrintExpectedAndActualStrings((const char*)(expected[j]), (const char*)(actual[j])); 1124 UnityAddMsgIfSpecified(msg); 1125 UNITY_FAIL_AND_BAIL; 1126 } 1127 } while (++j < num_elements); 1128 } 1129 1130 //----------------------------------------------- 1131 void UnityAssertEqualMemory( UNITY_PTR_ATTRIBUTE const void* expected, 1132 UNITY_PTR_ATTRIBUTE const void* actual, 1133 const _UU32 length, 1134 const _UU32 num_elements, 1135 const char* msg, 1136 const UNITY_LINE_TYPE lineNumber) 1137 { 1138 UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected; 1139 UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual; 1140 _UU32 elements = num_elements; 1141 _UU32 bytes; 1142 1143 UNITY_SKIP_EXECUTION; 1144 1145 if ((elements == 0) || (length == 0)) 1146 { 1147 UnityTestResultsFailBegin(lineNumber); 1148 UnityPrint(UnityStrPointless); 1149 UnityAddMsgIfSpecified(msg); 1150 UNITY_FAIL_AND_BAIL; 1151 } 1152 1153 if (UnityCheckArraysForNull((UNITY_PTR_ATTRIBUTE const void*)expected, (UNITY_PTR_ATTRIBUTE const void*)actual, lineNumber, msg) == 1) 1154 return; 1155 1156 while (elements--) 1157 { 1158 ///////////////////////////////////// 1159 bytes = length; 1160 while (bytes--) 1161 { 1162 if (*ptr_exp != *ptr_act) 1163 { 1164 UnityTestResultsFailBegin(lineNumber); 1165 UnityPrint(UnityStrMemory); 1166 if (num_elements > 1) 1167 { 1168 UnityPrint(UnityStrElement); 1169 UnityPrintNumberByStyle((num_elements - elements - 1), UNITY_DISPLAY_STYLE_UINT); 1170 } 1171 UnityPrint(UnityStrByte); 1172 UnityPrintNumberByStyle((length - bytes - 1), UNITY_DISPLAY_STYLE_UINT); 1173 UnityPrint(UnityStrExpected); 1174 UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8); 1175 UnityPrint(UnityStrWas); 1176 UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8); 1177 UnityAddMsgIfSpecified(msg); 1178 UNITY_FAIL_AND_BAIL; 1179 } 1180 ptr_exp = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_exp + 1); 1181 ptr_act = (UNITY_PTR_ATTRIBUTE const void*)((_UP)ptr_act + 1); 1182 } 1183 ///////////////////////////////////// 1184 1185 } 1186 } 1187 1188 //----------------------------------------------- 1189 // Control Functions 1190 //----------------------------------------------- 1191 1192 void UnityFail(const char* msg, const UNITY_LINE_TYPE line) 1193 { 1194 UNITY_SKIP_EXECUTION; 1195 1196 UnityTestResultsBegin(Unity.TestFile, line); 1197 UnityPrintFail(); 1198 if (msg != NULL) 1199 { 1200 UNITY_OUTPUT_CHAR(':'); 1201 if (msg[0] != ' ') 1202 { 1203 UNITY_OUTPUT_CHAR(' '); 1204 } 1205 UnityPrint(msg); 1206 } 1207 UNITY_FAIL_AND_BAIL; 1208 } 1209 1210 //----------------------------------------------- 1211 void UnityIgnore(const char* msg, const UNITY_LINE_TYPE line) 1212 { 1213 UNITY_SKIP_EXECUTION; 1214 1215 UnityTestResultsBegin(Unity.TestFile, line); 1216 UnityPrint(UnityStrIgnore); 1217 if (msg != NULL) 1218 { 1219 UNITY_OUTPUT_CHAR(':'); 1220 UNITY_OUTPUT_CHAR(' '); 1221 UnityPrint(msg); 1222 } 1223 UNITY_IGNORE_AND_BAIL; 1224 } 1225 1226 //----------------------------------------------- 1227 #if defined(UNITY_WEAK_ATTRIBUTE) 1228 void setUp(void); 1229 void tearDown(void); 1230 UNITY_WEAK_ATTRIBUTE void setUp(void) { } 1231 UNITY_WEAK_ATTRIBUTE void tearDown(void) { } 1232 #elif defined(UNITY_WEAK_PRAGMA) 1233 # pragma weak setUp 1234 void setUp(void); 1235 # pragma weak tearDown 1236 void tearDown(void); 1237 #else 1238 void setUp(void); 1239 void tearDown(void); 1240 #endif 1241 //----------------------------------------------- 1242 void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int FuncLineNum) 1243 { 1244 Unity.CurrentTestName = FuncName; 1245 Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum; 1246 Unity.NumberOfTests++; 1247 if (TEST_PROTECT()) 1248 { 1249 setUp(); 1250 Func(); 1251 } 1252 if (TEST_PROTECT() && !(Unity.CurrentTestIgnored)) 1253 { 1254 tearDown(); 1255 } 1256 UnityConcludeTest(); 1257 } 1258 1259 //----------------------------------------------- 1260 void UnityBegin(const char* filename) 1261 { 1262 Unity.TestFile = filename; 1263 Unity.CurrentTestName = NULL; 1264 Unity.CurrentTestLineNumber = 0; 1265 Unity.NumberOfTests = 0; 1266 Unity.TestFailures = 0; 1267 Unity.TestIgnores = 0; 1268 Unity.CurrentTestFailed = 0; 1269 Unity.CurrentTestIgnored = 0; 1270 1271 UNITY_OUTPUT_START(); 1272 } 1273 1274 //----------------------------------------------- 1275 int UnityEnd(void) 1276 { 1277 UNITY_PRINT_EOL; 1278 UnityPrint(UnityStrBreaker); 1279 UNITY_PRINT_EOL; 1280 UnityPrintNumber((_U_SINT)(Unity.NumberOfTests)); 1281 UnityPrint(UnityStrResultsTests); 1282 UnityPrintNumber((_U_SINT)(Unity.TestFailures)); 1283 UnityPrint(UnityStrResultsFailures); 1284 UnityPrintNumber((_U_SINT)(Unity.TestIgnores)); 1285 UnityPrint(UnityStrResultsIgnored); 1286 UNITY_PRINT_EOL; 1287 if (Unity.TestFailures == 0U) 1288 { 1289 UnityPrintOk(); 1290 } 1291 else 1292 { 1293 UnityPrintFail(); 1294 } 1295 UNITY_PRINT_EOL; 1296 UNITY_OUTPUT_COMPLETE(); 1297 return (int)(Unity.TestFailures); 1298 } 1299 1300 //-----------------------------------------------