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 testDoublesWithinDelta(void) 37{ 38#ifdef UNITY_EXCLUDE_DOUBLE 39 TEST_IGNORE(); 40#else 41 TEST_ASSERT_DOUBLE_WITHIN(0.00003, 187245.03485, 187245.03488); 42 TEST_ASSERT_DOUBLE_WITHIN(1.0, 187245.0, 187246.0); 43 TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2549, 9273.2049); 44 TEST_ASSERT_DOUBLE_WITHIN(0.007, -726.93725, -726.94424); 45 46 EXPECT_ABORT_BEGIN 47 TEST_ASSERT_DOUBLE_NOT_WITHIN(0.05, 9273.2549, 9273.2049); 48 VERIFY_FAILS_END 49#endif 50} 51 52void testDoublesNotWithinDelta(void) 53{ 54#ifdef UNITY_EXCLUDE_DOUBLE 55 TEST_IGNORE(); 56#else 57 TEST_ASSERT_DOUBLE_NOT_WITHIN(0.05, 9273.2649, 9273.2049); 58 59 EXPECT_ABORT_BEGIN 60 TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2649, 9273.2049); 61 VERIFY_FAILS_END 62#endif 63} 64 65 66void testDoublesEqual(void) 67{ 68#ifdef UNITY_EXCLUDE_DOUBLE 69 TEST_IGNORE(); 70#else 71 TEST_ASSERT_EQUAL_DOUBLE(187245123456.0, 187245123456.0); 72 TEST_ASSERT_EQUAL_DOUBLE(187241234567.5, 187241234567.6); 73 TEST_ASSERT_EQUAL_DOUBLE(9273.2512345649, 9273.25123455699); 74 TEST_ASSERT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374); 75 76 EXPECT_ABORT_BEGIN 77 TEST_ASSERT_NOT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374); 78 VERIFY_FAILS_END 79#endif 80} 81 82void testDoublesNotEqual(void) 83{ 84#ifdef UNITY_EXCLUDE_DOUBLE 85 TEST_IGNORE(); 86#else 87 TEST_ASSERT_NOT_EQUAL_DOUBLE(9273.9649, 9273.0049); 88 89 EXPECT_ABORT_BEGIN 90 TEST_ASSERT_EQUAL_DOUBLE(9273.9649, 9273.0049); 91 VERIFY_FAILS_END 92#endif 93} 94 95void testDoublesNotEqualNegative1(void) 96{ 97#ifdef UNITY_EXCLUDE_DOUBLE 98 TEST_IGNORE(); 99#else 100 TEST_ASSERT_NOT_EQUAL_DOUBLE(-9273.9649, -9273.0049); 101 102 EXPECT_ABORT_BEGIN 103 TEST_ASSERT_EQUAL_DOUBLE(-9273.9649, -9273.0049); 104 VERIFY_FAILS_END 105#endif 106} 107 108void testDoublesNotEqualNegative2(void) 109{ 110#ifdef UNITY_EXCLUDE_DOUBLE 111 TEST_IGNORE(); 112#else 113 TEST_ASSERT_NOT_EQUAL_DOUBLE(-9273.0049, -9273.9649); 114 115 EXPECT_ABORT_BEGIN 116 TEST_ASSERT_EQUAL_DOUBLE(-9273.0049, -9273.9649); 117 VERIFY_FAILS_END 118#endif 119} 120 121void testDoublesNotEqualActualNaN(void) 122{ 123#ifdef UNITY_EXCLUDE_DOUBLE 124 TEST_IGNORE(); 125#else 126 TEST_ASSERT_NOT_EQUAL_DOUBLE(85.963, 0.0 / d_zero); 127 128 EXPECT_ABORT_BEGIN 129 TEST_ASSERT_EQUAL_DOUBLE(85.963, 0.0 / d_zero); 130 VERIFY_FAILS_END 131#endif 132} 133 134void testDoublesNotEqualExpectedNaN(void) 135{ 136#ifdef UNITY_EXCLUDE_DOUBLE 137 TEST_IGNORE(); 138#else 139 TEST_ASSERT_NOT_EQUAL_DOUBLE(0.0 / d_zero, 85.963); 140 141 EXPECT_ABORT_BEGIN 142 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 85.963); 143 VERIFY_FAILS_END 144#endif 145} 146 147void testDoublesEqualBothNaN(void) 148{ 149#ifdef UNITY_EXCLUDE_DOUBLE 150 TEST_IGNORE(); 151#else 152 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero); 153 154 EXPECT_ABORT_BEGIN 155 TEST_ASSERT_NOT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero); 156 VERIFY_FAILS_END 157#endif 158} 159 160void testDoublesNotEqualInfNaN(void) 161{ 162#ifdef UNITY_EXCLUDE_DOUBLE 163 TEST_IGNORE(); 164#else 165 TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero); 166 167 EXPECT_ABORT_BEGIN 168 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero); 169 VERIFY_FAILS_END 170#endif 171} 172 173void testDoublesNotEqualNaNInf(void) 174{ 175#ifdef UNITY_EXCLUDE_DOUBLE 176 TEST_IGNORE(); 177#else 178 TEST_ASSERT_NOT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero); 179 180 EXPECT_ABORT_BEGIN 181 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero); 182 VERIFY_FAILS_END 183#endif 184} 185 186void testDoublesNotEqualActualInf(void) 187{ 188#ifdef UNITY_EXCLUDE_DOUBLE 189 TEST_IGNORE(); 190#else 191 TEST_ASSERT_NOT_EQUAL_DOUBLE(321.642, 1.0 / d_zero); 192 193 EXPECT_ABORT_BEGIN 194 TEST_ASSERT_EQUAL_DOUBLE(321.642, 1.0 / d_zero); 195 VERIFY_FAILS_END 196#endif 197} 198 199void testDoublesNotEqualExpectedInf(void) 200{ 201#ifdef UNITY_EXCLUDE_DOUBLE 202 TEST_IGNORE(); 203#else 204 TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, 321.642); 205 206 EXPECT_ABORT_BEGIN 207 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 321.642); 208 VERIFY_FAILS_END 209#endif 210} 211 212void testDoublesEqualBothInf(void) 213{ 214#ifdef UNITY_EXCLUDE_DOUBLE 215 TEST_IGNORE(); 216#else 217 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero); 218 219 EXPECT_ABORT_BEGIN 220 TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero); 221 VERIFY_FAILS_END 222#endif 223} 224 225void testDoublesNotEqualPlusMinusInf(void) 226{ 227#ifdef UNITY_EXCLUDE_DOUBLE 228 TEST_IGNORE(); 229#else 230 TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero); 231 232 EXPECT_ABORT_BEGIN 233 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero); 234 VERIFY_FAILS_END 235#endif 236} 237 238void testDoublesGreaterThan(void) 239{ 240#ifdef UNITY_EXCLUDE_DOUBLE 241 TEST_IGNORE(); 242#else 243 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, 2.0); 244 TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0, 1.0); 245 TEST_ASSERT_GREATER_THAN_DOUBLE(-2.0, -1.0); 246#endif 247} 248 249void testDoublesGreaterThanInf(void) 250{ 251#ifdef UNITY_EXCLUDE_DOUBLE 252 TEST_IGNORE(); 253#else 254 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, 1.0 / d_zero); 255 TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0 / d_zero, 1.0 / d_zero); 256 TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0 / d_zero, 1.0); 257#endif 258} 259 260void testDoublesNotGreaterThan(void) 261{ 262#ifdef UNITY_EXCLUDE_DOUBLE 263 TEST_IGNORE(); 264#else 265 EXPECT_ABORT_BEGIN 266 TEST_ASSERT_GREATER_THAN_DOUBLE(2.0, 1.0); 267 VERIFY_FAILS_END 268#endif 269} 270 271void testDoublesNotGreaterThanNanActual(void) 272{ 273#ifdef UNITY_EXCLUDE_DOUBLE 274 TEST_IGNORE(); 275#else 276 EXPECT_ABORT_BEGIN 277 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, 0.0 / d_zero); 278 VERIFY_FAILS_END 279#endif 280} 281 282void testDoublesNotGreaterThanNanThreshold(void) 283{ 284#ifdef UNITY_EXCLUDE_DOUBLE 285 TEST_IGNORE(); 286#else 287 EXPECT_ABORT_BEGIN 288 TEST_ASSERT_GREATER_THAN_DOUBLE(0.0 / d_zero, 1.0); 289 VERIFY_FAILS_END 290#endif 291} 292 293void testDoublesNotGreaterThanNanBoth(void) 294{ 295#ifdef UNITY_EXCLUDE_DOUBLE 296 TEST_IGNORE(); 297#else 298 EXPECT_ABORT_BEGIN 299 TEST_ASSERT_GREATER_THAN_DOUBLE(0.0 / d_zero, 0.0 / d_zero); 300 VERIFY_FAILS_END 301#endif 302} 303 304void testDoublesNotGreaterThanInfActual(void) 305{ 306#ifdef UNITY_EXCLUDE_DOUBLE 307 TEST_IGNORE(); 308#else 309 EXPECT_ABORT_BEGIN 310 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0 / d_zero, 1.0); 311 VERIFY_FAILS_END 312#endif 313} 314 315void testDoublesNotGreaterThanNegInf(void) 316{ 317#ifdef UNITY_EXCLUDE_DOUBLE 318 TEST_IGNORE(); 319#else 320 EXPECT_ABORT_BEGIN 321 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, -1.0 / d_zero); 322 VERIFY_FAILS_END 323#endif 324} 325 326void testDoublesNotGreaterThanBothInf(void) 327{ 328#ifdef UNITY_EXCLUDE_DOUBLE 329 TEST_IGNORE(); 330#else 331 EXPECT_ABORT_BEGIN 332 TEST_ASSERT_GREATER_THAN_DOUBLE(1.0 / d_zero, 1.0 / d_zero); 333 VERIFY_FAILS_END 334#endif 335} 336 337void testDoublesNotGreaterThanBothNegInf(void) 338{ 339#ifdef UNITY_EXCLUDE_DOUBLE 340 TEST_IGNORE(); 341#else 342 EXPECT_ABORT_BEGIN 343 TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0 / d_zero, -1.0 / d_zero); 344 VERIFY_FAILS_END 345#endif 346} 347 348void testDoublesGreaterOrEqual(void) 349{ 350#ifdef UNITY_EXCLUDE_DOUBLE 351 TEST_IGNORE(); 352#else 353 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, 2.0); 354 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(2.0, 2.0); 355 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0, 1.0); 356 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-2.0, -1.0); 357 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-2.0, -2.0); 358#endif 359} 360 361void testDoublesGreaterOrEqualInf(void) 362{ 363#ifdef UNITY_EXCLUDE_DOUBLE 364 TEST_IGNORE(); 365#else 366 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, 1.0 / d_zero); 367 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0 / d_zero, 1.0 / d_zero); 368 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0 / d_zero, 1.0); 369#endif 370} 371 372void testDoublesNotGreaterOrEqual(void) 373{ 374#ifdef UNITY_EXCLUDE_DOUBLE 375 TEST_IGNORE(); 376#else 377 EXPECT_ABORT_BEGIN 378 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(2.0, 1.0); 379 VERIFY_FAILS_END 380#endif 381} 382 383void testDoublesNotGreaterOrEqualNanActual(void) 384{ 385#ifdef UNITY_EXCLUDE_DOUBLE 386 TEST_IGNORE(); 387#else 388 EXPECT_ABORT_BEGIN 389 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, 0.0 / d_zero); 390 VERIFY_FAILS_END 391#endif 392} 393 394void testDoublesNotGreaterOrEqualNanThreshold(void) 395{ 396#ifdef UNITY_EXCLUDE_DOUBLE 397 TEST_IGNORE(); 398#else 399 EXPECT_ABORT_BEGIN 400 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(0.0 / d_zero, 1.0); 401 VERIFY_FAILS_END 402#endif 403} 404 405void testDoublesGreaterOrEqualNanBoth(void) 406{ 407#ifdef UNITY_EXCLUDE_DOUBLE 408 TEST_IGNORE(); 409#else 410 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero); 411#endif 412} 413 414void testDoublesNotGreaterOrEqualInfActual(void) 415{ 416#ifdef UNITY_EXCLUDE_DOUBLE 417 TEST_IGNORE(); 418#else 419 EXPECT_ABORT_BEGIN 420 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0); 421 VERIFY_FAILS_END 422#endif 423} 424 425void testDoublesNotGreaterOrEqualNegInf(void) 426{ 427#ifdef UNITY_EXCLUDE_DOUBLE 428 TEST_IGNORE(); 429#else 430 EXPECT_ABORT_BEGIN 431 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, -1.0 / d_zero); 432 VERIFY_FAILS_END 433#endif 434} 435 436void testDoublesGreaterOrEqualBothInf(void) 437{ 438#ifdef UNITY_EXCLUDE_DOUBLE 439 TEST_IGNORE(); 440#else 441 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero); 442#endif 443} 444 445void testDoublesGreaterOrEqualBothNegInf(void) 446{ 447#ifdef UNITY_EXCLUDE_DOUBLE 448 TEST_IGNORE(); 449#else 450 TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0 / d_zero, -1.0 / d_zero); 451#endif 452} 453 454void testDoublesLessThan(void) 455{ 456#ifdef UNITY_EXCLUDE_DOUBLE 457 TEST_IGNORE(); 458#else 459 TEST_ASSERT_LESS_THAN_DOUBLE(2.0, 1.0); 460 TEST_ASSERT_LESS_THAN_DOUBLE(1.0, -1.0); 461 TEST_ASSERT_LESS_THAN_DOUBLE(-1.0, -2.0); 462#endif 463} 464 465void testDoublesLessThanInf(void) 466{ 467#ifdef UNITY_EXCLUDE_DOUBLE 468 TEST_IGNORE(); 469#else 470 TEST_ASSERT_LESS_THAN_DOUBLE(1.0 / d_zero, 1.0); 471 TEST_ASSERT_LESS_THAN_DOUBLE(1.0 / d_zero, -1.0 / d_zero); 472 TEST_ASSERT_LESS_THAN_DOUBLE(1.0, -1.0 / d_zero); 473#endif 474} 475 476void testDoublesNotLessThan(void) 477{ 478#ifdef UNITY_EXCLUDE_DOUBLE 479 TEST_IGNORE(); 480#else 481 EXPECT_ABORT_BEGIN 482 TEST_ASSERT_LESS_THAN_DOUBLE(1.0, 2.0); 483 VERIFY_FAILS_END 484#endif 485} 486 487void testDoublesNotLessThanNanActual(void) 488{ 489#ifdef UNITY_EXCLUDE_DOUBLE 490 TEST_IGNORE(); 491#else 492 EXPECT_ABORT_BEGIN 493 TEST_ASSERT_LESS_THAN_DOUBLE(1.0, 0.0 / d_zero); 494 VERIFY_FAILS_END 495#endif 496} 497 498void testDoublesNotLessThanNanThreshold(void) 499{ 500#ifdef UNITY_EXCLUDE_DOUBLE 501 TEST_IGNORE(); 502#else 503 EXPECT_ABORT_BEGIN 504 TEST_ASSERT_LESS_THAN_DOUBLE(0.0 / d_zero, 1.0); 505 VERIFY_FAILS_END 506#endif 507} 508 509void testDoublesNotLessThanNanBoth(void) 510{ 511#ifdef UNITY_EXCLUDE_DOUBLE 512 TEST_IGNORE(); 513#else 514 EXPECT_ABORT_BEGIN 515 TEST_ASSERT_LESS_THAN_DOUBLE(0.0 / d_zero, 0.0 / d_zero); 516 VERIFY_FAILS_END 517#endif 518} 519 520void testDoublesNotLessThanInf(void) 521{ 522#ifdef UNITY_EXCLUDE_DOUBLE 523 TEST_IGNORE(); 524#else 525 EXPECT_ABORT_BEGIN 526 TEST_ASSERT_LESS_THAN_DOUBLE(1.0, 1.0 / d_zero); 527 VERIFY_FAILS_END 528#endif 529} 530 531void testDoublesNotLessThanNegInf(void) 532{ 533#ifdef UNITY_EXCLUDE_DOUBLE 534 TEST_IGNORE(); 535#else 536 EXPECT_ABORT_BEGIN 537 TEST_ASSERT_LESS_THAN_DOUBLE(-1.0 / d_zero, 1.0); 538 VERIFY_FAILS_END 539#endif 540} 541 542void testDoublesNotLessThanBothInf(void) 543{ 544#ifdef UNITY_EXCLUDE_DOUBLE 545 TEST_IGNORE(); 546#else 547 EXPECT_ABORT_BEGIN 548 TEST_ASSERT_LESS_THAN_DOUBLE(1.0 / d_zero, 1.0 / d_zero); 549 VERIFY_FAILS_END 550#endif 551} 552 553void testDoublesNotLessThanBothNegInf(void) 554{ 555#ifdef UNITY_EXCLUDE_DOUBLE 556 TEST_IGNORE(); 557#else 558 EXPECT_ABORT_BEGIN 559 TEST_ASSERT_LESS_THAN_DOUBLE(-1.0 / d_zero, -1.0 / d_zero); 560 VERIFY_FAILS_END 561#endif 562} 563 564void testDoublesLessOrEqual(void) 565{ 566#ifdef UNITY_EXCLUDE_DOUBLE 567 TEST_IGNORE(); 568#else 569 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(2.0, 1.0); 570 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(2.0, 2.0); 571 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, -1.0); 572 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-1.0, -2.0); 573 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-2.0, -2.0); 574#endif 575} 576 577void testDoublesLessOrEqualInf(void) 578{ 579#ifdef UNITY_EXCLUDE_DOUBLE 580 TEST_IGNORE(); 581#else 582 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0); 583 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero); 584 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, -1.0 / d_zero); 585#endif 586} 587 588void testDoublesNotLessOrEqual(void) 589{ 590#ifdef UNITY_EXCLUDE_DOUBLE 591 TEST_IGNORE(); 592#else 593 EXPECT_ABORT_BEGIN 594 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, 2.0); 595 VERIFY_FAILS_END 596#endif 597} 598 599void testDoublesNotLessOrEqualNanActual(void) 600{ 601#ifdef UNITY_EXCLUDE_DOUBLE 602 TEST_IGNORE(); 603#else 604 EXPECT_ABORT_BEGIN 605 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, 0.0 / d_zero); 606 VERIFY_FAILS_END 607#endif 608} 609 610void testDoublesNotLessOrEqualNanThreshold(void) 611{ 612#ifdef UNITY_EXCLUDE_DOUBLE 613 TEST_IGNORE(); 614#else 615 EXPECT_ABORT_BEGIN 616 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(0.0 / d_zero, 1.0); 617 VERIFY_FAILS_END 618#endif 619} 620 621void testDoublesLessOrEqualNanBoth(void) 622{ 623#ifdef UNITY_EXCLUDE_DOUBLE 624 TEST_IGNORE(); 625#else 626 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero); 627#endif 628} 629 630void testDoublesNotLessOrEqualInf(void) 631{ 632#ifdef UNITY_EXCLUDE_DOUBLE 633 TEST_IGNORE(); 634#else 635 EXPECT_ABORT_BEGIN 636 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, 1.0 / d_zero); 637 VERIFY_FAILS_END 638#endif 639} 640 641void testDoublesNotLessOrEqualNegInf(void) 642{ 643#ifdef UNITY_EXCLUDE_DOUBLE 644 TEST_IGNORE(); 645#else 646 EXPECT_ABORT_BEGIN 647 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-1.0 / d_zero, 1.0); 648 VERIFY_FAILS_END 649#endif 650} 651 652void testDoublesLessOrEqualBothInf(void) 653{ 654#ifdef UNITY_EXCLUDE_DOUBLE 655 TEST_IGNORE(); 656#else 657 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero); 658#endif 659} 660 661void testDoublesLessOrEqualBothNegInf(void) 662{ 663#ifdef UNITY_EXCLUDE_DOUBLE 664 TEST_IGNORE(); 665#else 666 TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-1.0 / d_zero, -1.0 / d_zero); 667#endif 668} 669 670void testDoubleIsPosInf1(void) 671{ 672#ifdef UNITY_EXCLUDE_DOUBLE 673 TEST_IGNORE(); 674#else 675 TEST_ASSERT_DOUBLE_IS_INF(2.0 / d_zero); 676#endif 677} 678 679void testDoubleIsPosInf2(void) 680{ 681#ifdef UNITY_EXCLUDE_DOUBLE 682 TEST_IGNORE(); 683#else 684 EXPECT_ABORT_BEGIN 685 TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0 / d_zero); 686 VERIFY_FAILS_END 687#endif 688} 689 690void testDoubleIsNegInf1(void) 691{ 692#ifdef UNITY_EXCLUDE_DOUBLE 693 TEST_IGNORE(); 694#else 695 TEST_ASSERT_DOUBLE_IS_NEG_INF(-3.0 / d_zero); 696#endif 697} 698 699void testDoubleIsNegInf2(void) 700{ 701#ifdef UNITY_EXCLUDE_DOUBLE 702 TEST_IGNORE(); 703#else 704 EXPECT_ABORT_BEGIN 705 TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(-3.0 / d_zero); 706 VERIFY_FAILS_END 707#endif 708} 709 710void testDoubleIsNotPosInf1(void) 711{ 712#ifdef UNITY_EXCLUDE_DOUBLE 713 TEST_IGNORE(); 714#else 715 EXPECT_ABORT_BEGIN 716 TEST_ASSERT_DOUBLE_IS_INF(2.0); 717 VERIFY_FAILS_END 718#endif 719} 720 721void testDoubleIsNotPosInf2(void) 722{ 723#ifdef UNITY_EXCLUDE_DOUBLE 724 TEST_IGNORE(); 725#else 726 TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0); 727#endif 728} 729 730void testDoubleIsNotNegInf(void) 731{ 732#ifdef UNITY_EXCLUDE_DOUBLE 733 TEST_IGNORE(); 734#else 735 EXPECT_ABORT_BEGIN 736 TEST_ASSERT_DOUBLE_IS_NEG_INF(-999.876); 737 VERIFY_FAILS_END 738#endif 739} 740 741void testDoubleIsNan1(void) 742{ 743#ifdef UNITY_EXCLUDE_DOUBLE 744 TEST_IGNORE(); 745#else 746 TEST_ASSERT_DOUBLE_IS_NAN(0.0 / d_zero); 747#endif 748} 749 750void testDoubleIsNan2(void) 751{ 752#ifdef UNITY_EXCLUDE_DOUBLE 753 TEST_IGNORE(); 754#else 755 EXPECT_ABORT_BEGIN 756 TEST_ASSERT_DOUBLE_IS_NOT_NAN(0.0 / d_zero); 757 VERIFY_FAILS_END 758#endif 759} 760 761void testDoubleIsNotNan1(void) 762{ 763#ifdef UNITY_EXCLUDE_DOUBLE 764 TEST_IGNORE(); 765#else 766 EXPECT_ABORT_BEGIN 767 TEST_ASSERT_DOUBLE_IS_NAN(234.9); 768 VERIFY_FAILS_END 769#endif 770} 771 772void testDoubleIsNotNan2(void) 773{ 774#ifdef UNITY_EXCLUDE_DOUBLE 775 TEST_IGNORE(); 776#else 777 TEST_ASSERT_DOUBLE_IS_NOT_NAN(234.9); 778#endif 779} 780 781void testDoubleInfIsNotNan(void) 782{ 783#ifdef UNITY_EXCLUDE_DOUBLE 784 TEST_IGNORE(); 785#else 786 EXPECT_ABORT_BEGIN 787 TEST_ASSERT_DOUBLE_IS_NAN(1.0 / d_zero); 788 VERIFY_FAILS_END 789#endif 790} 791 792void testDoubleNanIsNotInf(void) 793{ 794#ifdef UNITY_EXCLUDE_DOUBLE 795 TEST_IGNORE(); 796#else 797 EXPECT_ABORT_BEGIN 798 TEST_ASSERT_DOUBLE_IS_INF(0.0 / d_zero); 799 VERIFY_FAILS_END 800#endif 801} 802 803void testDoubleIsDeterminate1(void) 804{ 805#ifdef UNITY_EXCLUDE_DOUBLE 806 TEST_IGNORE(); 807#else 808 TEST_ASSERT_DOUBLE_IS_DETERMINATE(0.0); 809 TEST_ASSERT_DOUBLE_IS_DETERMINATE(123.3); 810 TEST_ASSERT_DOUBLE_IS_DETERMINATE(-88.3); 811#endif 812} 813 814void testDoubleIsDeterminate2(void) 815{ 816#ifdef UNITY_EXCLUDE_DOUBLE 817 TEST_IGNORE(); 818#else 819 EXPECT_ABORT_BEGIN 820 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-88.3); 821 VERIFY_FAILS_END 822#endif 823} 824 825void testDoubleIsNotDeterminate1(void) 826{ 827#ifdef UNITY_EXCLUDE_DOUBLE 828 TEST_IGNORE(); 829#else 830 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(1.0 / d_zero); 831 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-1.0 / d_zero); 832 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(0.0 / d_zero); 833#endif 834} 835 836void testDoubleIsNotDeterminate2(void) 837{ 838#ifdef UNITY_EXCLUDE_DOUBLE 839 TEST_IGNORE(); 840#else 841 EXPECT_ABORT_BEGIN 842 TEST_ASSERT_DOUBLE_IS_DETERMINATE(-1.0 / d_zero); 843 VERIFY_FAILS_END 844#endif 845} 846 847void testDoubleTraitFailsOnInvalidTrait(void) 848{ 849#ifdef UNITY_EXCLUDE_DOUBLE 850 TEST_IGNORE(); 851#else 852 EXPECT_ABORT_BEGIN 853 UnityAssertDoubleSpecial(1.0, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT); 854 VERIFY_FAILS_END 855#endif 856} 857 858void testEqualDoubleArrays(void) 859{ 860#ifdef UNITY_EXCLUDE_DOUBLE 861 TEST_IGNORE(); 862#else 863 double p0[] = {1.0, -8.0, 25.4, -0.123}; 864 double p1[] = {1.0, -8.0, 25.4, -0.123}; 865 double p2[] = {1.0, -8.0, 25.4, -0.2}; 866 double p3[] = {1.0, -23.0, 25.0, -0.26}; 867 868 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 1); 869 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 4); 870 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 871 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p2, 3); 872 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p3, 1); 873 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(NULL, NULL, 1); 874#endif 875} 876 877void testNotEqualDoubleArraysExpectedNull(void) 878{ 879#ifdef UNITY_EXCLUDE_DOUBLE 880 TEST_IGNORE(); 881#else 882 double* p0 = NULL; 883 double p1[] = {1.0, 8.0, 25.4, 0.252}; 884 885 EXPECT_ABORT_BEGIN 886 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 887 VERIFY_FAILS_END 888#endif 889} 890 891void testNotEqualDoubleArraysActualNull(void) 892{ 893#ifdef UNITY_EXCLUDE_DOUBLE 894 TEST_IGNORE(); 895#else 896 double p0[] = {1.0, 8.0, 25.4, 0.253}; 897 double* p1 = NULL; 898 899 EXPECT_ABORT_BEGIN 900 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 901 VERIFY_FAILS_END 902#endif 903} 904 905void testNotEqualDoubleArrays1(void) 906{ 907#ifdef UNITY_EXCLUDE_DOUBLE 908 TEST_IGNORE(); 909#else 910 double p0[] = {1.0, 8.0, 25.4, 0.25666666667}; 911 double p1[] = {1.0, 8.0, 25.4, 0.25666666666}; 912 913 EXPECT_ABORT_BEGIN 914 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 915 VERIFY_FAILS_END 916#endif 917} 918 919void testNotEqualDoubleArrays2(void) 920{ 921#ifdef UNITY_EXCLUDE_DOUBLE 922 TEST_IGNORE(); 923#else 924 double p0[] = {1.0, 8.0, 25.4, 0.253}; 925 double p1[] = {2.0, 8.0, 25.4, 0.253}; 926 927 EXPECT_ABORT_BEGIN 928 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 929 VERIFY_FAILS_END 930#endif 931} 932 933void testNotEqualDoubleArrays3(void) 934{ 935#ifdef UNITY_EXCLUDE_DOUBLE 936 TEST_IGNORE(); 937#else 938 double p0[] = {1.0, 8.0, 25.4, 0.253}; 939 double p1[] = {1.0, 8.0, 25.5, 0.253}; 940 941 EXPECT_ABORT_BEGIN 942 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 943 VERIFY_FAILS_END 944#endif 945} 946 947void testNotEqualDoubleArraysNegative1(void) 948{ 949#ifdef UNITY_EXCLUDE_DOUBLE 950 TEST_IGNORE(); 951#else 952 double p0[] = {-1.0, -8.0, -25.4, -0.2566666667}; 953 double p1[] = {-1.0, -8.0, -25.4, -0.2566666666}; 954 955 EXPECT_ABORT_BEGIN 956 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 957 VERIFY_FAILS_END 958#endif 959} 960 961void testNotEqualDoubleArraysNegative2(void) 962{ 963#ifdef UNITY_EXCLUDE_DOUBLE 964 TEST_IGNORE(); 965#else 966 double p0[] = {-1.0, -8.0, -25.4, -0.253}; 967 double p1[] = {-2.0, -8.0, -25.4, -0.253}; 968 969 EXPECT_ABORT_BEGIN 970 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 971 VERIFY_FAILS_END 972#endif 973} 974 975void testNotEqualDoubleArraysNegative3(void) 976{ 977#ifdef UNITY_EXCLUDE_DOUBLE 978 TEST_IGNORE(); 979#else 980 double p0[] = {-1.0, -8.0, -25.4, -0.253}; 981 double p1[] = {-1.0, -8.0, -25.5, -0.253}; 982 983 EXPECT_ABORT_BEGIN 984 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 985 VERIFY_FAILS_END 986#endif 987} 988 989void testEqualDoubleArraysNaN(void) 990{ 991#ifdef UNITY_EXCLUDE_DOUBLE 992 TEST_IGNORE(); 993#else 994 double p0[] = {1.0, 0.0 / d_zero, 25.4, 0.253}; 995 double p1[] = {1.0, 0.0 / d_zero, 25.4, 0.253}; 996 997 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 998#endif 999} 1000 1001void testEqualDoubleArraysInf(void) 1002{ 1003#ifdef UNITY_EXCLUDE_DOUBLE 1004 TEST_IGNORE(); 1005#else 1006 double p0[] = {1.0, 1.0 / d_zero, 25.4, 0.253}; 1007 double p1[] = {1.0, 1.0 / d_zero, 25.4, 0.253}; 1008 1009 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 1010#endif 1011} 1012 1013void testNotEqualDoubleArraysLengthZero(void) 1014{ 1015#ifdef UNITY_EXCLUDE_DOUBLE 1016 TEST_IGNORE(); 1017#else 1018 double p0[1] = {0.0}; 1019 double p1[1] = {0.0}; 1020 1021 EXPECT_ABORT_BEGIN 1022 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 0); 1023 VERIFY_FAILS_END 1024#endif 1025} 1026 1027void testDoubleArraysWithin(void) 1028{ 1029#ifdef UNITY_EXCLUDE_DOUBLE 1030 TEST_IGNORE(); 1031#else 1032 double p0[] = {1.0, -8.0, 25.4, -0.123}; 1033 double p1[] = {1.0, -8.0, 25.4, -0.123}; 1034 double p2[] = {1.0, -8.0, 25.4, -0.2}; 1035 double p3[] = {1.0, -23.0, 25.0, -0.26}; 1036 double p4[] = {2.0, -9.0, 26.2, 0.26}; 1037 double p5[] = {-1.0, -7.0, 29.0, 2.6}; 1038 1039 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p0, 1); 1040 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p0, 4); 1041 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p1, 4); 1042 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p2, 3); 1043 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p3, 1); 1044 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p4, 1); 1045 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p4, 4); 1046 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(2.0, p0, p5, 1); 1047 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(2.0, p0, p5, 2); 1048 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, NULL, NULL, 1); 1049#endif 1050} 1051 1052void testDoubleArraysWithinUnusualDelta(void) 1053{ 1054#ifdef UNITY_EXCLUDE_DOUBLE 1055 TEST_IGNORE(); 1056#else 1057 double p0[] = {-INFINITY, -8.0, 25.4, -0.123}; 1058 double p1[] = {INFINITY, 10.1}; 1059 1060 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(INFINITY, p0, p1, 2); 1061 1062 EXPECT_ABORT_BEGIN 1063 TEST_ASSERT_DOUBLE_ARRAY_WITHIN(NAN, p0, p0, 4); 1064 VERIFY_FAILS_END 1065#endif 1066} 1067 1068void testEqualDoubleEachEqual(void) 1069{ 1070#ifdef UNITY_EXCLUDE_DOUBLE 1071 TEST_IGNORE(); 1072#else 1073 double p0[] = {1.0, 1.0, 1.0, 1.0}; 1074 double p1[] = {-0.123, -0.123, -0.123, -0.123}; 1075 double p2[] = {25.4, 25.4, 25.4, -0.2}; 1076 double p3[] = {1.0, -23.0, 25.0, -0.26}; 1077 1078 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 1); 1079 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4); 1080 TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.123, p1, 4); 1081 TEST_ASSERT_EACH_EQUAL_DOUBLE(25.4, p2, 3); 1082 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p3, 1); 1083#endif 1084} 1085 1086void testNotEqualDoubleEachEqualActualNull(void) 1087{ 1088#ifdef UNITY_EXCLUDE_DOUBLE 1089 TEST_IGNORE(); 1090#else 1091 double* p0 = NULL; 1092 1093 EXPECT_ABORT_BEGIN 1094 TEST_ASSERT_EACH_EQUAL_DOUBLE(5, p0, 4); 1095 VERIFY_FAILS_END 1096#endif 1097} 1098 1099void testNotEqualDoubleEachEqual1(void) 1100{ 1101#ifdef UNITY_EXCLUDE_DOUBLE 1102 TEST_IGNORE(); 1103#else 1104 double p0[] = {0.253, 8.0, 0.253, 0.253}; 1105 1106 EXPECT_ABORT_BEGIN 1107 TEST_ASSERT_EACH_EQUAL_DOUBLE(0.253, p0, 4); 1108 VERIFY_FAILS_END 1109#endif 1110} 1111 1112void testNotEqualDoubleEachEqual2(void) 1113{ 1114#ifdef UNITY_EXCLUDE_DOUBLE 1115 TEST_IGNORE(); 1116#else 1117 double p0[] = {8.0, 8.0, 8.0, 0.253}; 1118 1119 EXPECT_ABORT_BEGIN 1120 TEST_ASSERT_EACH_EQUAL_DOUBLE(8.0, p0, 4); 1121 VERIFY_FAILS_END 1122#endif 1123} 1124 1125void testNotEqualDoubleEachEqual3(void) 1126{ 1127#ifdef UNITY_EXCLUDE_DOUBLE 1128 TEST_IGNORE(); 1129#else 1130 double p0[] = {1.0, 1.0, 1.0, 0.253}; 1131 1132 EXPECT_ABORT_BEGIN 1133 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0, p0, 4); 1134 VERIFY_FAILS_END 1135#endif 1136} 1137 1138void testNotEqualDoubleEachEqualNegative1(void) 1139{ 1140#ifdef UNITY_EXCLUDE_DOUBLE 1141 TEST_IGNORE(); 1142#else 1143 double p0[] = {-1.0, -0.253, -0.253, -0.253}; 1144 1145 EXPECT_ABORT_BEGIN 1146 TEST_ASSERT_EACH_EQUAL_DOUBLE(-0.253, p0, 4); 1147 VERIFY_FAILS_END 1148#endif 1149} 1150 1151void testNotEqualDoubleEachEqualNegative2(void) 1152{ 1153#ifdef UNITY_EXCLUDE_DOUBLE 1154 TEST_IGNORE(); 1155#else 1156 double p0[] = {-25.4, -8.0, -25.4, -25.4}; 1157 1158 EXPECT_ABORT_BEGIN 1159 TEST_ASSERT_EACH_EQUAL_DOUBLE(-25.4, p0, 4); 1160 VERIFY_FAILS_END 1161#endif 1162} 1163 1164void testNotEqualDoubleEachEqualNegative3(void) 1165{ 1166#ifdef UNITY_EXCLUDE_DOUBLE 1167 TEST_IGNORE(); 1168#else 1169 double p0[] = {-8.0, -8.0, -8.0, -0.253}; 1170 1171 EXPECT_ABORT_BEGIN 1172 TEST_ASSERT_EACH_EQUAL_DOUBLE(-8.0, p0, 4); 1173 VERIFY_FAILS_END 1174#endif 1175} 1176 1177void testEqualDoubleEachEqualNaN(void) 1178{ 1179#ifdef UNITY_EXCLUDE_DOUBLE 1180 TEST_IGNORE(); 1181#else 1182 double p0[] = {0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero, 0.0 / d_zero}; 1183 1184 TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0 / d_zero, p0, 4); 1185#endif 1186} 1187 1188void testEqualDoubleEachEqualInf(void) 1189{ 1190#ifdef UNITY_EXCLUDE_DOUBLE 1191 TEST_IGNORE(); 1192#else 1193 double p0[] = {1.0 / d_zero, 1.0 / d_zero, 25.4, 0.253}; 1194 1195 TEST_ASSERT_EACH_EQUAL_DOUBLE(1.0 / d_zero, p0, 2); 1196#endif 1197} 1198 1199void testNotEqualDoubleEachEqualLengthZero(void) 1200{ 1201#ifdef UNITY_EXCLUDE_DOUBLE 1202 TEST_IGNORE(); 1203#else 1204 double p0[1] = {0.0}; 1205 1206 EXPECT_ABORT_BEGIN 1207 TEST_ASSERT_EACH_EQUAL_DOUBLE(0.0, p0, 0); 1208 VERIFY_FAILS_END 1209#endif 1210} 1211 1212void testDoublePrinting(void) 1213{ 1214#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) 1215 TEST_IGNORE(); 1216#else 1217 TEST_ASSERT_EQUAL_PRINT_FLOATING("0", 0.0); 1218 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.99e-07", 0.000000499); 1219 TEST_ASSERT_EQUAL_PRINT_FLOATING("5.0000005e-07", 0.00000050000005); 1220 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469499", 0.100469499); 1221 TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 0.9999999995); /*Rounding to int place*/ 1222 TEST_ASSERT_EQUAL_PRINT_FLOATING("1", 1.0); 1223 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.25", 1.25); 1224 TEST_ASSERT_EQUAL_PRINT_FLOATING("7.99999999", 7.99999999); /*Not rounding*/ 1225 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000002", 16.0000002); 1226 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000004", 16.0000004); 1227 TEST_ASSERT_EQUAL_PRINT_FLOATING("16.0000006", 16.0000006); 1228 TEST_ASSERT_EQUAL_PRINT_FLOATING("999999999", 999999999.0); /*Last full print integer*/ 1229 1230 TEST_ASSERT_EQUAL_PRINT_FLOATING("0", -0.0); /* -0 no supported on all targets */ 1231 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.99e-07", -0.000000499); 1232 TEST_ASSERT_EQUAL_PRINT_FLOATING("-5.0000005e-07", -0.00000050000005); 1233 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469499", -0.100469499); 1234 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -0.9999999995); /*Rounding to int place*/ 1235 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1", -1.0); 1236 TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25", -1.25); 1237 TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.99999999", -7.99999999); /*Not rounding*/ 1238 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000002", -16.0000002); 1239 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000004", -16.0000004); 1240 TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.0000006", -16.0000006); 1241 TEST_ASSERT_EQUAL_PRINT_FLOATING("-999999999", -999999999.0); /*Last full print integer*/ 1242 1243 TEST_ASSERT_EQUAL_PRINT_FLOATING("0.1004695", 0.10046949999999999); 1244 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967295.9); 1245 TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09", 4294967296.0); 1246 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 9999999995.0); 1247 TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199254740990.0); 1248 TEST_ASSERT_EQUAL_PRINT_FLOATING("7e+100", 7.0e+100); 1249 TEST_ASSERT_EQUAL_PRINT_FLOATING("3e+200", 3.0e+200); 1250 TEST_ASSERT_EQUAL_PRINT_FLOATING("9.23456789e+300", 9.23456789e+300); 1251 1252 TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.1004695", -0.10046949999999999); 1253 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967295.9); 1254 TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09", -4294967296.0); 1255 TEST_ASSERT_EQUAL_PRINT_FLOATING("-7e+100", -7.0e+100); 1256#endif 1257} 1258 1259void testDoublePrintingRoundTiesToEven(void) 1260{ 1261#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) 1262 TEST_IGNORE(); 1263#else 1264 #ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO 1265 TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00000001e+10", 10000000050.0); 1266 TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199245000000.0); 1267 #else /* Default to Round ties to even */ 1268 TEST_ASSERT_EQUAL_PRINT_FLOATING("1e+10", 10000000050.0); 1269 TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719924e+15", 9007199245000000.0); 1270 #endif 1271#endif 1272} 1273 1274void testDoublePrintingInfinityAndNaN(void) 1275{ 1276#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY) 1277 TEST_IGNORE(); 1278#else 1279 TEST_ASSERT_EQUAL_PRINT_FLOATING("inf", 1.0 / d_zero); 1280 TEST_ASSERT_EQUAL_PRINT_FLOATING("-inf", -1.0 / d_zero); 1281 1282 TEST_ASSERT_EQUAL_PRINT_FLOATING("nan", 0.0 / d_zero); 1283#endif 1284} 1285