1/* ========================================== 2 Unity Project - A Test Framework for C 3 Copyright (c) 2007 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#define TEST_INSTANCES 9#include "self_assessment_utils.h" 10 11static int SetToOneToFailInTearDown; 12static int SetToOneMeanWeAlreadyCheckedThisGuy; 13 14void setUp(void) 15{ 16 SetToOneToFailInTearDown = 0; 17 SetToOneMeanWeAlreadyCheckedThisGuy = 0; 18} 19 20void tearDown(void) 21{ 22 endPutcharSpy(); /* Stop suppressing test output */ 23 if (SetToOneToFailInTearDown == 1) 24 { 25 /* These will be skipped internally if already failed/ignored */ 26 TEST_FAIL_MESSAGE("<= Failed in tearDown"); 27 TEST_IGNORE_MESSAGE("<= Ignored in tearDown"); 28 } 29 if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) 30 { 31 UnityPrint(": [[[[ Test Should Have Passed But Did Not ]]]]"); 32 UNITY_OUTPUT_CHAR('\n'); 33 } 34} 35 36void testFloatsWithinDelta(void) 37{ 38#ifdef UNITY_EXCLUDE_FLOAT 39 TEST_IGNORE(); 40#else 41 TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f); 42 TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f); 43 TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f); 44 TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f); 45 46 EXPECT_ABORT_BEGIN 47 TEST_ASSERT_FLOAT_NOT_WITHIN(0.05f, 9273.2549f, 9273.2049f); 48 VERIFY_FAILS_END 49#endif 50} 51 52void testFloatsNotWithinDelta(void) 53{ 54#ifdef UNITY_EXCLUDE_FLOAT 55 TEST_IGNORE(); 56#else 57 TEST_ASSERT_FLOAT_NOT_WITHIN(0.05f, 9273.2649f, 9273.2049f); 58 59 EXPECT_ABORT_BEGIN 60 TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f); 61 VERIFY_FAILS_END 62#endif 63} 64 65void testFloatsEqual(void) 66{ 67#ifdef UNITY_EXCLUDE_FLOAT 68 TEST_IGNORE(); 69#else 70 TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f); 71 TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f); 72 TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f); 73 TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f); 74 75 EXPECT_ABORT_BEGIN 76 TEST_ASSERT_NOT_EQUAL_FLOAT(-726.93724f, -726.9374f); 77 VERIFY_FAILS_END 78#endif 79} 80 81void testFloatsNotEqual(void) 82{ 83#ifdef UNITY_EXCLUDE_FLOAT 84 TEST_IGNORE(); 85#else 86 TEST_ASSERT_NOT_EQUAL_FLOAT(9273.9649f, 9273.0049f); 87 88 EXPECT_ABORT_BEGIN 89 TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f); 90 VERIFY_FAILS_END 91#endif 92} 93 94void testFloatsNotEqualNegative1(void) 95{ 96#ifdef UNITY_EXCLUDE_FLOAT 97 TEST_IGNORE(); 98#else 99 TEST_ASSERT_NOT_EQUAL_FLOAT(-9273.9649f, -9273.0049f); 100 101 EXPECT_ABORT_BEGIN 102 TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f); 103 VERIFY_FAILS_END 104#endif 105} 106 107void testFloatsNotEqualNegative2(void) 108{ 109#ifdef UNITY_EXCLUDE_FLOAT 110 TEST_IGNORE(); 111#else 112 TEST_ASSERT_NOT_EQUAL_FLOAT(-9273.0049f, -9273.9649f); 113 114 EXPECT_ABORT_BEGIN 115 TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f); 116 VERIFY_FAILS_END 117#endif 118} 119 120void testFloatsNotEqualActualNaN(void) 121{ 122#ifdef UNITY_EXCLUDE_FLOAT 123 TEST_IGNORE(); 124#else 125 TEST_ASSERT_NOT_EQUAL_FLOAT(85.963f, 0.0f / f_zero); 126 127 EXPECT_ABORT_BEGIN 128 TEST_ASSERT_EQUAL_FLOAT(85.963f, 0.0f / f_zero); 129 VERIFY_FAILS_END 130#endif 131} 132 133void testFloatsNotEqualExpectedNaN(void) 134{ 135#ifdef UNITY_EXCLUDE_FLOAT 136 TEST_IGNORE(); 137#else 138 TEST_ASSERT_NOT_EQUAL_FLOAT(0.0f / f_zero, 85.963f); 139 140 EXPECT_ABORT_BEGIN 141 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 85.963f); 142 VERIFY_FAILS_END 143#endif 144} 145 146void testFloatsEqualBothNaN(void) 147{ 148#ifdef UNITY_EXCLUDE_FLOAT 149 TEST_IGNORE(); 150#else 151 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); 152 153 EXPECT_ABORT_BEGIN 154 TEST_ASSERT_NOT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); 155 VERIFY_FAILS_END 156#endif 157} 158 159void testFloatsNotEqualInfNaN(void) 160{ 161#ifdef UNITY_EXCLUDE_FLOAT 162 TEST_IGNORE(); 163#else 164 TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero); 165 166 EXPECT_ABORT_BEGIN 167 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero); 168 VERIFY_FAILS_END 169#endif 170} 171 172void testFloatsNotEqualNaNInf(void) 173{ 174#ifdef UNITY_EXCLUDE_FLOAT 175 TEST_IGNORE(); 176#else 177 TEST_ASSERT_NOT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero); 178 179 EXPECT_ABORT_BEGIN 180 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero); 181 VERIFY_FAILS_END 182#endif 183} 184 185void testFloatsNotEqualActualInf(void) 186{ 187#ifdef UNITY_EXCLUDE_FLOAT 188 TEST_IGNORE(); 189#else 190 TEST_ASSERT_NOT_EQUAL_FLOAT(321.642f, 1.0f / f_zero); 191 192 EXPECT_ABORT_BEGIN 193 TEST_ASSERT_EQUAL_FLOAT(321.642f, 1.0f / f_zero); 194 VERIFY_FAILS_END 195#endif 196} 197 198void testFloatsNotEqualExpectedInf(void) 199{ 200#ifdef UNITY_EXCLUDE_FLOAT 201 TEST_IGNORE(); 202#else 203 TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, 321.642f); 204 205 EXPECT_ABORT_BEGIN 206 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 321.642f); 207 VERIFY_FAILS_END 208#endif 209} 210 211void testFloatsEqualBothInf(void) 212{ 213#ifdef UNITY_EXCLUDE_FLOAT 214 TEST_IGNORE(); 215#else 216 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); 217 218 EXPECT_ABORT_BEGIN 219 TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); 220 VERIFY_FAILS_END 221#endif 222} 223 224void testFloatsNotEqualPlusMinusInf(void) 225{ 226#ifdef UNITY_EXCLUDE_FLOAT 227 TEST_IGNORE(); 228#else 229 TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero); 230 231 EXPECT_ABORT_BEGIN 232 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero); 233 VERIFY_FAILS_END 234#endif 235} 236 237void testFloatsGreaterThan(void) 238{ 239#ifdef UNITY_EXCLUDE_FLOAT 240 TEST_IGNORE(); 241#else 242 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, 2.0f); 243 TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f, 1.0f); 244 TEST_ASSERT_GREATER_THAN_FLOAT(-2.0f, -1.0f); 245#endif 246} 247 248void testFloatsGreaterThanInf(void) 249{ 250#ifdef UNITY_EXCLUDE_FLOAT 251 TEST_IGNORE(); 252#else 253 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, 1.0f / f_zero); 254 TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f / f_zero, 1.0f / f_zero); 255 TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f / f_zero, 1.0f); 256#endif 257} 258 259void testFloatsNotGreaterThan(void) 260{ 261#ifdef UNITY_EXCLUDE_FLOAT 262 TEST_IGNORE(); 263#else 264 EXPECT_ABORT_BEGIN 265 TEST_ASSERT_GREATER_THAN_FLOAT(2.0f, 1.0f); 266 VERIFY_FAILS_END 267#endif 268} 269 270void testFloatsNotGreaterThanNanActual(void) 271{ 272#ifdef UNITY_EXCLUDE_FLOAT 273 TEST_IGNORE(); 274#else 275 EXPECT_ABORT_BEGIN 276 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, 0.0f / f_zero); 277 VERIFY_FAILS_END 278#endif 279} 280 281void testFloatsNotGreaterThanNanThreshold(void) 282{ 283#ifdef UNITY_EXCLUDE_FLOAT 284 TEST_IGNORE(); 285#else 286 EXPECT_ABORT_BEGIN 287 TEST_ASSERT_GREATER_THAN_FLOAT(0.0f / f_zero, 1.0f); 288 VERIFY_FAILS_END 289#endif 290} 291 292void testFloatsNotGreaterThanNanBoth(void) 293{ 294#ifdef UNITY_EXCLUDE_FLOAT 295 TEST_IGNORE(); 296#else 297 EXPECT_ABORT_BEGIN 298 TEST_ASSERT_GREATER_THAN_FLOAT(0.0f / f_zero, 0.0f / f_zero); 299 VERIFY_FAILS_END 300#endif 301} 302 303void testFloatsNotGreaterThanInfActual(void) 304{ 305#ifdef UNITY_EXCLUDE_FLOAT 306 TEST_IGNORE(); 307#else 308 EXPECT_ABORT_BEGIN 309 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f / f_zero, 1.0f); 310 VERIFY_FAILS_END 311#endif 312} 313 314void testFloatsNotGreaterThanNegInf(void) 315{ 316#ifdef UNITY_EXCLUDE_FLOAT 317 TEST_IGNORE(); 318#else 319 EXPECT_ABORT_BEGIN 320 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, -1.0f / f_zero); 321 VERIFY_FAILS_END 322#endif 323} 324 325void testFloatsNotGreaterThanBothInf(void) 326{ 327#ifdef UNITY_EXCLUDE_FLOAT 328 TEST_IGNORE(); 329#else 330 EXPECT_ABORT_BEGIN 331 TEST_ASSERT_GREATER_THAN_FLOAT(1.0f / f_zero, 1.0f / f_zero); 332 VERIFY_FAILS_END 333#endif 334} 335 336void testFloatsNotGreaterThanBothNegInf(void) 337{ 338#ifdef UNITY_EXCLUDE_FLOAT 339 TEST_IGNORE(); 340#else 341 EXPECT_ABORT_BEGIN 342 TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f / f_zero, -1.0f / f_zero); 343 VERIFY_FAILS_END 344#endif 345} 346 347void testFloatsGreaterOrEqual(void) 348{ 349#ifdef UNITY_EXCLUDE_FLOAT 350 TEST_IGNORE(); 351#else 352 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, 2.0f); 353 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(2.0f, 2.0f); 354 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f, 1.0f); 355 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-2.0f, -1.0f); 356 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-2.0f, -2.0f); 357#endif 358} 359 360void testFloatsGreaterOrEqualInf(void) 361{ 362#ifdef UNITY_EXCLUDE_FLOAT 363 TEST_IGNORE(); 364#else 365 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, 1.0f / f_zero); 366 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f / f_zero, 1.0f / f_zero); 367 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f / f_zero, 1.0f); 368#endif 369} 370 371void testFloatsNotGreaterOrEqual(void) 372{ 373#ifdef UNITY_EXCLUDE_FLOAT 374 TEST_IGNORE(); 375#else 376 EXPECT_ABORT_BEGIN 377 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(2.0f, 1.0f); 378 VERIFY_FAILS_END 379#endif 380} 381 382void testFloatsNotGreaterOrEqualNanActual(void) 383{ 384#ifdef UNITY_EXCLUDE_FLOAT 385 TEST_IGNORE(); 386#else 387 EXPECT_ABORT_BEGIN 388 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, 0.0f / f_zero); 389 VERIFY_FAILS_END 390#endif 391} 392 393void testFloatsNotGreaterOrEqualNanThreshold(void) 394{ 395#ifdef UNITY_EXCLUDE_FLOAT 396 TEST_IGNORE(); 397#else 398 EXPECT_ABORT_BEGIN 399 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(0.0f / f_zero, 1.0f); 400 VERIFY_FAILS_END 401#endif 402} 403 404void testFloatsGreaterOrEqualNanBoth(void) 405{ 406#ifdef UNITY_EXCLUDE_FLOAT 407 TEST_IGNORE(); 408#else 409 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); 410#endif 411} 412 413void testFloatsNotGreaterOrEqualInfActual(void) 414{ 415#ifdef UNITY_EXCLUDE_FLOAT 416 TEST_IGNORE(); 417#else 418 EXPECT_ABORT_BEGIN 419 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f); 420 VERIFY_FAILS_END 421#endif 422} 423 424void testFloatsNotGreaterOrEqualNegInf(void) 425{ 426#ifdef UNITY_EXCLUDE_FLOAT 427 TEST_IGNORE(); 428#else 429 EXPECT_ABORT_BEGIN 430 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, -1.0f / f_zero); 431 VERIFY_FAILS_END 432#endif 433} 434 435void testFloatsGreaterOrEqualBothInf(void) 436{ 437#ifdef UNITY_EXCLUDE_FLOAT 438 TEST_IGNORE(); 439#else 440 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); 441#endif 442} 443 444void testFloatsGreaterOrEqualBothNegInf(void) 445{ 446#ifdef UNITY_EXCLUDE_FLOAT 447 TEST_IGNORE(); 448#else 449 TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f / f_zero, -1.0f / f_zero); 450#endif 451} 452 453void testFloatsLessThan(void) 454{ 455#ifdef UNITY_EXCLUDE_FLOAT 456 TEST_IGNORE(); 457#else 458 TEST_ASSERT_LESS_THAN_FLOAT(2.0f, 1.0f); 459 TEST_ASSERT_LESS_THAN_FLOAT(1.0f, -1.0f); 460 TEST_ASSERT_LESS_THAN_FLOAT(-1.0f, -2.0f); 461#endif 462} 463 464void testFloatsLessThanInf(void) 465{ 466#ifdef UNITY_EXCLUDE_FLOAT 467 TEST_IGNORE(); 468#else 469 TEST_ASSERT_LESS_THAN_FLOAT(1.0f / f_zero, 1.0f); 470 TEST_ASSERT_LESS_THAN_FLOAT(1.0f / f_zero, -1.0f / f_zero); 471 TEST_ASSERT_LESS_THAN_FLOAT(1.0f, -1.0f / f_zero); 472#endif 473} 474 475void testFloatsNotLessThan(void) 476{ 477#ifdef UNITY_EXCLUDE_FLOAT 478 TEST_IGNORE(); 479#else 480 EXPECT_ABORT_BEGIN 481 TEST_ASSERT_LESS_THAN_FLOAT(1.0f, 2.0f); 482 VERIFY_FAILS_END 483#endif 484} 485 486void testFloatsNotLessThanNanActual(void) 487{ 488#ifdef UNITY_EXCLUDE_FLOAT 489 TEST_IGNORE(); 490#else 491 EXPECT_ABORT_BEGIN 492 TEST_ASSERT_LESS_THAN_FLOAT(1.0f, 0.0f / f_zero); 493 VERIFY_FAILS_END 494#endif 495} 496 497void testFloatsNotLessThanNanThreshold(void) 498{ 499#ifdef UNITY_EXCLUDE_FLOAT 500 TEST_IGNORE(); 501#else 502 EXPECT_ABORT_BEGIN 503 TEST_ASSERT_LESS_THAN_FLOAT(0.0f / f_zero, 1.0f); 504 VERIFY_FAILS_END 505#endif 506} 507 508void testFloatsNotLessThanNanBoth(void) 509{ 510#ifdef UNITY_EXCLUDE_FLOAT 511 TEST_IGNORE(); 512#else 513 EXPECT_ABORT_BEGIN 514 TEST_ASSERT_LESS_THAN_FLOAT(0.0f / f_zero, 0.0f / f_zero); 515 VERIFY_FAILS_END 516#endif 517} 518 519void testFloatsNotLessThanInf(void) 520{ 521#ifdef UNITY_EXCLUDE_FLOAT 522 TEST_IGNORE(); 523#else 524 EXPECT_ABORT_BEGIN 525 TEST_ASSERT_LESS_THAN_FLOAT(1.0f, 1.0f / f_zero); 526 VERIFY_FAILS_END 527#endif 528} 529 530void testFloatsNotLessThanNegInf(void) 531{ 532#ifdef UNITY_EXCLUDE_FLOAT 533 TEST_IGNORE(); 534#else 535 EXPECT_ABORT_BEGIN 536 TEST_ASSERT_LESS_THAN_FLOAT(-1.0f / f_zero, 1.0f); 537 VERIFY_FAILS_END 538#endif 539} 540 541void testFloatsNotLessThanBothInf(void) 542{ 543#ifdef UNITY_EXCLUDE_FLOAT 544 TEST_IGNORE(); 545#else 546 EXPECT_ABORT_BEGIN 547 TEST_ASSERT_LESS_THAN_FLOAT(1.0f / f_zero, 1.0f / f_zero); 548 VERIFY_FAILS_END 549#endif 550} 551 552void testFloatsNotLessThanBothNegInf(void) 553{ 554#ifdef UNITY_EXCLUDE_FLOAT 555 TEST_IGNORE(); 556#else 557 EXPECT_ABORT_BEGIN 558 TEST_ASSERT_LESS_THAN_FLOAT(-1.0f / f_zero, -1.0f / f_zero); 559 VERIFY_FAILS_END 560#endif 561} 562void testFloatsLessOrEqual(void) 563{ 564#ifdef UNITY_EXCLUDE_FLOAT 565 TEST_IGNORE(); 566#else 567 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(2.0f, 1.0f); 568 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(2.0f, 2.0f); 569 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, -1.0f); 570 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-1.0f, -2.0f); 571 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-2.0f, -2.0f); 572#endif 573} 574 575void testFloatsLessOrEqualInf(void) 576{ 577#ifdef UNITY_EXCLUDE_FLOAT 578 TEST_IGNORE(); 579#else 580 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f); 581 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero); 582 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, -1.0f / f_zero); 583#endif 584} 585 586void testFloatsNotLessOrEqual(void) 587{ 588#ifdef UNITY_EXCLUDE_FLOAT 589 TEST_IGNORE(); 590#else 591 EXPECT_ABORT_BEGIN 592 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, 2.0f); 593 VERIFY_FAILS_END 594#endif 595} 596 597void testFloatsNotLessOrEqualNanActual(void) 598{ 599#ifdef UNITY_EXCLUDE_FLOAT 600 TEST_IGNORE(); 601#else 602 EXPECT_ABORT_BEGIN 603 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, 0.0f / f_zero); 604 VERIFY_FAILS_END 605#endif 606} 607 608void testFloatsNotLessOrEqualNanThreshold(void) 609{ 610#ifdef UNITY_EXCLUDE_FLOAT 611 TEST_IGNORE(); 612#else 613 EXPECT_ABORT_BEGIN 614 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(0.0f / f_zero, 1.0f); 615 VERIFY_FAILS_END 616#endif 617} 618 619void testFloatsLessOrEqualNanBoth(void) 620{ 621#ifdef UNITY_EXCLUDE_FLOAT 622 TEST_IGNORE(); 623#else 624 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); 625#endif 626} 627 628void testFloatsNotLessOrEqualInf(void) 629{ 630#ifdef UNITY_EXCLUDE_FLOAT 631 TEST_IGNORE(); 632#else 633 EXPECT_ABORT_BEGIN 634 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, 1.0f / f_zero); 635 VERIFY_FAILS_END 636#endif 637} 638 639void testFloatsNotLessOrEqualNegInf(void) 640{ 641#ifdef UNITY_EXCLUDE_FLOAT 642 TEST_IGNORE(); 643#else 644 EXPECT_ABORT_BEGIN 645 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-1.0f / f_zero, 1.0f); 646 VERIFY_FAILS_END 647#endif 648} 649 650void testFloatsLessOrEqualBothInf(void) 651{ 652#ifdef UNITY_EXCLUDE_FLOAT 653 TEST_IGNORE(); 654#else 655 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); 656#endif 657} 658 659void testFloatsLessOrEqualBothNegInf(void) 660{ 661#ifdef UNITY_EXCLUDE_FLOAT 662 TEST_IGNORE(); 663#else 664 TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-1.0f / f_zero, -1.0f / f_zero); 665#endif 666} 667 668void testFloatIsPosInf1(void) 669{ 670#ifdef UNITY_EXCLUDE_FLOAT 671 TEST_IGNORE(); 672#else 673 TEST_ASSERT_FLOAT_IS_INF(2.0f / f_zero); 674#endif 675} 676 677void testFloatIsPosInf2(void) 678{ 679#ifdef UNITY_EXCLUDE_FLOAT 680 TEST_IGNORE(); 681#else 682 EXPECT_ABORT_BEGIN 683 TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f / f_zero); 684 VERIFY_FAILS_END 685#endif 686} 687 688void testFloatIsNegInf1(void) 689{ 690#ifdef UNITY_EXCLUDE_FLOAT 691 TEST_IGNORE(); 692#else 693 TEST_ASSERT_FLOAT_IS_NEG_INF(-3.0f / f_zero); 694#endif 695} 696 697void testFloatIsNegInf2(void) 698{ 699#ifdef UNITY_EXCLUDE_FLOAT 700 TEST_IGNORE(); 701#else 702 EXPECT_ABORT_BEGIN 703 TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(-3.0f / f_zero); 704 VERIFY_FAILS_END 705#endif 706} 707 708void testFloatIsNotPosInf1(void) 709{ 710#ifdef UNITY_EXCLUDE_FLOAT 711 TEST_IGNORE(); 712#else 713 EXPECT_ABORT_BEGIN 714 TEST_ASSERT_FLOAT_IS_INF(2.0f); 715 VERIFY_FAILS_END 716#endif 717} 718 719void testFloatIsNotPosInf2(void) 720{ 721#ifdef UNITY_EXCLUDE_FLOAT 722 TEST_IGNORE(); 723#else 724 TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f); 725#endif 726} 727 728void testFloatIsNotNegInf(void) 729{ 730#ifdef UNITY_EXCLUDE_FLOAT 731 TEST_IGNORE(); 732#else 733 EXPECT_ABORT_BEGIN 734 TEST_ASSERT_FLOAT_IS_NEG_INF(-999.876f); 735 VERIFY_FAILS_END 736#endif 737} 738 739void testFloatIsNan1(void) 740{ 741#ifdef UNITY_EXCLUDE_FLOAT 742 TEST_IGNORE(); 743#else 744 TEST_ASSERT_FLOAT_IS_NAN(0.0f / f_zero); 745#endif 746} 747 748void testFloatIsNan2(void) 749{ 750#ifdef UNITY_EXCLUDE_FLOAT 751 TEST_IGNORE(); 752#else 753 EXPECT_ABORT_BEGIN 754 TEST_ASSERT_FLOAT_IS_NOT_NAN(0.0f / f_zero); 755 VERIFY_FAILS_END 756#endif 757} 758 759void testFloatIsNotNan1(void) 760{ 761#ifdef UNITY_EXCLUDE_FLOAT 762 TEST_IGNORE(); 763#else 764 EXPECT_ABORT_BEGIN 765 TEST_ASSERT_FLOAT_IS_NAN(234.9f); 766 VERIFY_FAILS_END 767#endif 768} 769 770void testFloatIsNotNan2(void) 771{ 772#ifdef UNITY_EXCLUDE_FLOAT 773 TEST_IGNORE(); 774#else 775 TEST_ASSERT_FLOAT_IS_NOT_NAN(234.9f); 776#endif 777} 778 779void testFloatInfIsNotNan(void) 780{ 781#ifdef UNITY_EXCLUDE_FLOAT 782 TEST_IGNORE(); 783#else 784 EXPECT_ABORT_BEGIN 785 TEST_ASSERT_FLOAT_IS_NAN(1.0f / f_zero); 786 VERIFY_FAILS_END 787#endif 788} 789 790void testFloatNanIsNotInf(void) 791{ 792#ifdef UNITY_EXCLUDE_FLOAT 793 TEST_IGNORE(); 794#else 795 EXPECT_ABORT_BEGIN 796 TEST_ASSERT_FLOAT_IS_INF(0.0f / f_zero); 797 VERIFY_FAILS_END 798#endif 799} 800 801void testFloatIsDeterminate1(void) 802{ 803#ifdef UNITY_EXCLUDE_FLOAT 804 TEST_IGNORE(); 805#else 806 TEST_ASSERT_FLOAT_IS_DETERMINATE(0.0f); 807 TEST_ASSERT_FLOAT_IS_DETERMINATE(123.3f); 808 TEST_ASSERT_FLOAT_IS_DETERMINATE(-88.3f); 809#endif 810} 811 812void testFloatIsDeterminate2(void) 813{ 814#ifdef UNITY_EXCLUDE_FLOAT 815 TEST_IGNORE(); 816#else 817 EXPECT_ABORT_BEGIN 818 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-88.3f); 819 VERIFY_FAILS_END 820#endif 821} 822 823void testFloatIsNotDeterminate1(void) 824{ 825#ifdef UNITY_EXCLUDE_FLOAT 826 TEST_IGNORE(); 827#else 828 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(1.0f / f_zero); 829 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-1.0f / f_zero); 830 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(0.0f / f_zero); 831#endif 832} 833 834void testFloatIsNotDeterminate2(void) 835{ 836#ifdef UNITY_EXCLUDE_FLOAT 837 TEST_IGNORE(); 838#else 839 EXPECT_ABORT_BEGIN 840 TEST_ASSERT_FLOAT_IS_DETERMINATE(-1.0f / f_zero); 841 VERIFY_FAILS_END 842#endif 843} 844 845void testFloatTraitFailsOnInvalidTrait(void) 846{ 847#ifdef UNITY_EXCLUDE_FLOAT 848 TEST_IGNORE(); 849#else 850 EXPECT_ABORT_BEGIN 851 UnityAssertFloatSpecial(1.0f, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT); 852 VERIFY_FAILS_END 853#endif 854} 855 856void testEqualFloatArrays(void) 857{ 858#ifdef UNITY_EXCLUDE_FLOAT 859 TEST_IGNORE(); 860#else 861 float p0[] = {1.0f, -8.0f, 25.4f, -0.123f}; 862 float p1[] = {1.0f, -8.0f, 25.4f, -0.123f}; 863 float p2[] = {1.0f, -8.0f, 25.4f, -0.2f}; 864 float p3[] = {1.0f, -23.0f, 25.0f, -0.26f}; 865 866 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 1); 867 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 4); 868 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 869 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p2, 3); 870 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p3, 1); 871 TEST_ASSERT_EQUAL_FLOAT_ARRAY(NULL, NULL, 1); 872#endif 873} 874 875void testNotEqualFloatArraysExpectedNull(void) 876{ 877#ifdef UNITY_EXCLUDE_FLOAT 878 TEST_IGNORE(); 879#else 880 float* p0 = NULL; 881 float p1[] = {1.0f, 8.0f, 25.4f, 0.252f}; 882 883 EXPECT_ABORT_BEGIN 884 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 885 VERIFY_FAILS_END 886#endif 887} 888 889void testNotEqualFloatArraysActualNull(void) 890{ 891#ifdef UNITY_EXCLUDE_FLOAT 892 TEST_IGNORE(); 893#else 894 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; 895 float* p1 = NULL; 896 897 EXPECT_ABORT_BEGIN 898 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 899 VERIFY_FAILS_END 900#endif 901} 902 903void testNotEqualFloatArrays1(void) 904{ 905#ifdef UNITY_EXCLUDE_FLOAT 906 TEST_IGNORE(); 907#else 908 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; 909 float p1[] = {1.0f, 8.0f, 25.4f, 0.252f}; 910 911 EXPECT_ABORT_BEGIN 912 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 913 VERIFY_FAILS_END 914#endif 915} 916 917void testNotEqualFloatArrays2(void) 918{ 919#ifdef UNITY_EXCLUDE_FLOAT 920 TEST_IGNORE(); 921#else 922 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; 923 float p1[] = {2.0f, 8.0f, 25.4f, 0.253f}; 924 925 EXPECT_ABORT_BEGIN 926 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 927 VERIFY_FAILS_END 928#endif 929} 930 931void testNotEqualFloatArrays3(void) 932{ 933#ifdef UNITY_EXCLUDE_FLOAT 934 TEST_IGNORE(); 935#else 936 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; 937 float p1[] = {1.0f, 8.0f, 25.5f, 0.253f}; 938 939 EXPECT_ABORT_BEGIN 940 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 941 VERIFY_FAILS_END 942#endif 943} 944 945void testNotEqualFloatArraysNegative1(void) 946{ 947#ifdef UNITY_EXCLUDE_FLOAT 948 TEST_IGNORE(); 949#else 950 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; 951 float p1[] = {-1.0f, -8.0f, -25.4f, -0.252f}; 952 953 EXPECT_ABORT_BEGIN 954 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 955 VERIFY_FAILS_END 956#endif 957} 958 959void testNotEqualFloatArraysNegative2(void) 960{ 961#ifdef UNITY_EXCLUDE_FLOAT 962 TEST_IGNORE(); 963#else 964 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; 965 float p1[] = {-2.0f, -8.0f, -25.4f, -0.253f}; 966 967 EXPECT_ABORT_BEGIN 968 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 969 VERIFY_FAILS_END 970#endif 971} 972 973void testNotEqualFloatArraysNegative3(void) 974{ 975#ifdef UNITY_EXCLUDE_FLOAT 976 TEST_IGNORE(); 977#else 978 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; 979 float p1[] = {-1.0f, -8.0f, -25.5f, -0.253f}; 980 981 EXPECT_ABORT_BEGIN 982 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 983 VERIFY_FAILS_END 984#endif 985} 986 987void testEqualFloatArraysNaN(void) 988{ 989#ifdef UNITY_EXCLUDE_FLOAT 990 TEST_IGNORE(); 991#else 992 float p0[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f}; 993 float p1[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f}; 994 995 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 996#endif 997} 998 999void testEqualFloatArraysInf(void) 1000{ 1001#ifdef UNITY_EXCLUDE_FLOAT 1002 TEST_IGNORE(); 1003#else 1004 float p0[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f}; 1005 float p1[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f}; 1006 1007 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 1008#endif 1009} 1010 1011void testNotEqualFloatArraysLengthZero(void) 1012{ 1013#ifdef UNITY_EXCLUDE_FLOAT 1014 TEST_IGNORE(); 1015#else 1016 float p0[1] = {0.0f}; 1017 float p1[1] = {0.0f}; 1018 1019 EXPECT_ABORT_BEGIN 1020 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 0); 1021 VERIFY_FAILS_END 1022#endif 1023} 1024 1025void testFloatArraysWithin(void) 1026{ 1027#ifdef UNITY_EXCLUDE_FLOAT 1028 TEST_IGNORE(); 1029#else 1030 float p0[] = {1.0f, -8.0f, 25.4f, -0.123f}; 1031 float p1[] = {1.0f, -8.0f, 25.4f, -0.123f}; 1032 float p2[] = {1.0f, -8.0f, 25.4f, -0.2f}; 1033 float p3[] = {1.0f, -23.0f, 25.0f, -0.26f}; 1034 float p4[] = {2.0f, -9.0f, 26.2f, 0.26f}; 1035 float p5[] = {-1.0f, -7.0f, 29.0f, 2.6f}; 1036 1037 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p0, 1); 1038 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p0, 4); 1039 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p1, 4); 1040 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p2, 3); 1041 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p3, 1); 1042 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p4, 1); 1043 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p4, 4); 1044 TEST_ASSERT_FLOAT_ARRAY_WITHIN(2.0f, p0, p5, 1); 1045 TEST_ASSERT_FLOAT_ARRAY_WITHIN(2.0f, p0, p5, 2); 1046 TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, NULL, NULL, 1); 1047#endif 1048} 1049 1050void testFloatArraysWithinUnusualDelta(void) 1051{ 1052#ifdef UNITY_EXCLUDE_FLOAT 1053 TEST_IGNORE(); 1054#else 1055 float p0[] = {(float)-INFINITY, -8.0f, 25.4f, -0.123f}; 1056 float p1[] = {(float)INFINITY, 10.1f}; 1057 1058 TEST_ASSERT_FLOAT_ARRAY_WITHIN(INFINITY, p0, p1, 2); 1059 1060 EXPECT_ABORT_BEGIN 1061 TEST_ASSERT_FLOAT_ARRAY_WITHIN(NAN, p0, p0, 4); 1062 VERIFY_FAILS_END 1063#endif 1064} 1065 1066void testEqualFloatEachEqual(void) 1067{ 1068#ifdef UNITY_EXCLUDE_FLOAT 1069 TEST_IGNORE(); 1070#else 1071 float p0[] = {1.0f, 1.0f, 1.0f, 1.0f}; 1072 float p1[] = {-0.123f, -0.123f, -0.123f, -0.123f}; 1073 float p2[] = {25.4f, 25.4f, 25.4f, -0.2f}; 1074 float p3[] = {1.0f, -23.0f, 25.0f, -0.26f}; 1075 1076 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 1); 1077 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4); 1078 TEST_ASSERT_EACH_EQUAL_FLOAT(-0.123f, p1, 4); 1079 TEST_ASSERT_EACH_EQUAL_FLOAT(25.4f, p2, 3); 1080 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p3, 1); 1081#endif 1082} 1083 1084void testNotEqualFloatEachEqualActualNull(void) 1085{ 1086#ifdef UNITY_EXCLUDE_FLOAT 1087 TEST_IGNORE(); 1088#else 1089 float* p0 = NULL; 1090 1091 EXPECT_ABORT_BEGIN 1092 TEST_ASSERT_EACH_EQUAL_FLOAT(5, p0, 4); 1093 VERIFY_FAILS_END 1094#endif 1095} 1096 1097void testNotEqualFloatEachEqual1(void) 1098{ 1099#ifdef UNITY_EXCLUDE_FLOAT 1100 TEST_IGNORE(); 1101#else 1102 float p0[] = {0.253f, 8.0f, 0.253f, 0.253f}; 1103 1104 EXPECT_ABORT_BEGIN 1105 TEST_ASSERT_EACH_EQUAL_FLOAT(0.253f, p0, 4); 1106 VERIFY_FAILS_END 1107#endif 1108} 1109 1110void testNotEqualFloatEachEqual2(void) 1111{ 1112#ifdef UNITY_EXCLUDE_FLOAT 1113 TEST_IGNORE(); 1114#else 1115 float p0[] = {8.0f, 8.0f, 8.0f, 0.253f}; 1116 1117 EXPECT_ABORT_BEGIN 1118 TEST_ASSERT_EACH_EQUAL_FLOAT(8.0f, p0, 4); 1119 VERIFY_FAILS_END 1120#endif 1121} 1122 1123void testNotEqualFloatEachEqual3(void) 1124{ 1125#ifdef UNITY_EXCLUDE_FLOAT 1126 TEST_IGNORE(); 1127#else 1128 float p0[] = {1.0f, 1.0f, 1.0f, 0.253f}; 1129 1130 EXPECT_ABORT_BEGIN 1131 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f, p0, 4); 1132 VERIFY_FAILS_END 1133#endif 1134} 1135 1136void testNotEqualFloatEachEqualNegative1(void) 1137{ 1138#ifdef UNITY_EXCLUDE_FLOAT 1139 TEST_IGNORE(); 1140#else 1141 float p0[] = {-1.0f, -0.253f, -0.253f, -0.253f}; 1142 1143 EXPECT_ABORT_BEGIN 1144 TEST_ASSERT_EACH_EQUAL_FLOAT(-0.253f, p0, 4); 1145 VERIFY_FAILS_END 1146#endif 1147} 1148 1149void testNotEqualFloatEachEqualNegative2(void) 1150{ 1151#ifdef UNITY_EXCLUDE_FLOAT 1152 TEST_IGNORE(); 1153#else 1154 float p0[] = {-25.4f, -8.0f, -25.4f, -25.4f}; 1155 1156 EXPECT_ABORT_BEGIN 1157 TEST_ASSERT_EACH_EQUAL_FLOAT(-25.4f, p0, 4); 1158 VERIFY_FAILS_END 1159#endif 1160} 1161 1162void testNotEqualFloatEachEqualNegative3(void) 1163{ 1164#ifdef UNITY_EXCLUDE_FLOAT 1165 TEST_IGNORE(); 1166#else 1167 float p0[] = {-8.0f, -8.0f, -8.0f, -0.253f}; 1168 1169 EXPECT_ABORT_BEGIN 1170 TEST_ASSERT_EACH_EQUAL_FLOAT(-8.0f, p0, 4); 1171 VERIFY_FAILS_END 1172#endif 1173} 1174 1175void testEqualFloatEachEqualNaN(void) 1176{ 1177#ifdef UNITY_EXCLUDE_FLOAT 1178 TEST_IGNORE(); 1179#else 1180 float p0[] = {0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero, 0.0f / f_zero}; 1181 1182 TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f / f_zero, p0, 4); 1183#endif 1184} 1185 1186void testEqualFloatEachEqualInf(void) 1187{ 1188#ifdef UNITY_EXCLUDE_FLOAT 1189 TEST_IGNORE(); 1190#else 1191 float p0[] = {1.0f / f_zero, 1.0f / f_zero, 25.4f, 0.253f}; 1192 1193 TEST_ASSERT_EACH_EQUAL_FLOAT(1.0f / f_zero, p0, 2); 1194#endif 1195} 1196 1197void testNotEqualFloatEachEqualLengthZero(void) 1198{ 1199#ifdef UNITY_EXCLUDE_FLOAT 1200 TEST_IGNORE(); 1201#else 1202 float p0[1] = {0.0f}; 1203 1204 EXPECT_ABORT_BEGIN 1205 TEST_ASSERT_EACH_EQUAL_FLOAT(0.0f, p0, 0); 1206 VERIFY_FAILS_END 1207#endif 1208} 1209 1210void testFloatPrinting(void) 1211{ 1212#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_INCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) 1213 TEST_IGNORE(); 1214#else 1215 TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0f); 1216 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499f); 1217 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.1004695", 0.100469499f); 1218 TEST_ASSERT_EQUAL_PRINT_FLOATING("2", 1.9999995f); /*Rounding to int place*/ 1219 TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0f); 1220 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25f); 1221 TEST_ASSERT_EQUAL_PRINT_FLOATING("7.999999", 7.999999f); /*Not rounding*/ 1222 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00002", 16.00002f); 1223 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00004", 16.00004f); 1224 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.00006", 16.00006f); 1225 TEST_ASSERT_EQUAL_PRINT_FLOATING("9999999", 9999999.0f); /*Last full print integer*/ 1226 1227 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0", -0.0f); 1228 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499f); 1229 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.1004695", -0.100469499f); 1230 TEST_ASSERT_EQUAL_PRINT_FLOATING("-2", -1.9999995f); /*Rounding to int place*/ 1231 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0f); 1232 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25f); 1233 TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.999999", -7.999999f); /*Not rounding*/ 1234 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00002", -16.00002f); 1235 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00004", -16.00004f); 1236 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.00006", -16.00006f); 1237 TEST_ASSERT_EQUAL_PRINT_FLOATING("-9999999", -9999999.0f); /*Last full print integer*/ 1238 1239 /* Fails, prints "4.294968e+09" due to FP math imprecision 1240 * TEST_ASSERT_EQUAL_PRINT_FLOATING("4.294967e+09", 4294967296.0f); */ 1241 TEST_ASSERT_EQUAL_PRINT_FLOATING("5e+09", 5000000000.0f); 1242 TEST_ASSERT_EQUAL_PRINT_FLOATING("8e+09", 8.0e+09f); 1243 TEST_ASSERT_EQUAL_PRINT_FLOATING("8.309999e+09", 8309999104.0f); 1244 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 1.0e+10f); 1245 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000000.0f); 1246 /* Some compilers have trouble with inexact float constants, a float cast works generally */ 1247 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.000055e+10", (float)1.000055e+10f); 1248 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.1e+38", (float)1.10000005e+38f); 1249 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.635299e+10", 1.63529943e+10f); 1250 /* Fails, prints "3.402824e+38" due to FP math imprecision 1251 * TEST_ASSERT_EQUAL_PRINT_FLOATING("3.402823e+38", 3.40282346638e38f); */ 1252 1253 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1e+10", -1.0e+10f); 1254 /* Fails, prints "-3.402824e+38" due to FP math imprecision 1255 * TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.402823e+38", -3.40282346638e38f); */ 1256#endif 1257} 1258 1259void testFloatPrintingRoundTiesToEven(void) 1260{ 1261#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_INCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) 1262 TEST_IGNORE(); 1263#else 1264 #ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO 1265 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0004882813", 0.00048828125f); 1266 TEST_ASSERT_EQUAL_PRINT_FLOATING("488281.3", 488281.25f); 1267 TEST_ASSERT_EQUAL_PRINT_FLOATING("5.000001e-07", 0.00000050000005f); 1268 TEST_ASSERT_EQUAL_PRINT_FLOATING("-5.000001e-07", -0.00000050000005f); 1269 #else /* Default to Round ties to even */ 1270 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0004882812", 0.00048828125f); 1271 TEST_ASSERT_EQUAL_PRINT_FLOATING("488281.2", 488281.25f); 1272 TEST_ASSERT_EQUAL_PRINT_FLOATING("5e-07", 0.00000050000005f); 1273 TEST_ASSERT_EQUAL_PRINT_FLOATING("-5e-07", -0.00000050000005f); 1274 #endif 1275#endif 1276} 1277 1278void testFloatPrintingInfinityAndNaN(void) 1279{ 1280#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY) 1281 TEST_IGNORE(); 1282#else 1283 TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0f / f_zero); 1284 TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0f / f_zero); 1285 1286 TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0f / f_zero); 1287#endif 1288} 1289 1290#if defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) && defined(USING_OUTPUT_SPY) 1291#ifdef UNITY_INCLUDE_DOUBLE 1292static void printFloatValue(float f) 1293{ 1294 char expected[18]; 1295 1296 startPutcharSpy(); 1297 UnityPrintFloat(f); 1298 1299 sprintf(expected, "%.9g", f); 1300 /* We print all NaN's as "nan", not "-nan" */ 1301 if (strcmp(expected, "-nan") == 0) strcpy(expected, "nan"); 1302 1303 if (strcmp(expected, getBufferPutcharSpy())) 1304 { 1305 /* Fail with diagnostic printing */ 1306 TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f); 1307 } 1308} 1309#else 1310static void printFloatValue(float f) 1311{ 1312 char expected[18]; 1313 char expected_lower[18]; 1314 char expected_lower2[18]; 1315 char expected_lower3[18]; 1316 char expected_higher[18]; 1317 char expected_higher2[18]; 1318 char expected_higher3[18]; 1319 1320 startPutcharSpy(); 1321 UnityPrintFloat(f); 1322 1323 sprintf(expected, "%.7g", f); 1324 /* We print all NaN's as "nan", not "-nan" */ 1325 if (strcmp(expected, "-nan") == 0) strcpy(expected, "nan"); 1326 1327 strcpy(expected_lower, expected); 1328 strcpy(expected_lower2, expected); 1329 strcpy(expected_lower3, expected); 1330 strcpy(expected_higher, expected); 1331 strcpy(expected_higher2, expected); 1332 strcpy(expected_higher3, expected); 1333 1334 /* Allow for rounding differences in the last digit */ 1335 double lower = (double)f * 0.99999995; 1336 double higher = (double)f * 1.00000005; 1337 1338 if(isfinite(lower)) sprintf(expected_lower, "%.7g", lower); 1339 if(isfinite(higher)) sprintf(expected_higher, "%.7g", higher); 1340 1341 /* Outside [1,10000000] allow for relative error of +/-2.5e-7 */ 1342 if (f < 1.0 || f > 10000000) 1343 { 1344 double lower2 = (double)f * 0.99999985; 1345 double lower3 = (double)f * 0.99999975; 1346 double higher2 = (double)f * 1.00000015; 1347 double higher3 = (double)f * 1.00000025; 1348 1349 if (isfinite(lower2)) sprintf(expected_lower2, "%.7g", lower2); 1350 if (isfinite(lower3)) sprintf(expected_lower3, "%.7g", lower3); 1351 if (isfinite(higher2)) sprintf(expected_higher2, "%.7g", higher2); 1352 if (isfinite(higher3)) sprintf(expected_higher3, "%.7g", higher3); 1353 } 1354 1355 if (strcmp(expected, getBufferPutcharSpy()) != 0 && 1356 strcmp(expected_lower, getBufferPutcharSpy()) != 0 && 1357 strcmp(expected_lower2, getBufferPutcharSpy()) != 0 && 1358 strcmp(expected_lower3, getBufferPutcharSpy()) != 0 && 1359 strcmp(expected_higher, getBufferPutcharSpy()) != 0 && 1360 strcmp(expected_higher2, getBufferPutcharSpy()) != 0 && 1361 strcmp(expected_higher3, getBufferPutcharSpy()) != 0) 1362 { 1363 /* Fail with diagnostic printing */ 1364 TEST_ASSERT_EQUAL_PRINT_FLOATING(expected, f); 1365 } 1366} 1367#endif 1368#endif 1369 1370void testFloatPrintingRandomSamples(void) 1371{ 1372#if !defined(UNITY_TEST_ALL_FLOATS_PRINT_OK) || !defined(USING_OUTPUT_SPY) 1373 TEST_IGNORE(); 1374#else 1375 union { float f_value; uint32_t int_value; } u; 1376 1377 /* These values are not covered by the MINSTD generator */ 1378 u.int_value = 0x00000000; printFloatValue(u.f_value); 1379 u.int_value = 0x80000000; printFloatValue(u.f_value); 1380 u.int_value = 0x7fffffff; printFloatValue(u.f_value); 1381 u.int_value = 0xffffffff; printFloatValue(u.f_value); 1382 1383 uint32_t a = 1; 1384 for(int num_tested = 0; num_tested < 1000000; num_tested++) 1385 { 1386 /* MINSTD pseudo-random number generator */ 1387 a = (uint32_t)(((uint64_t)a * 48271u) % 2147483647u); 1388 1389 /* MINSTD does not set the highest bit; test both possibilities */ 1390 u.int_value = a; printFloatValue(u.f_value); 1391 u.int_value = a | 0x80000000; printFloatValue(u.f_value); 1392 } 1393#endif 1394} 1395