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 testNotEqualInts(void) 37{ 38 EXPECT_ABORT_BEGIN 39 TEST_ASSERT_EQUAL_INT(3982, 3983); 40 VERIFY_FAILS_END 41} 42 43void testNotEqualInt8s(void) 44{ 45 EXPECT_ABORT_BEGIN 46 TEST_ASSERT_EQUAL_INT8(-127, -126); 47 VERIFY_FAILS_END 48} 49 50void testNotEqualChars(void) 51{ 52 EXPECT_ABORT_BEGIN 53 TEST_ASSERT_EQUAL_CHAR('A', 'a'); 54 VERIFY_FAILS_END 55} 56 57void testNotEqualInt16s(void) 58{ 59 EXPECT_ABORT_BEGIN 60 TEST_ASSERT_EQUAL_INT16(-16383, -16382); 61 VERIFY_FAILS_END 62} 63 64void testNotEqualInt32s(void) 65{ 66 EXPECT_ABORT_BEGIN 67 /*use largest 32 bit negative to test printability*/ 68 /*note: (-2147483647 - 1) is used instead of -2147483648 because of C90 casting rules */ 69 TEST_ASSERT_EQUAL_INT32(-2147483647, (-2147483647 - 1)); 70 VERIFY_FAILS_END 71} 72 73void testNotEqualBits(void) 74{ 75 EXPECT_ABORT_BEGIN 76 TEST_ASSERT_BITS(0xFF00, 0x5555, 0x5A55); 77 VERIFY_FAILS_END 78} 79 80void testNotEqualUInts(void) 81{ 82 UNITY_UINT16 v0, v1; 83 84 v0 = 9000; 85 v1 = 9001; 86 87 EXPECT_ABORT_BEGIN 88 TEST_ASSERT_EQUAL_UINT(v0, v1); 89 VERIFY_FAILS_END 90} 91 92void testNotEqualUInt8s(void) 93{ 94 UNITY_UINT8 v0, v1; 95 96 v0 = 254; 97 v1 = 255; 98 99 EXPECT_ABORT_BEGIN 100 TEST_ASSERT_EQUAL_UINT8(v0, v1); 101 VERIFY_FAILS_END 102} 103 104void testNotEqualUInt16s(void) 105{ 106 UNITY_UINT16 v0, v1; 107 108 v0 = 65535u; 109 v1 = 65534u; 110 111 EXPECT_ABORT_BEGIN 112 TEST_ASSERT_EQUAL_UINT16(v0, v1); 113 VERIFY_FAILS_END 114} 115 116void testNotEqualUInt32s(void) 117{ 118 UNITY_UINT32 v0, v1; 119 120 v0 = 4294967295u; 121 v1 = 4294967294u; 122 123 EXPECT_ABORT_BEGIN 124 TEST_ASSERT_EQUAL_UINT32(v0, v1); 125 VERIFY_FAILS_END 126} 127 128void testNotEqualHex8s(void) 129{ 130 UNITY_UINT8 v0, v1; 131 132 v0 = 0x23; 133 v1 = 0x22; 134 135 EXPECT_ABORT_BEGIN 136 TEST_ASSERT_EQUAL_HEX8(v0, v1); 137 VERIFY_FAILS_END 138} 139 140void testNotEqualHex8sIfSigned(void) 141{ 142 UNITY_INT8 v0, v1; 143 144 v0 = -2; 145 v1 = 2; 146 147 EXPECT_ABORT_BEGIN 148 TEST_ASSERT_EQUAL_HEX8(v0, v1); 149 VERIFY_FAILS_END 150} 151 152void testNotEqualHex16s(void) 153{ 154 UNITY_UINT16 v0, v1; 155 156 v0 = 0x1234; 157 v1 = 0x1235; 158 159 EXPECT_ABORT_BEGIN 160 TEST_ASSERT_EQUAL_HEX16(v0, v1); 161 VERIFY_FAILS_END 162} 163 164void testNotEqualHex16sIfSigned(void) 165{ 166 UNITY_INT16 v0, v1; 167 168 v0 = -1024; 169 v1 = -1028; 170 171 EXPECT_ABORT_BEGIN 172 TEST_ASSERT_EQUAL_HEX16(v0, v1); 173 VERIFY_FAILS_END 174} 175 176void testNotEqualHex32s(void) 177{ 178 UNITY_UINT32 v0, v1; 179 180 v0 = 900000; 181 v1 = 900001; 182 183 EXPECT_ABORT_BEGIN 184 TEST_ASSERT_EQUAL_HEX32(v0, v1); 185 VERIFY_FAILS_END 186} 187 188void testNotEqualHex32sIfSigned(void) 189{ 190 UNITY_INT32 v0, v1; 191 192 v0 = -900000; 193 v1 = 900001; 194 195 EXPECT_ABORT_BEGIN 196 TEST_ASSERT_EQUAL_HEX32(v0, v1); 197 VERIFY_FAILS_END 198} 199 200void testEqualInts(void) 201{ 202 int v0, v1; 203 int *p0, *p1; 204 205 v0 = 19467; 206 v1 = 19467; 207 p0 = &v0; 208 p1 = &v1; 209 210 TEST_ASSERT_EQUAL_INT(1837, 1837); 211 TEST_ASSERT_EQUAL_INT(-27365, -27365); 212 TEST_ASSERT_EQUAL_INT(v0, v1); 213 TEST_ASSERT_EQUAL_INT(19467, v1); 214 TEST_ASSERT_EQUAL_INT(v0, 19467); 215 TEST_ASSERT_EQUAL_INT(*p0, v1); 216 TEST_ASSERT_EQUAL_INT(*p0, *p1); 217 TEST_ASSERT_EQUAL_INT(*p0, 19467); 218} 219 220void testEqualInt8s(void) 221{ 222 UNITY_INT8 v0, v1; 223 UNITY_INT8 *p0, *p1; 224 225 v0 = 0x22; 226 v1 = 0x22; 227 p0 = &v0; 228 p1 = &v1; 229 230 TEST_ASSERT_EQUAL_INT8(0x22, 0x22); 231 TEST_ASSERT_EQUAL_INT8(v0, v1); 232 TEST_ASSERT_EQUAL_INT8(0x22, v1); 233 TEST_ASSERT_EQUAL_INT8(v0, 0x22); 234 TEST_ASSERT_EQUAL_INT8(*p0, v1); 235 TEST_ASSERT_EQUAL_INT8(*p0, *p1); 236 TEST_ASSERT_EQUAL_INT8(*p0, 0x22); 237} 238 239void testEqualInt8sWhenThereAreDifferencesOutside8Bits(void) 240{ 241 TEST_ASSERT_EQUAL_INT8(0x321,0x421); 242 TEST_ASSERT_EQUAL_INT8(0xFF21,0x0021); 243} 244 245void testEqualChars(void) 246{ 247 char v0, v1; 248 char *p0, *p1; 249 250 v0 = 'A'; 251 v1 = 'A'; 252 p0 = &v0; 253 p1 = &v1; 254 255 TEST_ASSERT_EQUAL_CHAR('A', 'A'); 256 TEST_ASSERT_EQUAL_CHAR(v0, v1); 257 TEST_ASSERT_EQUAL_CHAR('A', v1); 258 TEST_ASSERT_EQUAL_CHAR(v0, 'A'); 259 TEST_ASSERT_EQUAL_CHAR(*p0, v1); 260 TEST_ASSERT_EQUAL_CHAR(*p0, *p1); 261 TEST_ASSERT_EQUAL_CHAR(*p0, 'A'); 262} 263 264void testEqualCharsWhenThereAreDifferencesOutside8Bits(void) 265{ 266 TEST_ASSERT_EQUAL_CHAR(0x321,0x421); 267 TEST_ASSERT_EQUAL_CHAR(0xFF21,0x0021); 268} 269 270 271void testEqualInt16s(void) 272{ 273 UNITY_INT16 v0, v1; 274 UNITY_INT16 *p0, *p1; 275 276 v0 = 0x7876; 277 v1 = 0x7876; 278 p0 = &v0; 279 p1 = &v1; 280 281 TEST_ASSERT_EQUAL_INT16(0x7876, 0x7876); 282 TEST_ASSERT_EQUAL_INT16(v0, v1); 283 TEST_ASSERT_EQUAL_INT16(0x7876, v1); 284 TEST_ASSERT_EQUAL_INT16(v0, 0x7876); 285 TEST_ASSERT_EQUAL_INT16(*p0, v1); 286 TEST_ASSERT_EQUAL_INT16(*p0, *p1); 287 TEST_ASSERT_EQUAL_INT16(*p0, 0x7876); 288} 289 290void testEqualInt16sNegatives(void) 291{ 292 UNITY_INT16 v0, v1; 293 UNITY_INT16 *p0, *p1; 294 295 v0 = -7876; 296 v1 = -7876; 297 p0 = &v0; 298 p1 = &v1; 299 300 TEST_ASSERT_EQUAL_INT16(-7876, -7876); 301 TEST_ASSERT_EQUAL_INT16(v0, v1); 302 TEST_ASSERT_EQUAL_INT16(-7876, v1); 303 TEST_ASSERT_EQUAL_INT16(v0, -7876); 304 TEST_ASSERT_EQUAL_INT16(*p0, v1); 305 TEST_ASSERT_EQUAL_INT16(*p0, *p1); 306 TEST_ASSERT_EQUAL_INT16(*p0, -7876); 307} 308 309void testEqualInt16sWhenThereAreDifferencesOutside16Bits(void) 310{ 311 TEST_ASSERT_EQUAL_INT16(0x54321,0x64321); 312 TEST_ASSERT_EQUAL_INT16(0xFFFF4321,0x00004321); 313} 314 315void testEqualInt32s(void) 316{ 317 UNITY_INT32 v0, v1; 318 UNITY_INT32 *p0, *p1; 319 320 v0 = 0x78760000; 321 v1 = 0x78760000; 322 p0 = &v0; 323 p1 = &v1; 324 325 TEST_ASSERT_EQUAL_INT32(0x78760000, 0x78760000); 326 TEST_ASSERT_EQUAL_INT32(v0, v1); 327 TEST_ASSERT_EQUAL_INT32(0x78760000, v1); 328 TEST_ASSERT_EQUAL_INT32(v0, 0x78760000); 329 TEST_ASSERT_EQUAL_INT32(*p0, v1); 330 TEST_ASSERT_EQUAL_INT32(*p0, *p1); 331 TEST_ASSERT_EQUAL_INT32(*p0, 0x78760000); 332} 333 334void testEqualInt32sNegatives(void) 335{ 336 UNITY_INT32 v0, v1; 337 UNITY_INT32 *p0, *p1; 338 339 v0 = -123456789; 340 v1 = -123456789; 341 p0 = &v0; 342 p1 = &v1; 343 344 TEST_ASSERT_EQUAL_INT32(-123456789, -123456789); 345 TEST_ASSERT_EQUAL_INT32(v0, v1); 346 TEST_ASSERT_EQUAL_INT32(-123456789, v1); 347 TEST_ASSERT_EQUAL_INT32(v0, -123456789); 348 TEST_ASSERT_EQUAL_INT32(*p0, v1); 349 TEST_ASSERT_EQUAL_INT32(*p0, *p1); 350 TEST_ASSERT_EQUAL_INT32(*p0, -123456789); 351} 352 353 354void testEqualUints(void) 355{ 356 unsigned int v0, v1; 357 unsigned int *p0, *p1; 358 359 v0 = 19467; 360 v1 = 19467; 361 p0 = &v0; 362 p1 = &v1; 363 364 TEST_ASSERT_EQUAL_UINT(1837, 1837); 365 TEST_ASSERT_EQUAL_UINT(v0, v1); 366 TEST_ASSERT_EQUAL_UINT(19467, v1); 367 TEST_ASSERT_EQUAL_UINT(v0, 19467); 368 TEST_ASSERT_EQUAL_UINT(*p0, v1); 369 TEST_ASSERT_EQUAL_UINT(*p0, *p1); 370 TEST_ASSERT_EQUAL_UINT(*p0, 19467); 371 TEST_ASSERT_EQUAL_UINT(60872u, 60872u); 372} 373 374 375void testEqualUint8s(void) 376{ 377 UNITY_UINT8 v0, v1; 378 UNITY_UINT8 *p0, *p1; 379 380 v0 = 0x22; 381 v1 = 0x22; 382 p0 = &v0; 383 p1 = &v1; 384 385 TEST_ASSERT_EQUAL_UINT8(0x22, 0x22); 386 TEST_ASSERT_EQUAL_UINT8(v0, v1); 387 TEST_ASSERT_EQUAL_UINT8(0x22, v1); 388 TEST_ASSERT_EQUAL_UINT8(v0, 0x22); 389 TEST_ASSERT_EQUAL_UINT8(*p0, v1); 390 TEST_ASSERT_EQUAL_UINT8(*p0, *p1); 391 TEST_ASSERT_EQUAL_UINT8(*p0, 0x22); 392} 393 394void testEqualUint8sWhenThereAreDifferencesOutside8Bits(void) 395{ 396 TEST_ASSERT_EQUAL_UINT8(0x321,0x421); 397 TEST_ASSERT_EQUAL_UINT8(0xFF21,0x0021); 398} 399 400void testEqualUint16s(void) 401{ 402 UNITY_UINT16 v0, v1; 403 UNITY_UINT16 *p0, *p1; 404 405 v0 = 0x9876; 406 v1 = 0x9876; 407 p0 = &v0; 408 p1 = &v1; 409 410 TEST_ASSERT_EQUAL_UINT16(0x9876, 0x9876); 411 TEST_ASSERT_EQUAL_UINT16(v0, v1); 412 TEST_ASSERT_EQUAL_UINT16(0x9876, v1); 413 TEST_ASSERT_EQUAL_UINT16(v0, 0x9876); 414 TEST_ASSERT_EQUAL_UINT16(*p0, v1); 415 TEST_ASSERT_EQUAL_UINT16(*p0, *p1); 416 TEST_ASSERT_EQUAL_UINT16(*p0, 0x9876); 417} 418 419void testEqualUint16sWhenThereAreDifferencesOutside16Bits(void) 420{ 421 TEST_ASSERT_EQUAL_UINT16(0x54321,0x64321); 422 TEST_ASSERT_EQUAL_UINT16(0xFFFF4321,0x00004321); 423} 424 425void testEqualUint32s(void) 426{ 427 UNITY_UINT32 v0, v1; 428 UNITY_UINT32 *p0, *p1; 429 430 v0 = 0x98760000; 431 v1 = 0x98760000; 432 p0 = &v0; 433 p1 = &v1; 434 435 TEST_ASSERT_EQUAL_UINT32(0x98760000, 0x98760000); 436 TEST_ASSERT_EQUAL_UINT32(v0, v1); 437 TEST_ASSERT_EQUAL_UINT32(0x98760000, v1); 438 TEST_ASSERT_EQUAL_UINT32(v0, 0x98760000); 439 TEST_ASSERT_EQUAL_UINT32(*p0, v1); 440 TEST_ASSERT_EQUAL_UINT32(*p0, *p1); 441 TEST_ASSERT_EQUAL_UINT32(*p0, 0x98760000); 442} 443 444void testNotEqual(void) 445{ 446 TEST_ASSERT_NOT_EQUAL(0, 1); 447 TEST_ASSERT_NOT_EQUAL(1, 0); 448 TEST_ASSERT_NOT_EQUAL(100, 101); 449 TEST_ASSERT_NOT_EQUAL(0, -1); 450 TEST_ASSERT_NOT_EQUAL(65535, -65535); 451 TEST_ASSERT_NOT_EQUAL(75, 900); 452 TEST_ASSERT_NOT_EQUAL(-100, -101); 453} 454 455void testEqualHex8s(void) 456{ 457 UNITY_UINT8 v0, v1; 458 UNITY_UINT8 *p0, *p1; 459 460 v0 = 0x22; 461 v1 = 0x22; 462 p0 = &v0; 463 p1 = &v1; 464 465 TEST_ASSERT_EQUAL_HEX8(0x22, 0x22); 466 TEST_ASSERT_EQUAL_HEX8(v0, v1); 467 TEST_ASSERT_EQUAL_HEX8(0x22, v1); 468 TEST_ASSERT_EQUAL_HEX8(v0, 0x22); 469 TEST_ASSERT_EQUAL_HEX8(*p0, v1); 470 TEST_ASSERT_EQUAL_HEX8(*p0, *p1); 471 TEST_ASSERT_EQUAL_HEX8(*p0, 0x22); 472} 473 474void testEqualHex8sWhenThereAreDifferencesOutside8Bits(void) 475{ 476 TEST_ASSERT_EQUAL_HEX8(0x321,0x421); 477 TEST_ASSERT_EQUAL_HEX8(0xFF21,0x0021); 478} 479 480void testEqualHex8sNegatives(void) 481{ 482 UNITY_UINT8 v0, v1; 483 UNITY_UINT8 *p0, *p1; 484 485 v0 = 0xDD; 486 v1 = 0xDD; 487 p0 = &v0; 488 p1 = &v1; 489 490 TEST_ASSERT_EQUAL_HEX8(0xDD, 0xDD); 491 TEST_ASSERT_EQUAL_HEX8(v0, v1); 492 TEST_ASSERT_EQUAL_HEX8(0xDD, v1); 493 TEST_ASSERT_EQUAL_HEX8(v0, 0xDD); 494 TEST_ASSERT_EQUAL_HEX8(*p0, v1); 495 TEST_ASSERT_EQUAL_HEX8(*p0, *p1); 496 TEST_ASSERT_EQUAL_HEX8(*p0, 0xDD); 497} 498 499void testEqualHex16s(void) 500{ 501 UNITY_UINT16 v0, v1; 502 UNITY_UINT16 *p0, *p1; 503 504 v0 = 0x9876; 505 v1 = 0x9876; 506 p0 = &v0; 507 p1 = &v1; 508 509 TEST_ASSERT_EQUAL_HEX16(0x9876, 0x9876); 510 TEST_ASSERT_EQUAL_HEX16(v0, v1); 511 TEST_ASSERT_EQUAL_HEX16(0x9876, v1); 512 TEST_ASSERT_EQUAL_HEX16(v0, 0x9876); 513 TEST_ASSERT_EQUAL_HEX16(*p0, v1); 514 TEST_ASSERT_EQUAL_HEX16(*p0, *p1); 515 TEST_ASSERT_EQUAL_HEX16(*p0, 0x9876); 516} 517 518void testEqualHex16sWhenThereAreDifferencesOutside16Bits(void) 519{ 520 TEST_ASSERT_EQUAL_HEX16(0x54321,0x64321); 521 TEST_ASSERT_EQUAL_HEX16(0xFFFF4321,0x00004321); 522} 523 524void testEqualHex32s(void) 525{ 526 UNITY_UINT32 v0, v1; 527 UNITY_UINT32 *p0, *p1; 528 529 v0 = 0x98765432ul; 530 v1 = 0x98765432ul; 531 p0 = &v0; 532 p1 = &v1; 533 534 TEST_ASSERT_EQUAL_HEX32(0x98765432ul, 0x98765432ul); 535 TEST_ASSERT_EQUAL_HEX32(v0, v1); 536 TEST_ASSERT_EQUAL_HEX32(0x98765432ul, v1); 537 TEST_ASSERT_EQUAL_HEX32(v0, 0x98765432ul); 538 TEST_ASSERT_EQUAL_HEX32(*p0, v1); 539 TEST_ASSERT_EQUAL_HEX32(*p0, *p1); 540 TEST_ASSERT_EQUAL_HEX32(*p0, 0x98765432ul); 541} 542 543void testEqualBits(void) 544{ 545 UNITY_UINT32 v0 = 0xFF55AA00; 546 UNITY_UINT32 v1 = 0x55550000; 547 548 TEST_ASSERT_BITS(v1, v0, 0x55550000); 549 TEST_ASSERT_BITS(v1, v0, 0xFF55CC00); 550 TEST_ASSERT_BITS(0xFFFFFFFF, v0, 0xFF55AA00); 551 TEST_ASSERT_BITS(0xFFFFFFFF, v0, v0); 552 TEST_ASSERT_BITS(0xF0F0F0F0, v0, 0xFC5DAE0F); 553 TEST_ASSERT_BITS_HIGH(v1, v0); 554 TEST_ASSERT_BITS_LOW(0x000055FF, v0); 555 TEST_ASSERT_BIT_HIGH(30, v0); 556 TEST_ASSERT_BIT_LOW(5, v0); 557} 558 559void testNotEqualBitHigh(void) 560{ 561 UNITY_UINT32 v0 = 0x7F55AA00; 562 563 EXPECT_ABORT_BEGIN 564 TEST_ASSERT_BIT_HIGH(31, v0); 565 VERIFY_FAILS_END 566} 567 568void testNotEqualBitLow(void) 569{ 570 UNITY_UINT32 v0 = 0xFF55AA00; 571 572 EXPECT_ABORT_BEGIN 573 TEST_ASSERT_BIT_LOW(30, v0); 574 VERIFY_FAILS_END 575} 576 577void testNotEqualBitsHigh(void) 578{ 579 UNITY_UINT32 v0 = 0xFF55AA00; 580 UNITY_UINT32 v1 = 0x55550000; 581 582 EXPECT_ABORT_BEGIN 583 TEST_ASSERT_BITS_HIGH(v0, v1); 584 VERIFY_FAILS_END 585 586} 587 588void testNotEqualBitsLow(void) 589{ 590 UNITY_UINT32 v0 = 0xFF55AA00; 591 UNITY_UINT32 v1 = 0x55550000; 592 593 EXPECT_ABORT_BEGIN 594 TEST_ASSERT_BITS_LOW(v0, v1); 595 VERIFY_FAILS_END 596} 597 598 599void testEqualShorts(void) 600{ 601 short v0, v1; 602 short *p0, *p1; 603 604 v0 = 19467; 605 v1 = 19467; 606 p0 = &v0; 607 p1 = &v1; 608 609 TEST_ASSERT_EQUAL_INT(1837, 1837); 610 TEST_ASSERT_EQUAL_INT(-2987, -2987); 611 TEST_ASSERT_EQUAL_INT(v0, v1); 612 TEST_ASSERT_EQUAL_INT(19467, v1); 613 TEST_ASSERT_EQUAL_INT(v0, 19467); 614 TEST_ASSERT_EQUAL_INT(*p0, v1); 615 TEST_ASSERT_EQUAL_INT(*p0, *p1); 616 TEST_ASSERT_EQUAL_INT(*p0, 19467); 617} 618 619void testEqualUShorts(void) 620{ 621 unsigned short v0, v1; 622 unsigned short *p0, *p1; 623 624 v0 = 19467; 625 v1 = 19467; 626 p0 = &v0; 627 p1 = &v1; 628 629 TEST_ASSERT_EQUAL_UINT(1837, 1837); 630 TEST_ASSERT_EQUAL_UINT(2987, 2987); 631 TEST_ASSERT_EQUAL_UINT(v0, v1); 632 TEST_ASSERT_EQUAL_UINT(19467, v1); 633 TEST_ASSERT_EQUAL_UINT(v0, 19467); 634 TEST_ASSERT_EQUAL_UINT(*p0, v1); 635 TEST_ASSERT_EQUAL_UINT(*p0, *p1); 636 TEST_ASSERT_EQUAL_UINT(*p0, 19467); 637} 638 639void testEqualUInts(void) 640{ 641 unsigned char v0, v1; 642 unsigned char *p0, *p1; 643 644 v0 = 109; 645 v1 = 109; 646 p0 = &v0; 647 p1 = &v1; 648 649 TEST_ASSERT_EQUAL_UINT(42, 42); 650 TEST_ASSERT_EQUAL_UINT(-116, -116); 651 TEST_ASSERT_EQUAL_UINT(v0, v1); 652 TEST_ASSERT_EQUAL_UINT(109, v1); 653 TEST_ASSERT_EQUAL_UINT(v0, 109); 654 TEST_ASSERT_EQUAL_UINT(*p0, v1); 655 TEST_ASSERT_EQUAL_UINT(*p0, *p1); 656 TEST_ASSERT_EQUAL_UINT(*p0, 109); 657} 658 659void testEqualUChars(void) 660{ 661 unsigned char v0, v1; 662 unsigned char *p0, *p1; 663 664 v0 = 251; 665 v1 = 251; 666 p0 = &v0; 667 p1 = &v1; 668 669 TEST_ASSERT_EQUAL_INT(42, 42); 670 TEST_ASSERT_EQUAL_INT(v0, v1); 671 TEST_ASSERT_EQUAL_INT(251, v1); 672 TEST_ASSERT_EQUAL_INT(v0, 251); 673 TEST_ASSERT_EQUAL_INT(*p0, v1); 674 TEST_ASSERT_EQUAL_INT(*p0, *p1); 675 TEST_ASSERT_EQUAL_INT(*p0, 251); 676} 677 678void testEqualPointers(void) 679{ 680 int v0, v1; 681 int *p0, *p1, *p2; 682 683 v0 = 19467; 684 v1 = 18271; 685 p0 = &v0; 686 p1 = &v1; 687 p2 = &v1; 688 689 TEST_ASSERT_EQUAL_PTR(p0, &v0); 690 TEST_ASSERT_EQUAL_PTR(&v1, p1); 691 TEST_ASSERT_EQUAL_PTR(p2, p1); 692 TEST_ASSERT_EQUAL_PTR(&v0, &v0); 693} 694 695void testNotEqualPointers(void) 696{ 697 EXPECT_ABORT_BEGIN 698 TEST_ASSERT_EQUAL_PTR(0x12345678, 0x12345677); 699 VERIFY_FAILS_END 700} 701 702void testIntsWithinDelta(void) 703{ 704 TEST_ASSERT_INT_WITHIN(1, 5000, 5001); 705 TEST_ASSERT_INT_WITHIN(5, 5000, 4996); 706 TEST_ASSERT_INT_WITHIN(5, 5000, 5005); 707 TEST_ASSERT_INT_WITHIN(500, 50, -440); 708 709 TEST_ASSERT_INT_WITHIN(2, -1, -1); 710 TEST_ASSERT_INT_WITHIN(5, 1, -1); 711 TEST_ASSERT_INT_WITHIN(5, -1, 1); 712} 713 714void testIntsWithinDeltaAndCustomMessage(void) 715{ 716 TEST_ASSERT_INT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 717 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 718 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 719 TEST_ASSERT_INT_WITHIN_MESSAGE(500, 50, -440, "Custom Message."); 720 721 TEST_ASSERT_INT_WITHIN_MESSAGE(2, -1, -1, "Custom Message."); 722 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); 723 TEST_ASSERT_INT_WITHIN_MESSAGE(5, -1, 1, "Custom Message."); 724} 725 726void testIntsNotWithinDelta(void) 727{ 728 EXPECT_ABORT_BEGIN 729 TEST_ASSERT_INT_WITHIN(5, 5000, 5006); 730 VERIFY_FAILS_END 731} 732 733void testIntsNotWithinDeltaAndCustomMessage(void) 734{ 735 EXPECT_ABORT_BEGIN 736 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5006, "Custom Message."); 737 VERIFY_FAILS_END 738} 739 740void testUIntsWithinDelta(void) 741{ 742 TEST_ASSERT_UINT_WITHIN(1, 5000, 5001); 743 TEST_ASSERT_UINT_WITHIN(5, 5000, 4996); 744 TEST_ASSERT_UINT_WITHIN(5, 5000, 5005); 745} 746 747void testUIntsWithinDeltaAndCustomMessage(void) 748{ 749 TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 750 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 751 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 752} 753 754void testUIntsNotWithinDelta(void) 755{ 756 EXPECT_ABORT_BEGIN 757 TEST_ASSERT_UINT_WITHIN(1, 2147483647u, 2147483649u); 758 VERIFY_FAILS_END 759} 760 761void testUIntsNotWithinDeltaAndCustomMessage(void) 762{ 763 EXPECT_ABORT_BEGIN 764 TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); 765 VERIFY_FAILS_END 766} 767 768void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirst(void) 769{ 770 EXPECT_ABORT_BEGIN 771 TEST_ASSERT_UINT_WITHIN(5, 1, -1); 772 VERIFY_FAILS_END 773} 774 775void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirstAndCustomMessage(void) 776{ 777 EXPECT_ABORT_BEGIN 778 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); 779 VERIFY_FAILS_END 780} 781 782void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirst(void) 783{ 784 EXPECT_ABORT_BEGIN 785 TEST_ASSERT_UINT_WITHIN(5, -1, 1); 786 VERIFY_FAILS_END 787} 788 789void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirstAndCustomMessage(void) 790{ 791 EXPECT_ABORT_BEGIN 792 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, -1, 1, "Custom Message."); 793 VERIFY_FAILS_END 794} 795 796void testHEX32sWithinDelta(void) 797{ 798 TEST_ASSERT_HEX32_WITHIN(1, 5000, 5001); 799 TEST_ASSERT_HEX32_WITHIN(5, 5000, 4996); 800 TEST_ASSERT_HEX32_WITHIN(5, 5000, 5005); 801} 802 803void testHEX32sWithinDeltaShouldIgnoreSign(void) 804{ 805 TEST_ASSERT_HEX32_WITHIN(1, 0x7FFFFFFF, 0x80000000); 806} 807 808void testHEX32sWithinDeltaAndCustomMessage(void) 809{ 810 TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 811 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 812 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 813} 814 815void testHEX32sNotWithinDelta(void) 816{ 817 EXPECT_ABORT_BEGIN 818 TEST_ASSERT_HEX32_WITHIN(1, 2147483647u, 2147483649u); 819 VERIFY_FAILS_END 820} 821 822void testHEX32sNotWithinDeltaAndCustomMessage(void) 823{ 824 EXPECT_ABORT_BEGIN 825 TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); 826 VERIFY_FAILS_END 827} 828 829void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPass(void) 830{ 831 EXPECT_ABORT_BEGIN 832 TEST_ASSERT_HEX32_WITHIN(5, 1, -1); 833 VERIFY_FAILS_END 834} 835 836void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void) 837{ 838 EXPECT_ABORT_BEGIN 839 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); 840 VERIFY_FAILS_END 841} 842 843void testHEX16sWithinDelta(void) 844{ 845 TEST_ASSERT_HEX16_WITHIN(1, 5000, 5001); 846 TEST_ASSERT_HEX16_WITHIN(5, 5000, 4996); 847 TEST_ASSERT_HEX16_WITHIN(5, 5000, 5005); 848} 849 850void testHEX16sWithinDeltaShouldIgnoreSign(void) 851{ 852 TEST_ASSERT_HEX16_WITHIN(1, 0x7FFF, 0x8000); 853} 854 855void testHEX16sWithinDeltaAndCustomMessage(void) 856{ 857 TEST_ASSERT_HEX16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 858 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 859 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 860} 861 862void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) 863{ 864 TEST_ASSERT_HEX16_WITHIN(5, 0x54321, 0x44321); 865} 866 867void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) 868{ 869 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); 870} 871 872void testHEX16sNotWithinDelta(void) 873{ 874 EXPECT_ABORT_BEGIN 875 TEST_ASSERT_HEX16_WITHIN(2, 65535, 0); 876 VERIFY_FAILS_END 877} 878 879void testHEX16sNotWithinDeltaAndCustomMessage(void) 880{ 881 EXPECT_ABORT_BEGIN 882 TEST_ASSERT_HEX16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message."); 883 VERIFY_FAILS_END 884} 885 886void testHEX8sWithinDelta(void) 887{ 888 TEST_ASSERT_HEX8_WITHIN(1, 254, 255); 889 TEST_ASSERT_HEX8_WITHIN(5, 251, 255); 890 TEST_ASSERT_HEX8_WITHIN(5, 1, 4); 891} 892 893void testHEX8sWithinDeltaShouldIgnoreSign(void) 894{ 895 TEST_ASSERT_HEX8_WITHIN(1, 0x7F, 0x80); 896} 897 898void testHEX8sWithinDeltaAndCustomMessage(void) 899{ 900 TEST_ASSERT_HEX8_WITHIN_MESSAGE(1, 254, 255, "Custom Message."); 901 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 251, 255, "Custom Message."); 902 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); 903} 904 905void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) 906{ 907 TEST_ASSERT_HEX8_WITHIN(5, 0x123, 0xF23); 908} 909 910void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) 911{ 912 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); 913} 914 915void testHEX8sNotWithinDelta(void) 916{ 917 EXPECT_ABORT_BEGIN 918 TEST_ASSERT_HEX8_WITHIN(2, 255, 0); 919 VERIFY_FAILS_END 920} 921 922void testHEX8sNotWithinDeltaAndCustomMessage(void) 923{ 924 EXPECT_ABORT_BEGIN 925 TEST_ASSERT_HEX8_WITHIN_MESSAGE(2, 255, 0, "Custom Message."); 926 VERIFY_FAILS_END 927} 928 929/*-----------------*/ 930 931void testUINT32sWithinDelta(void) 932{ 933 TEST_ASSERT_UINT32_WITHIN(1, 5000, 5001); 934 TEST_ASSERT_UINT32_WITHIN(5, 5000, 4996); 935 TEST_ASSERT_UINT32_WITHIN(5, 5000, 5005); 936} 937 938void testUINT32sWithinDeltaAndCustomMessage(void) 939{ 940 TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 941 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 942 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 943} 944 945void testUINT32sNotWithinDelta(void) 946{ 947 EXPECT_ABORT_BEGIN 948 TEST_ASSERT_UINT32_WITHIN(1, 2147483647u, 2147483649u); 949 VERIFY_FAILS_END 950} 951 952void testUINT32sNotWithinDeltaAndCustomMessage(void) 953{ 954 EXPECT_ABORT_BEGIN 955 TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); 956 VERIFY_FAILS_END 957} 958 959void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPass(void) 960{ 961 EXPECT_ABORT_BEGIN 962 TEST_ASSERT_UINT32_WITHIN(5, 1, -1); 963 VERIFY_FAILS_END 964} 965 966void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void) 967{ 968 EXPECT_ABORT_BEGIN 969 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); 970 VERIFY_FAILS_END 971} 972 973void testUINT16sWithinDelta(void) 974{ 975 TEST_ASSERT_UINT16_WITHIN(1, 5000, 5001); 976 TEST_ASSERT_UINT16_WITHIN(5, 5000, 4996); 977 TEST_ASSERT_UINT16_WITHIN(5, 5000, 5005); 978} 979 980void testUINT16sWithinDeltaAndCustomMessage(void) 981{ 982 TEST_ASSERT_UINT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 983 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 984 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 985} 986 987void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) 988{ 989 TEST_ASSERT_UINT16_WITHIN(5, 0x54321, 0x44321); 990} 991 992void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) 993{ 994 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); 995} 996 997void testUINT16sNotWithinDelta(void) 998{ 999 EXPECT_ABORT_BEGIN 1000 TEST_ASSERT_UINT16_WITHIN(2, 65535, 0); 1001 VERIFY_FAILS_END 1002} 1003 1004void testUINT16sNotWithinDeltaAndCustomMessage(void) 1005{ 1006 EXPECT_ABORT_BEGIN 1007 TEST_ASSERT_UINT16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message."); 1008 VERIFY_FAILS_END 1009} 1010 1011void testUINT8sWithinDelta(void) 1012{ 1013 TEST_ASSERT_UINT8_WITHIN(1, 254, 255); 1014 TEST_ASSERT_UINT8_WITHIN(5, 251, 255); 1015 TEST_ASSERT_UINT8_WITHIN(5, 1, 4); 1016} 1017 1018void testUINT8sWithinDeltaAndCustomMessage(void) 1019{ 1020 TEST_ASSERT_UINT8_WITHIN_MESSAGE(1, 254, 255, "Custom Message."); 1021 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 251, 255, "Custom Message."); 1022 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); 1023} 1024 1025void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) 1026{ 1027 TEST_ASSERT_UINT8_WITHIN(5, 0x123, 0xF23); 1028} 1029 1030void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) 1031{ 1032 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); 1033} 1034 1035void testUINT8sNotWithinDelta(void) 1036{ 1037 EXPECT_ABORT_BEGIN 1038 TEST_ASSERT_UINT8_WITHIN(2, 255, 0); 1039 VERIFY_FAILS_END 1040} 1041 1042void testUINT8sNotWithinDeltaAndCustomMessage(void) 1043{ 1044 EXPECT_ABORT_BEGIN 1045 TEST_ASSERT_UINT8_WITHIN_MESSAGE(2, 255, 0, "Custom Message."); 1046 VERIFY_FAILS_END 1047} 1048 1049void testINT32sWithinDelta(void) 1050{ 1051 TEST_ASSERT_INT32_WITHIN(1, 5000, 5001); 1052 TEST_ASSERT_INT32_WITHIN(5, 1, -2); 1053 TEST_ASSERT_INT32_WITHIN(5, -2, 1); 1054} 1055 1056void testINT32sWithinDeltaAndCustomMessage(void) 1057{ 1058 TEST_ASSERT_INT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 1059} 1060 1061void testINT32sNotWithinDelta(void) 1062{ 1063 EXPECT_ABORT_BEGIN 1064 TEST_ASSERT_INT32_WITHIN(1, -3, 1); 1065 VERIFY_FAILS_END 1066} 1067 1068void testINT32sNotWithinDeltaAndDifferenceOverflows(void) 1069{ 1070 EXPECT_ABORT_BEGIN 1071 TEST_ASSERT_INT32_WITHIN(1, -1, 0x7FFFFFFF); 1072 VERIFY_FAILS_END 1073} 1074void testINT32sNotWithinDeltaAndCustomMessage(void) 1075{ 1076 EXPECT_ABORT_BEGIN 1077 TEST_ASSERT_INT32_WITHIN_MESSAGE(1, -2, 1, "Custom Message."); 1078 VERIFY_FAILS_END 1079} 1080 1081void testINT16sWithinDelta(void) 1082{ 1083 TEST_ASSERT_INT16_WITHIN(1, 5000, 5001); 1084 TEST_ASSERT_INT16_WITHIN(5, 2, -2); 1085 TEST_ASSERT_INT16_WITHIN(5, -2, 2); 1086} 1087 1088void testINT16sWithinDeltaAndCustomMessage(void) 1089{ 1090 TEST_ASSERT_INT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 1091} 1092 1093void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) 1094{ 1095 TEST_ASSERT_INT16_WITHIN(5, 0x54321, 0x44321); 1096} 1097 1098void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) 1099{ 1100 TEST_ASSERT_INT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); 1101} 1102 1103void testINT16sNotWithinDelta(void) 1104{ 1105 EXPECT_ABORT_BEGIN 1106 TEST_ASSERT_INT16_WITHIN(2, 4, -2); 1107 VERIFY_FAILS_END 1108} 1109 1110void testINT16sNotWithinDeltaAndCustomMessage(void) 1111{ 1112 EXPECT_ABORT_BEGIN 1113 TEST_ASSERT_INT16_WITHIN_MESSAGE(2, 3, 0, "Custom Message."); 1114 VERIFY_FAILS_END 1115} 1116 1117void testINT8sWithinDelta(void) 1118{ 1119 TEST_ASSERT_INT8_WITHIN(1, 127, 126); 1120 TEST_ASSERT_INT8_WITHIN(5, -2, 2); 1121 TEST_ASSERT_INT8_WITHIN(5, 2, -2); 1122} 1123 1124void testINT8sWithinDeltaAndCustomMessage(void) 1125{ 1126 TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); 1127} 1128 1129void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) 1130{ 1131 TEST_ASSERT_INT8_WITHIN(5, 0x123, 0xF23); 1132} 1133 1134void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) 1135{ 1136 TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); 1137} 1138 1139void testINT8sNotWithinDelta(void) 1140{ 1141 EXPECT_ABORT_BEGIN 1142 TEST_ASSERT_INT8_WITHIN(2, -3, 0); 1143 VERIFY_FAILS_END 1144} 1145 1146void testINT8sNotWithinDeltaAndCustomMessage(void) 1147{ 1148 EXPECT_ABORT_BEGIN 1149 TEST_ASSERT_INT8_WITHIN_MESSAGE(2, -4, 0, "Custom Message."); 1150 VERIFY_FAILS_END 1151} 1152 1153void testCHARsWithinDelta(void) 1154{ 1155 TEST_ASSERT_CHAR_WITHIN(1, 'M', 'L'); 1156 TEST_ASSERT_CHAR_WITHIN(5, -2, 2); 1157 TEST_ASSERT_CHAR_WITHIN(5, 2, -2); 1158} 1159 1160void testCHARsWithinDeltaAndCustomMessage(void) 1161{ 1162 TEST_ASSERT_CHAR_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); 1163} 1164 1165void testCHARsWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) 1166{ 1167 TEST_ASSERT_CHAR_WITHIN(5, 0x123, 0xF23); 1168} 1169 1170void testCHARsWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) 1171{ 1172 TEST_ASSERT_CHAR_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); 1173} 1174 1175void testCHARsNotWithinDelta(void) 1176{ 1177 EXPECT_ABORT_BEGIN 1178 TEST_ASSERT_CHAR_WITHIN(2, -3, 0); 1179 VERIFY_FAILS_END 1180} 1181 1182void testCHARsNotWithinDeltaAndCustomMessage(void) 1183{ 1184 EXPECT_ABORT_BEGIN 1185 TEST_ASSERT_CHAR_WITHIN_MESSAGE(2, -4, 0, "Custom Message."); 1186 VERIFY_FAILS_END 1187} 1188 1189void testNotEqualINT(void) 1190{ 1191 UNITY_INT v0, v1; 1192 UNITY_INT *p0, *p1; 1193 1194 v0 = 302; 1195 v1 = 3334; 1196 p0 = &v0; 1197 p1 = &v1; 1198 1199 TEST_ASSERT_NOT_EQUAL_INT(v0, v1); 1200 TEST_ASSERT_NOT_EQUAL_INT(*p0, v1); 1201 TEST_ASSERT_NOT_EQUAL_INT(v0, *p1); 1202 TEST_ASSERT_NOT_EQUAL_INT(*p1, *p0); 1203} 1204 1205void testNotNotEqualINT(void) 1206{ 1207 EXPECT_ABORT_BEGIN 1208 TEST_ASSERT_NOT_EQUAL_INT(302, 302); 1209 VERIFY_FAILS_END 1210} 1211 1212void testNotEqualINT8(void) 1213{ 1214 UNITY_INT8 v0, v1; 1215 UNITY_INT8 *p0, *p1; 1216 1217 v0 = -128; 1218 v1 = 127; 1219 p0 = &v0; 1220 p1 = &v1; 1221 1222 TEST_ASSERT_NOT_EQUAL_INT8(v0, v1); 1223 TEST_ASSERT_NOT_EQUAL_INT8(*p0, v1); 1224 TEST_ASSERT_NOT_EQUAL_INT8(v0, *p1); 1225 TEST_ASSERT_NOT_EQUAL_INT8(*p1, *p0); 1226} 1227 1228void testNotNotEqualINT8(void) 1229{ 1230 EXPECT_ABORT_BEGIN 1231 TEST_ASSERT_NOT_EQUAL_INT8(-128, -128); 1232 VERIFY_FAILS_END 1233} 1234 1235void testNotEqualCHAR(void) 1236{ 1237 char v0, v1; 1238 char *p0, *p1; 1239 1240 v0 = -128; 1241 v1 = 127; 1242 p0 = &v0; 1243 p1 = &v1; 1244 1245 TEST_ASSERT_NOT_EQUAL_CHAR(v0, v1); 1246 TEST_ASSERT_NOT_EQUAL_CHAR(*p0, v1); 1247 TEST_ASSERT_NOT_EQUAL_CHAR(v0, *p1); 1248 TEST_ASSERT_NOT_EQUAL_CHAR(*p1, *p0); 1249} 1250 1251void testNotNotEqualCHAR(void) 1252{ 1253 EXPECT_ABORT_BEGIN 1254 TEST_ASSERT_NOT_EQUAL_CHAR(127, 127); 1255 VERIFY_FAILS_END 1256} 1257 1258void testNotEqualINT16(void) 1259{ 1260 UNITY_INT16 v0, v1; 1261 UNITY_INT16 *p0, *p1; 1262 1263 v0 = -32768; 1264 v1 = 32767; 1265 p0 = &v0; 1266 p1 = &v1; 1267 1268 TEST_ASSERT_NOT_EQUAL_INT16(v0, v1); 1269 TEST_ASSERT_NOT_EQUAL_INT16(*p0, v1); 1270 TEST_ASSERT_NOT_EQUAL_INT16(v0, *p1); 1271 TEST_ASSERT_NOT_EQUAL_INT16(*p1, *p0); 1272} 1273 1274void testNotNotEqualINT16(void) 1275{ 1276 EXPECT_ABORT_BEGIN 1277 TEST_ASSERT_NOT_EQUAL_INT16(-32768, -32768); 1278 VERIFY_FAILS_END 1279} 1280 1281void testNotEqualINT32(void) 1282{ 1283 UNITY_INT32 v0, v1; 1284 UNITY_INT32 *p0, *p1; 1285 1286 v0 = -214783648; 1287 v1 = 214783647; 1288 p0 = &v0; 1289 p1 = &v1; 1290 1291 TEST_ASSERT_NOT_EQUAL_INT32(v0, v1); 1292 TEST_ASSERT_NOT_EQUAL_INT32(*p0, v1); 1293 TEST_ASSERT_NOT_EQUAL_INT32(v0, *p1); 1294 TEST_ASSERT_NOT_EQUAL_INT32(*p1, *p0); 1295} 1296 1297void testNotNotEqualINT32(void) 1298{ 1299 EXPECT_ABORT_BEGIN 1300 TEST_ASSERT_NOT_EQUAL_INT32(-214783648, -214783648); 1301 VERIFY_FAILS_END 1302} 1303 1304void testNotEqualUINT(void) 1305{ 1306 UNITY_UINT v0, v1; 1307 UNITY_UINT *p0, *p1; 1308 1309 v0 = 0; 1310 v1 = 1; 1311 p0 = &v0; 1312 p1 = &v1; 1313 1314 TEST_ASSERT_NOT_EQUAL_UINT(v0, v1); 1315 TEST_ASSERT_NOT_EQUAL_UINT(*p0, v1); 1316 TEST_ASSERT_NOT_EQUAL_UINT(v0, *p1); 1317 TEST_ASSERT_NOT_EQUAL_UINT(*p1, *p0); 1318} 1319 1320void testNotNotEqualUINT(void) 1321{ 1322 EXPECT_ABORT_BEGIN 1323 TEST_ASSERT_NOT_EQUAL_UINT(1, 1); 1324 VERIFY_FAILS_END 1325} 1326 1327void testNotEqualUINT8(void) 1328{ 1329 UNITY_UINT8 v0, v1; 1330 UNITY_UINT8 *p0, *p1; 1331 1332 v0 = 0; 1333 v1 = 255; 1334 p0 = &v0; 1335 p1 = &v1; 1336 1337 TEST_ASSERT_NOT_EQUAL_UINT8(v0, v1); 1338 TEST_ASSERT_NOT_EQUAL_UINT8(*p0, v1); 1339 TEST_ASSERT_NOT_EQUAL_UINT8(v0, *p1); 1340 TEST_ASSERT_NOT_EQUAL_UINT8(*p1, *p0); 1341} 1342 1343void testNotNotEqualUINT8(void) 1344{ 1345 EXPECT_ABORT_BEGIN 1346 TEST_ASSERT_NOT_EQUAL_UINT8(255, 255); 1347 VERIFY_FAILS_END 1348} 1349 1350void testNotEqualUINT16(void) 1351{ 1352 UNITY_UINT16 v0, v1; 1353 UNITY_UINT16 *p0, *p1; 1354 1355 v0 = 0; 1356 v1 = 65535; 1357 p0 = &v0; 1358 p1 = &v1; 1359 1360 TEST_ASSERT_NOT_EQUAL_UINT16(v0, v1); 1361 TEST_ASSERT_NOT_EQUAL_UINT16(*p0, v1); 1362 TEST_ASSERT_NOT_EQUAL_UINT16(v0, *p1); 1363 TEST_ASSERT_NOT_EQUAL_UINT16(*p1, *p0); 1364} 1365 1366void testNotNotEqualUINT16(void) 1367{ 1368 EXPECT_ABORT_BEGIN 1369 TEST_ASSERT_NOT_EQUAL_UINT16(65535, 65535); 1370 VERIFY_FAILS_END 1371} 1372 1373void testNotEqualUINT32(void) 1374{ 1375 UNITY_UINT32 v0, v1; 1376 UNITY_UINT32 *p0, *p1; 1377 1378 v0 = 0u; 1379 v1 = 4294967295u; 1380 p0 = &v0; 1381 p1 = &v1; 1382 1383 TEST_ASSERT_NOT_EQUAL_UINT32(v0, v1); 1384 TEST_ASSERT_NOT_EQUAL_UINT32(*p0, v1); 1385 TEST_ASSERT_NOT_EQUAL_UINT32(v0, *p1); 1386 TEST_ASSERT_NOT_EQUAL_UINT32(*p1, *p0); 1387} 1388 1389void testNotNotEqualUINT32(void) 1390{ 1391 EXPECT_ABORT_BEGIN 1392 TEST_ASSERT_NOT_EQUAL_UINT32(4294967295u, 4294967295u); 1393 VERIFY_FAILS_END 1394} 1395 1396void testNotEqualHEX8(void) 1397{ 1398 UNITY_UINT8 v0, v1; 1399 UNITY_UINT8 *p0, *p1; 1400 1401 v0 = 0x00; 1402 v1 = 0xFF; 1403 p0 = &v0; 1404 p1 = &v1; 1405 1406 TEST_ASSERT_NOT_EQUAL_HEX8(v0, v1); 1407 TEST_ASSERT_NOT_EQUAL_HEX8(*p0, v1); 1408 TEST_ASSERT_NOT_EQUAL_HEX8(v0, *p1); 1409 TEST_ASSERT_NOT_EQUAL_HEX8(*p1, *p0); 1410} 1411 1412void testNotNotEqualHEX8(void) 1413{ 1414 EXPECT_ABORT_BEGIN 1415 TEST_ASSERT_NOT_EQUAL_HEX8(0xFF, 0xFF); 1416 VERIFY_FAILS_END 1417} 1418 1419void testNotEqualHEX16(void) 1420{ 1421 UNITY_UINT16 v0, v1; 1422 UNITY_UINT16 *p0, *p1; 1423 1424 v0 = 0x0000; 1425 v1 = 0xFFFF; 1426 p0 = &v0; 1427 p1 = &v1; 1428 1429 TEST_ASSERT_NOT_EQUAL_HEX16(v0, v1); 1430 TEST_ASSERT_NOT_EQUAL_HEX16(*p0, v1); 1431 TEST_ASSERT_NOT_EQUAL_HEX16(v0, *p1); 1432 TEST_ASSERT_NOT_EQUAL_HEX16(*p1, *p0); 1433} 1434 1435void testNotNotEqualHEX16(void) 1436{ 1437 EXPECT_ABORT_BEGIN 1438 TEST_ASSERT_NOT_EQUAL_HEX16(0xFFFF, 0xFFFF); 1439 VERIFY_FAILS_END 1440} 1441 1442void testNotEqualHEX32(void) 1443{ 1444 UNITY_UINT32 v0, v1; 1445 UNITY_UINT32 *p0, *p1; 1446 1447 v0 = 0x00000000; 1448 v1 = 0xFFFFFFFF; 1449 p0 = &v0; 1450 p1 = &v1; 1451 1452 TEST_ASSERT_NOT_EQUAL_HEX32(v0, v1); 1453 TEST_ASSERT_NOT_EQUAL_HEX32(*p0, v1); 1454 TEST_ASSERT_NOT_EQUAL_HEX32(v0, *p1); 1455 TEST_ASSERT_NOT_EQUAL_HEX32(*p1, *p0); 1456} 1457 1458void testNotNotEqualHEX32(void) 1459{ 1460 EXPECT_ABORT_BEGIN 1461 TEST_ASSERT_NOT_EQUAL_HEX32(0xFFFFFFFF, 0xFFFFFFFF); 1462 VERIFY_FAILS_END 1463} 1464 1465/*-----------------*/ 1466 1467void testGreaterThan(void) 1468{ 1469 UNITY_INT v0, v1; 1470 UNITY_INT *p0, *p1; 1471 1472 v0 = 0; 1473 v1 = 1; 1474 p0 = &v0; 1475 p1 = &v1; 1476 1477 TEST_ASSERT_GREATER_THAN(v0, v1); 1478 TEST_ASSERT_GREATER_THAN(*p0, v1); 1479 TEST_ASSERT_GREATER_THAN(v0, *p1); 1480 TEST_ASSERT_GREATER_THAN(*p0, *p1); 1481} 1482 1483void testNotGreaterThan(void) 1484{ 1485 EXPECT_ABORT_BEGIN 1486 TEST_ASSERT_GREATER_THAN(0, -1); 1487 VERIFY_FAILS_END 1488} 1489 1490void testGreaterThanINT(void) 1491{ 1492 UNITY_INT v0, v1; 1493 UNITY_INT *p0, *p1; 1494 1495 v0 = 302; 1496 v1 = 3334; 1497 p0 = &v0; 1498 p1 = &v1; 1499 1500 TEST_ASSERT_GREATER_THAN_INT(v0, v1); 1501 TEST_ASSERT_GREATER_THAN_INT(*p0, v1); 1502 TEST_ASSERT_GREATER_THAN_INT(v0, *p1); 1503 TEST_ASSERT_GREATER_THAN_INT(*p0, *p1); 1504} 1505 1506void testNotGreaterThanINT(void) 1507{ 1508 EXPECT_ABORT_BEGIN 1509 TEST_ASSERT_GREATER_THAN_INT(3334, 302); 1510 VERIFY_FAILS_END 1511} 1512 1513void testGreaterThanINT8(void) 1514{ 1515 UNITY_INT8 v0, v1; 1516 UNITY_INT8 *p0, *p1; 1517 1518 v0 = -128; 1519 v1 = 127; 1520 p0 = &v0; 1521 p1 = &v1; 1522 1523 TEST_ASSERT_GREATER_THAN_INT8(v0, v1); 1524 TEST_ASSERT_GREATER_THAN_INT8(*p0, v1); 1525 TEST_ASSERT_GREATER_THAN_INT8(v0, *p1); 1526 TEST_ASSERT_GREATER_THAN_INT8(*p0, *p1); 1527} 1528 1529void testNotGreaterThanINT8(void) 1530{ 1531 EXPECT_ABORT_BEGIN 1532 TEST_ASSERT_GREATER_THAN_INT8(127, -128); 1533 VERIFY_FAILS_END 1534} 1535 1536void testGreaterThanCHAR(void) 1537{ 1538 char v0, v1; 1539 char *p0, *p1; 1540 1541 v0 = -128; 1542 v1 = 127; 1543 p0 = &v0; 1544 p1 = &v1; 1545 1546 TEST_ASSERT_GREATER_THAN_CHAR(v0, v1); 1547 TEST_ASSERT_GREATER_THAN_CHAR(*p0, v1); 1548 TEST_ASSERT_GREATER_THAN_CHAR(v0, *p1); 1549 TEST_ASSERT_GREATER_THAN_CHAR(*p0, *p1); 1550} 1551 1552void testNotGreaterThanCHAR(void) 1553{ 1554 EXPECT_ABORT_BEGIN 1555 TEST_ASSERT_GREATER_THAN_CHAR(127, -128); 1556 VERIFY_FAILS_END 1557} 1558 1559void testGreaterThanINT16(void) 1560{ 1561 UNITY_INT16 v0, v1; 1562 UNITY_INT16 *p0, *p1; 1563 1564 v0 = -32768; 1565 v1 = 32767; 1566 p0 = &v0; 1567 p1 = &v1; 1568 1569 TEST_ASSERT_GREATER_THAN_INT16(v0, v1); 1570 TEST_ASSERT_GREATER_THAN_INT16(*p0, v1); 1571 TEST_ASSERT_GREATER_THAN_INT16(v0, *p1); 1572 TEST_ASSERT_GREATER_THAN_INT16(*p0, *p1); 1573} 1574 1575void testNotGreaterThanINT16(void) 1576{ 1577 EXPECT_ABORT_BEGIN 1578 TEST_ASSERT_GREATER_THAN_INT16(32768, -32768); 1579 VERIFY_FAILS_END 1580} 1581 1582void testGreaterThanINT32(void) 1583{ 1584 UNITY_INT32 v0, v1; 1585 UNITY_INT32 *p0, *p1; 1586 1587 v0 = -214783648; 1588 v1 = 214783647; 1589 p0 = &v0; 1590 p1 = &v1; 1591 1592 TEST_ASSERT_GREATER_THAN_INT32(v0, v1); 1593 TEST_ASSERT_GREATER_THAN_INT32(*p0, v1); 1594 TEST_ASSERT_GREATER_THAN_INT32(v0, *p1); 1595 TEST_ASSERT_GREATER_THAN_INT32(*p0, *p1); 1596} 1597 1598void testNotGreaterThanINT32(void) 1599{ 1600 EXPECT_ABORT_BEGIN 1601 TEST_ASSERT_GREATER_THAN_INT32(214783647, -214783648); 1602 VERIFY_FAILS_END 1603} 1604 1605void testGreaterThanUINT(void) 1606{ 1607 UNITY_UINT v0, v1; 1608 UNITY_UINT *p0, *p1; 1609 1610 v0 = 0; 1611 v1 = 1; 1612 p0 = &v0; 1613 p1 = &v1; 1614 1615 TEST_ASSERT_GREATER_THAN_UINT(v0, v1); 1616 TEST_ASSERT_GREATER_THAN_UINT(*p0, v1); 1617 TEST_ASSERT_GREATER_THAN_UINT(v0, *p1); 1618 TEST_ASSERT_GREATER_THAN_UINT(*p0, *p1); 1619} 1620 1621void testNotGreaterThanUINT(void) 1622{ 1623 EXPECT_ABORT_BEGIN 1624 TEST_ASSERT_GREATER_THAN_UINT(1, 0); 1625 VERIFY_FAILS_END 1626} 1627 1628void testGreaterThanUINT8(void) 1629{ 1630 UNITY_UINT8 v0, v1; 1631 UNITY_UINT8 *p0, *p1; 1632 1633 v0 = 0; 1634 v1 = 255; 1635 p0 = &v0; 1636 p1 = &v1; 1637 1638 TEST_ASSERT_GREATER_THAN_UINT8(v0, v1); 1639 TEST_ASSERT_GREATER_THAN_UINT8(*p0, v1); 1640 TEST_ASSERT_GREATER_THAN_UINT8(v0, *p1); 1641 TEST_ASSERT_GREATER_THAN_UINT8(*p0, *p1); 1642} 1643 1644void testNotGreaterThanUINT8(void) 1645{ 1646 EXPECT_ABORT_BEGIN 1647 TEST_ASSERT_GREATER_THAN_UINT8(255, 0); 1648 VERIFY_FAILS_END 1649} 1650 1651void testGreaterThanUINT16(void) 1652{ 1653 UNITY_UINT16 v0, v1; 1654 UNITY_UINT16 *p0, *p1; 1655 1656 v0 = 0; 1657 v1 = 65535; 1658 p0 = &v0; 1659 p1 = &v1; 1660 1661 TEST_ASSERT_GREATER_THAN_UINT16(v0, v1); 1662 TEST_ASSERT_GREATER_THAN_UINT16(*p0, v1); 1663 TEST_ASSERT_GREATER_THAN_UINT16(v0, *p1); 1664 TEST_ASSERT_GREATER_THAN_UINT16(*p0, *p1); 1665} 1666 1667void testNotGreaterThanUINT16(void) 1668{ 1669 EXPECT_ABORT_BEGIN 1670 TEST_ASSERT_GREATER_THAN_UINT16(65535, 0); 1671 VERIFY_FAILS_END 1672} 1673 1674void testGreaterThanUINT32(void) 1675{ 1676 UNITY_UINT32 v0, v1; 1677 UNITY_UINT32 *p0, *p1; 1678 1679 v0 = 0u; 1680 v1 = 4294967295u; 1681 p0 = &v0; 1682 p1 = &v1; 1683 1684 TEST_ASSERT_GREATER_THAN_UINT32(v0, v1); 1685 TEST_ASSERT_GREATER_THAN_UINT32(*p0, v1); 1686 TEST_ASSERT_GREATER_THAN_UINT32(v0, *p1); 1687 TEST_ASSERT_GREATER_THAN_UINT32(*p0, *p1); 1688} 1689 1690void testNotGreaterThanUINT32(void) 1691{ 1692 EXPECT_ABORT_BEGIN 1693 TEST_ASSERT_GREATER_THAN_UINT32(4294967295u, 0); 1694 VERIFY_FAILS_END 1695} 1696 1697void testGreaterThanHEX8(void) 1698{ 1699 UNITY_UINT8 v0, v1; 1700 UNITY_UINT8 *p0, *p1; 1701 1702 v0 = 0x00; 1703 v1 = 0xFF; 1704 p0 = &v0; 1705 p1 = &v1; 1706 1707 TEST_ASSERT_GREATER_THAN_HEX8(v0, v1); 1708 TEST_ASSERT_GREATER_THAN_HEX8(*p0, v1); 1709 TEST_ASSERT_GREATER_THAN_HEX8(v0, *p1); 1710 TEST_ASSERT_GREATER_THAN_HEX8(*p0, *p1); 1711} 1712 1713void testNotGreaterThanHEX8(void) 1714{ 1715 EXPECT_ABORT_BEGIN 1716 TEST_ASSERT_GREATER_THAN_HEX8(0xFF, 0x00); 1717 VERIFY_FAILS_END 1718} 1719 1720void testGreaterThanHEX16(void) 1721{ 1722 UNITY_UINT16 v0, v1; 1723 UNITY_UINT16 *p0, *p1; 1724 1725 v0 = 0x0000; 1726 v1 = 0xFFFF; 1727 p0 = &v0; 1728 p1 = &v1; 1729 1730 TEST_ASSERT_GREATER_THAN_HEX16(v0, v1); 1731 TEST_ASSERT_GREATER_THAN_HEX16(*p0, v1); 1732 TEST_ASSERT_GREATER_THAN_HEX16(v0, *p1); 1733 TEST_ASSERT_GREATER_THAN_HEX16(*p0, *p1); 1734} 1735 1736void testNotGreaterThanHEX16(void) 1737{ 1738 EXPECT_ABORT_BEGIN 1739 TEST_ASSERT_GREATER_THAN_HEX16(0xFFFF, 0x00); 1740 VERIFY_FAILS_END 1741} 1742 1743void testGreaterThanHEX32(void) 1744{ 1745 UNITY_UINT32 v0, v1; 1746 UNITY_UINT32 *p0, *p1; 1747 1748 v0 = 0x00000000; 1749 v1 = 0xFFFFFFFF; 1750 p0 = &v0; 1751 p1 = &v1; 1752 1753 TEST_ASSERT_GREATER_THAN_HEX32(v0, v1); 1754 TEST_ASSERT_GREATER_THAN_HEX32(*p0, v1); 1755 TEST_ASSERT_GREATER_THAN_HEX32(v0, *p1); 1756 TEST_ASSERT_GREATER_THAN_HEX32(*p0, *p1); 1757} 1758 1759void testNotGreaterThanHEX32(void) 1760{ 1761 EXPECT_ABORT_BEGIN 1762 TEST_ASSERT_GREATER_THAN_HEX32(0xFFFFFFFF, 0x00); 1763 VERIFY_FAILS_END 1764} 1765 1766void testGreaterOrEqual(void) 1767{ 1768 UNITY_INT v0, v1, v2; 1769 UNITY_INT *p0, *p1, *p2; 1770 1771 v0 = 0; 1772 v1 = 1; 1773 v2 = 0; 1774 p0 = &v0; 1775 p1 = &v1; 1776 p2 = &v2; 1777 1778 TEST_ASSERT_GREATER_OR_EQUAL(v0, v1); 1779 TEST_ASSERT_GREATER_OR_EQUAL(*p0, v1); 1780 TEST_ASSERT_GREATER_OR_EQUAL(v0, *p1); 1781 TEST_ASSERT_GREATER_OR_EQUAL(*p0, *p1); 1782 TEST_ASSERT_GREATER_OR_EQUAL(v0, v2); 1783 TEST_ASSERT_GREATER_OR_EQUAL(*p0, v2); 1784 TEST_ASSERT_GREATER_OR_EQUAL(v0, *p2); 1785 TEST_ASSERT_GREATER_OR_EQUAL(*p0, *p2); 1786} 1787 1788void testNotGreaterOrEqual(void) 1789{ 1790 EXPECT_ABORT_BEGIN 1791 TEST_ASSERT_GREATER_OR_EQUAL(0, -1); 1792 VERIFY_FAILS_END 1793} 1794 1795void testGreaterOrEqualINT(void) 1796{ 1797 UNITY_INT v0, v1, v2; 1798 UNITY_INT *p0, *p1, *p2; 1799 1800 v0 = 302; 1801 v1 = 3334; 1802 v2 = 302; 1803 p0 = &v0; 1804 p1 = &v1; 1805 p2 = &v2; 1806 1807 TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, v1); 1808 TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, v1); 1809 TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, *p1); 1810 TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, *p1); 1811 TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, v2); 1812 TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, v2); 1813 TEST_ASSERT_GREATER_OR_EQUAL_INT(v0, *p2); 1814 TEST_ASSERT_GREATER_OR_EQUAL_INT(*p0, *p2); 1815} 1816 1817void testNotGreaterOrEqualINT(void) 1818{ 1819 EXPECT_ABORT_BEGIN 1820 TEST_ASSERT_GREATER_OR_EQUAL_INT(3334, 302); 1821 VERIFY_FAILS_END 1822} 1823 1824void testGreaterOrEqualINT8(void) 1825{ 1826 UNITY_INT8 v0, v1, v2; 1827 UNITY_INT8 *p0, *p1, *p2; 1828 1829 v0 = -128; 1830 v1 = 127; 1831 v2 = -128; 1832 p0 = &v0; 1833 p1 = &v1; 1834 p2 = &v2; 1835 1836 TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, v1); 1837 TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, v1); 1838 TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, *p1); 1839 TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, *p1); 1840 TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, v2); 1841 TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, v2); 1842 TEST_ASSERT_GREATER_OR_EQUAL_INT8(v0, *p2); 1843 TEST_ASSERT_GREATER_OR_EQUAL_INT8(*p0, *p2); 1844} 1845 1846void testNotGreaterOrEqualINT8(void) 1847{ 1848 EXPECT_ABORT_BEGIN 1849 TEST_ASSERT_GREATER_OR_EQUAL_INT8(127, -128); 1850 VERIFY_FAILS_END 1851} 1852 1853void testGreaterOrEqualCHAR(void) 1854{ 1855 char v0, v1, v2; 1856 char *p0, *p1, *p2; 1857 1858 v0 = -128; 1859 v1 = 127; 1860 v2 = -128; 1861 p0 = &v0; 1862 p1 = &v1; 1863 p2 = &v2; 1864 1865 TEST_ASSERT_GREATER_OR_EQUAL_CHAR(v0, v1); 1866 TEST_ASSERT_GREATER_OR_EQUAL_CHAR(*p0, v1); 1867 TEST_ASSERT_GREATER_OR_EQUAL_CHAR(v0, *p1); 1868 TEST_ASSERT_GREATER_OR_EQUAL_CHAR(*p0, *p1); 1869 TEST_ASSERT_GREATER_OR_EQUAL_CHAR(v0, v2); 1870 TEST_ASSERT_GREATER_OR_EQUAL_CHAR(*p0, v2); 1871 TEST_ASSERT_GREATER_OR_EQUAL_CHAR(v0, *p2); 1872 TEST_ASSERT_GREATER_OR_EQUAL_CHAR(*p0, *p2); 1873} 1874 1875void testNotGreaterOrEqualCHAR(void) 1876{ 1877 EXPECT_ABORT_BEGIN 1878 TEST_ASSERT_GREATER_OR_EQUAL_CHAR(127, -128); 1879 VERIFY_FAILS_END 1880} 1881 1882void testGreaterOrEqualINT16(void) 1883{ 1884 UNITY_INT16 v0, v1, v2; 1885 UNITY_INT16 *p0, *p1, *p2; 1886 1887 v0 = -32768; 1888 v1 = 32767; 1889 v2 = -32768; 1890 p0 = &v0; 1891 p1 = &v1; 1892 p2 = &v2; 1893 1894 TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, v1); 1895 TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, v1); 1896 TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, *p1); 1897 TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, *p1); 1898 TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, v2); 1899 TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, v2); 1900 TEST_ASSERT_GREATER_OR_EQUAL_INT16(v0, *p2); 1901 TEST_ASSERT_GREATER_OR_EQUAL_INT16(*p0, *p2); 1902} 1903 1904void testNotGreaterOrEqualINT16(void) 1905{ 1906 EXPECT_ABORT_BEGIN 1907 TEST_ASSERT_GREATER_OR_EQUAL_INT16(32767, -32768); 1908 VERIFY_FAILS_END 1909} 1910 1911void testGreaterOrEqualINT32(void) 1912{ 1913 UNITY_INT32 v0, v1, v2; 1914 UNITY_INT32 *p0, *p1, *p2; 1915 1916 v0 = -214783648; 1917 v1 = 214783647; 1918 v2 = -214783648; 1919 p0 = &v0; 1920 p1 = &v1; 1921 p2 = &v2; 1922 1923 TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, v1); 1924 TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, v1); 1925 TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, *p1); 1926 TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, *p1); 1927 TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, v2); 1928 TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, v2); 1929 TEST_ASSERT_GREATER_OR_EQUAL_INT32(v0, *p2); 1930 TEST_ASSERT_GREATER_OR_EQUAL_INT32(*p0, *p2); 1931} 1932 1933void testNotGreaterOrEqualINT32(void) 1934{ 1935 EXPECT_ABORT_BEGIN 1936 TEST_ASSERT_GREATER_OR_EQUAL_INT32(214783647, -214783648); 1937 VERIFY_FAILS_END 1938} 1939 1940void testGreaterOrEqualUINT(void) 1941{ 1942 UNITY_UINT v0, v1, v2; 1943 UNITY_UINT *p0, *p1, *p2; 1944 1945 v0 = 0; 1946 v1 = 1; 1947 v2 = 0; 1948 p0 = &v0; 1949 p1 = &v1; 1950 p2 = &v2; 1951 1952 TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, v1); 1953 TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, v1); 1954 TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, *p1); 1955 TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, *p1); 1956 TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, v2); 1957 TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, v2); 1958 TEST_ASSERT_GREATER_OR_EQUAL_UINT(v0, *p2); 1959 TEST_ASSERT_GREATER_OR_EQUAL_UINT(*p0, *p2); 1960} 1961 1962void testNotGreaterOrEqualUINT(void) 1963{ 1964 EXPECT_ABORT_BEGIN 1965 TEST_ASSERT_GREATER_OR_EQUAL_UINT(1, 0); 1966 VERIFY_FAILS_END 1967} 1968 1969void testGreaterOrEqualUINT8(void) 1970{ 1971 UNITY_UINT8 v0, v1, v2; 1972 UNITY_UINT8 *p0, *p1, *p2; 1973 1974 v0 = 0; 1975 v1 = 255; 1976 v2 = 0; 1977 p0 = &v0; 1978 p1 = &v1; 1979 p2 = &v2; 1980 1981 TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, v1); 1982 TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, v1); 1983 TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, *p1); 1984 TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, *p1); 1985 TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, v2); 1986 TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, v2); 1987 TEST_ASSERT_GREATER_OR_EQUAL_UINT8(v0, *p2); 1988 TEST_ASSERT_GREATER_OR_EQUAL_UINT8(*p0, *p2); 1989} 1990 1991void testNotGreaterOrEqualUINT8(void) 1992{ 1993 EXPECT_ABORT_BEGIN 1994 TEST_ASSERT_GREATER_OR_EQUAL_UINT8(255, 0); 1995 VERIFY_FAILS_END 1996} 1997 1998void testGreaterOrEqualUINT16(void) 1999{ 2000 UNITY_UINT16 v0, v1, v2; 2001 UNITY_UINT16 *p0, *p1, *p2; 2002 2003 v0 = 0; 2004 v1 = 65535; 2005 v2 = 0; 2006 p0 = &v0; 2007 p1 = &v1; 2008 p2 = &v2; 2009 2010 TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, v1); 2011 TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, v1); 2012 TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, *p1); 2013 TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, *p1); 2014 TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, v2); 2015 TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, v2); 2016 TEST_ASSERT_GREATER_OR_EQUAL_UINT16(v0, *p2); 2017 TEST_ASSERT_GREATER_OR_EQUAL_UINT16(*p0, *p2); 2018} 2019 2020void testNotGreaterOrEqualUINT16(void) 2021{ 2022 EXPECT_ABORT_BEGIN 2023 TEST_ASSERT_GREATER_OR_EQUAL_UINT16(65535, 0); 2024 VERIFY_FAILS_END 2025} 2026 2027void testGreaterOrEqualUINT32(void) 2028{ 2029 UNITY_UINT32 v0, v1, v2; 2030 UNITY_UINT32 *p0, *p1, *p2; 2031 2032 v0 = 0; 2033 v1 = 4294967295u; 2034 v2 = 0; 2035 p0 = &v0; 2036 p1 = &v1; 2037 p2 = &v2; 2038 2039 TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, v1); 2040 TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, v1); 2041 TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, *p1); 2042 TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, *p1); 2043 TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, v2); 2044 TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, v2); 2045 TEST_ASSERT_GREATER_OR_EQUAL_UINT32(v0, *p2); 2046 TEST_ASSERT_GREATER_OR_EQUAL_UINT32(*p0, *p2); 2047} 2048 2049void testNotGreaterOrEqualUINT32(void) 2050{ 2051 EXPECT_ABORT_BEGIN 2052 TEST_ASSERT_GREATER_OR_EQUAL_UINT32(4294967295u, 0); 2053 VERIFY_FAILS_END 2054} 2055 2056void testGreaterOrEqualHEX8(void) 2057{ 2058 UNITY_UINT8 v0, v1, v2; 2059 UNITY_UINT8 *p0, *p1, *p2; 2060 2061 v0 = 0x00; 2062 v1 = 0xFF; 2063 v2 = 0x00; 2064 p0 = &v0; 2065 p1 = &v1; 2066 p2 = &v2; 2067 2068 TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, v1); 2069 TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, v1); 2070 TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, *p1); 2071 TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, *p1); 2072 TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, v2); 2073 TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, v2); 2074 TEST_ASSERT_GREATER_OR_EQUAL_HEX8(v0, *p2); 2075 TEST_ASSERT_GREATER_OR_EQUAL_HEX8(*p0, *p2); 2076} 2077 2078void testNotGreaterOrEqualHEX8(void) 2079{ 2080 EXPECT_ABORT_BEGIN 2081 TEST_ASSERT_GREATER_OR_EQUAL_HEX8(0xFF, 0x00); 2082 VERIFY_FAILS_END 2083} 2084 2085void testGreaterOrEqualHEX16(void) 2086{ 2087 UNITY_UINT16 v0, v1, v2; 2088 UNITY_UINT16 *p0, *p1, *p2; 2089 2090 v0 = 0x0000; 2091 v1 = 0xFFFF; 2092 v2 = 0x0000; 2093 p0 = &v0; 2094 p1 = &v1; 2095 p2 = &v2; 2096 2097 TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, v1); 2098 TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, v1); 2099 TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, *p1); 2100 TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, *p1); 2101 TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, v2); 2102 TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, v2); 2103 TEST_ASSERT_GREATER_OR_EQUAL_HEX16(v0, *p2); 2104 TEST_ASSERT_GREATER_OR_EQUAL_HEX16(*p0, *p2); 2105} 2106 2107void testNotGreaterOrEqualHEX16(void) 2108{ 2109 EXPECT_ABORT_BEGIN 2110 TEST_ASSERT_GREATER_OR_EQUAL_HEX16(0xFFFF, 0x00); 2111 VERIFY_FAILS_END 2112} 2113 2114void testGreaterOrEqualHEX32(void) 2115{ 2116 UNITY_UINT32 v0, v1, v2; 2117 UNITY_UINT32 *p0, *p1, *p2; 2118 2119 v0 = 0x00000000; 2120 v1 = 0xFFFFFFFF; 2121 v2 = 0x00000000; 2122 p0 = &v0; 2123 p1 = &v1; 2124 p2 = &v2; 2125 2126 TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, v1); 2127 TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, v1); 2128 TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, *p1); 2129 TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, *p1); 2130 TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, v2); 2131 TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, v2); 2132 TEST_ASSERT_GREATER_OR_EQUAL_HEX32(v0, *p2); 2133 TEST_ASSERT_GREATER_OR_EQUAL_HEX32(*p0, *p2); 2134} 2135 2136void testNotGreaterOrEqualHEX32(void) 2137{ 2138 EXPECT_ABORT_BEGIN 2139 TEST_ASSERT_GREATER_OR_EQUAL_HEX32(0xFFFFFFFF, 0x00); 2140 VERIFY_FAILS_END 2141} 2142 2143/*-----------------*/ 2144 2145void testLessThan(void) 2146{ 2147 UNITY_INT v0, v1; 2148 UNITY_INT *p0, *p1; 2149 2150 v0 = 0; 2151 v1 = -1; 2152 p0 = &v0; 2153 p1 = &v1; 2154 2155 TEST_ASSERT_LESS_THAN(v0, v1); 2156 TEST_ASSERT_LESS_THAN(*p0, v1); 2157 TEST_ASSERT_LESS_THAN(v0, *p1); 2158 TEST_ASSERT_LESS_THAN(*p0, *p1); 2159} 2160 2161void testNotLessThan(void) 2162{ 2163 EXPECT_ABORT_BEGIN 2164 TEST_ASSERT_LESS_THAN(0, 1); 2165 VERIFY_FAILS_END 2166} 2167 2168void testLessThanINT(void) 2169{ 2170 UNITY_INT v0, v1; 2171 UNITY_INT *p0, *p1; 2172 2173 v0 = 3334; 2174 v1 = 302; 2175 p0 = &v0; 2176 p1 = &v1; 2177 2178 TEST_ASSERT_LESS_THAN_INT(v0, v1); 2179 TEST_ASSERT_LESS_THAN_INT(*p0, v1); 2180 TEST_ASSERT_LESS_THAN_INT(v0, *p1); 2181 TEST_ASSERT_LESS_THAN_INT(*p0, *p1); 2182} 2183 2184void testNotLessThanINT(void) 2185{ 2186 EXPECT_ABORT_BEGIN 2187 TEST_ASSERT_LESS_THAN_INT(302, 3334); 2188 VERIFY_FAILS_END 2189} 2190 2191void testLessThanINT8(void) 2192{ 2193 UNITY_INT8 v0, v1; 2194 UNITY_INT8 *p0, *p1; 2195 2196 v0 = 127; 2197 v1 = -128; 2198 p0 = &v0; 2199 p1 = &v1; 2200 2201 TEST_ASSERT_LESS_THAN_INT8(v0, v1); 2202 TEST_ASSERT_LESS_THAN_INT8(*p0, v1); 2203 TEST_ASSERT_LESS_THAN_INT8(v0, *p1); 2204 TEST_ASSERT_LESS_THAN_INT8(*p0, *p1); 2205} 2206 2207void testNotLessThanINT8(void) 2208{ 2209 EXPECT_ABORT_BEGIN 2210 TEST_ASSERT_LESS_THAN_INT8(-128, 127); 2211 VERIFY_FAILS_END 2212} 2213 2214void testLessThanCHAR(void) 2215{ 2216 char v0, v1; 2217 char *p0, *p1; 2218 2219 v0 = 127; 2220 v1 = -128; 2221 p0 = &v0; 2222 p1 = &v1; 2223 2224 TEST_ASSERT_LESS_THAN_CHAR(v0, v1); 2225 TEST_ASSERT_LESS_THAN_CHAR(*p0, v1); 2226 TEST_ASSERT_LESS_THAN_CHAR(v0, *p1); 2227 TEST_ASSERT_LESS_THAN_CHAR(*p0, *p1); 2228} 2229 2230void testNotLessThanCHAR(void) 2231{ 2232 EXPECT_ABORT_BEGIN 2233 TEST_ASSERT_LESS_THAN_CHAR(-128, 127); 2234 VERIFY_FAILS_END 2235} 2236 2237void testLessThanINT16(void) 2238{ 2239 UNITY_INT16 v0, v1; 2240 UNITY_INT16 *p0, *p1; 2241 2242 v0 = 32767; 2243 v1 = -32768; 2244 p0 = &v0; 2245 p1 = &v1; 2246 2247 TEST_ASSERT_LESS_THAN_INT16(v0, v1); 2248 TEST_ASSERT_LESS_THAN_INT16(*p0, v1); 2249 TEST_ASSERT_LESS_THAN_INT16(v0, *p1); 2250 TEST_ASSERT_LESS_THAN_INT16(*p0, *p1); 2251} 2252 2253void testNotLessThanINT16(void) 2254{ 2255 EXPECT_ABORT_BEGIN 2256 TEST_ASSERT_LESS_THAN_INT16(-32768, 32767); 2257 VERIFY_FAILS_END 2258} 2259 2260void testLessThanINT32(void) 2261{ 2262 UNITY_INT32 v0, v1; 2263 UNITY_INT32 *p0, *p1; 2264 2265 v0 = 214783647; 2266 v1 = -214783648; 2267 p0 = &v0; 2268 p1 = &v1; 2269 2270 TEST_ASSERT_LESS_THAN_INT32(v0, v1); 2271 TEST_ASSERT_LESS_THAN_INT32(*p0, v1); 2272 TEST_ASSERT_LESS_THAN_INT32(v0, *p1); 2273 TEST_ASSERT_LESS_THAN_INT32(*p0, *p1); 2274} 2275 2276void testNotLessThanINT32(void) 2277{ 2278 EXPECT_ABORT_BEGIN 2279 TEST_ASSERT_LESS_THAN_INT32(-214783648, 214783647); 2280 VERIFY_FAILS_END 2281} 2282 2283void testLessThanUINT(void) 2284{ 2285 UNITY_UINT v0, v1; 2286 UNITY_UINT *p0, *p1; 2287 2288 v0 = 1; 2289 v1 = 0; 2290 p0 = &v0; 2291 p1 = &v1; 2292 2293 TEST_ASSERT_LESS_THAN_UINT(v0, v1); 2294 TEST_ASSERT_LESS_THAN_UINT(*p0, v1); 2295 TEST_ASSERT_LESS_THAN_UINT(v0, *p1); 2296 TEST_ASSERT_LESS_THAN_UINT(*p0, *p1); 2297} 2298 2299void testNotLessThanUINT(void) 2300{ 2301 EXPECT_ABORT_BEGIN 2302 TEST_ASSERT_LESS_THAN_UINT(0, 1); 2303 VERIFY_FAILS_END 2304} 2305 2306void testLessThanUINT8(void) 2307{ 2308 UNITY_UINT8 v0, v1; 2309 UNITY_UINT8 *p0, *p1; 2310 2311 v0 = 255; 2312 v1 = 0; 2313 p0 = &v0; 2314 p1 = &v1; 2315 2316 TEST_ASSERT_LESS_THAN_UINT8(v0, v1); 2317 TEST_ASSERT_LESS_THAN_UINT8(*p0, v1); 2318 TEST_ASSERT_LESS_THAN_UINT8(v0, *p1); 2319 TEST_ASSERT_LESS_THAN_UINT8(*p0, *p1); 2320} 2321 2322void testNotLessThanUINT8(void) 2323{ 2324 EXPECT_ABORT_BEGIN 2325 TEST_ASSERT_LESS_THAN_UINT8(0, 255); 2326 VERIFY_FAILS_END 2327} 2328 2329void testLessThanUINT16(void) 2330{ 2331 UNITY_UINT16 v0, v1; 2332 UNITY_UINT16 *p0, *p1; 2333 2334 v0 = 65535; 2335 v1 = 0; 2336 p0 = &v0; 2337 p1 = &v1; 2338 2339 TEST_ASSERT_LESS_THAN_UINT16(v0, v1); 2340 TEST_ASSERT_LESS_THAN_UINT16(*p0, v1); 2341 TEST_ASSERT_LESS_THAN_UINT16(v0, *p1); 2342 TEST_ASSERT_LESS_THAN_UINT16(*p0, *p1); 2343} 2344 2345void testNotLessThanUINT16(void) 2346{ 2347 EXPECT_ABORT_BEGIN 2348 TEST_ASSERT_LESS_THAN_UINT16(0, 65535); 2349 VERIFY_FAILS_END 2350} 2351 2352void testLessThanUINT32(void) 2353{ 2354 UNITY_UINT32 v0, v1; 2355 UNITY_UINT32 *p0, *p1; 2356 2357 v0 = 4294967295u; 2358 v1 = 0; 2359 p0 = &v0; 2360 p1 = &v1; 2361 2362 TEST_ASSERT_LESS_THAN_UINT32(v0, v1); 2363 TEST_ASSERT_LESS_THAN_UINT32(*p0, v1); 2364 TEST_ASSERT_LESS_THAN_UINT32(v0, *p1); 2365 TEST_ASSERT_LESS_THAN_UINT32(*p0, *p1); 2366} 2367 2368void testNotLessThanUINT32(void) 2369{ 2370 EXPECT_ABORT_BEGIN 2371 TEST_ASSERT_LESS_THAN_UINT32(0, 4294967295u); 2372 VERIFY_FAILS_END 2373} 2374 2375void testLessThanHEX8(void) 2376{ 2377 UNITY_UINT8 v0, v1; 2378 UNITY_UINT8 *p0, *p1; 2379 2380 v0 = 0xFF; 2381 v1 = 0x00; 2382 p0 = &v0; 2383 p1 = &v1; 2384 2385 TEST_ASSERT_LESS_THAN_HEX8(v0, v1); 2386 TEST_ASSERT_LESS_THAN_HEX8(*p0, v1); 2387 TEST_ASSERT_LESS_THAN_HEX8(v0, *p1); 2388 TEST_ASSERT_LESS_THAN_HEX8(*p0, *p1); 2389} 2390 2391void testNotLessThanHEX8(void) 2392{ 2393 EXPECT_ABORT_BEGIN 2394 TEST_ASSERT_LESS_THAN_HEX8(0x00, 0xFF); 2395 VERIFY_FAILS_END 2396} 2397 2398void testLessThanHEX16(void) 2399{ 2400 UNITY_UINT16 v0, v1; 2401 UNITY_UINT16 *p0, *p1; 2402 2403 v0 = 0xFFFF; 2404 v1 = 0x0000; 2405 p0 = &v0; 2406 p1 = &v1; 2407 2408 TEST_ASSERT_LESS_THAN_HEX16(v0, v1); 2409 TEST_ASSERT_LESS_THAN_HEX16(*p0, v1); 2410 TEST_ASSERT_LESS_THAN_HEX16(v0, *p1); 2411 TEST_ASSERT_LESS_THAN_HEX16(*p0, *p1); 2412} 2413 2414void testNotLessThanHEX16(void) 2415{ 2416 EXPECT_ABORT_BEGIN 2417 TEST_ASSERT_LESS_THAN_HEX16(0x0000, 0xFFFF); 2418 VERIFY_FAILS_END 2419} 2420 2421void testLessThanHEX32(void) 2422{ 2423 UNITY_UINT32 v0, v1; 2424 UNITY_UINT32 *p0, *p1; 2425 2426 v0 = 0xFFFFFFFF; 2427 v1 = 0x00000000; 2428 p0 = &v0; 2429 p1 = &v1; 2430 2431 TEST_ASSERT_LESS_THAN_HEX32(v0, v1); 2432 TEST_ASSERT_LESS_THAN_HEX32(*p0, v1); 2433 TEST_ASSERT_LESS_THAN_HEX32(v0, *p1); 2434 TEST_ASSERT_LESS_THAN_HEX32(*p0, *p1); 2435} 2436 2437void testNotLessThanHEX32(void) 2438{ 2439 EXPECT_ABORT_BEGIN 2440 TEST_ASSERT_LESS_THAN_HEX32(0x00000000, 0xFFFFFFFF); 2441 VERIFY_FAILS_END 2442} 2443 2444void testLessOrEqual(void) 2445{ 2446 UNITY_INT v0, v1, v2; 2447 UNITY_INT *p0, *p1, *p2; 2448 2449 v0 = 0; 2450 v1 = -1; 2451 v2 = 0; 2452 p0 = &v0; 2453 p1 = &v1; 2454 p2 = &v2; 2455 2456 TEST_ASSERT_LESS_OR_EQUAL(v0, v1); 2457 TEST_ASSERT_LESS_OR_EQUAL(*p0, v1); 2458 TEST_ASSERT_LESS_OR_EQUAL(v0, *p1); 2459 TEST_ASSERT_LESS_OR_EQUAL(*p0, *p1); 2460 TEST_ASSERT_LESS_OR_EQUAL(v0, v2); 2461 TEST_ASSERT_LESS_OR_EQUAL(*p0, v2); 2462 TEST_ASSERT_LESS_OR_EQUAL(v0, *p2); 2463 TEST_ASSERT_LESS_OR_EQUAL(*p0, *p2); 2464} 2465 2466void testNotLessOrEqual(void) 2467{ 2468 EXPECT_ABORT_BEGIN 2469 TEST_ASSERT_LESS_OR_EQUAL(0, 1); 2470 VERIFY_FAILS_END 2471} 2472 2473void testLessOrEqualINT(void) 2474{ 2475 UNITY_INT v0, v1, v2; 2476 UNITY_INT *p0, *p1, *p2; 2477 2478 v0 = 3334; 2479 v1 = 302; 2480 v2 = 3334; 2481 p0 = &v0; 2482 p1 = &v1; 2483 p2 = &v2; 2484 2485 TEST_ASSERT_LESS_OR_EQUAL_INT(v0, v1); 2486 TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, v1); 2487 TEST_ASSERT_LESS_OR_EQUAL_INT(v0, *p1); 2488 TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, *p1); 2489 TEST_ASSERT_LESS_OR_EQUAL_INT(v0, v2); 2490 TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, v2); 2491 TEST_ASSERT_LESS_OR_EQUAL_INT(v0, *p2); 2492 TEST_ASSERT_LESS_OR_EQUAL_INT(*p0, *p2); 2493} 2494 2495void testNotLessOrEqualINT(void) 2496{ 2497 EXPECT_ABORT_BEGIN 2498 TEST_ASSERT_LESS_OR_EQUAL_INT(302, 3334); 2499 VERIFY_FAILS_END 2500} 2501 2502void testLessOrEqualINT8(void) 2503{ 2504 UNITY_INT8 v0, v1, v2; 2505 UNITY_INT8 *p0, *p1, *p2; 2506 2507 v0 = 127; 2508 v1 = -128; 2509 v2 = 127; 2510 p0 = &v0; 2511 p1 = &v1; 2512 p2 = &v2; 2513 2514 TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, v1); 2515 TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, v1); 2516 TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, *p1); 2517 TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, *p1); 2518 TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, v2); 2519 TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, v2); 2520 TEST_ASSERT_LESS_OR_EQUAL_INT8(v0, *p2); 2521 TEST_ASSERT_LESS_OR_EQUAL_INT8(*p0, *p2); 2522} 2523 2524void testNotLessOrEqualINT8(void) 2525{ 2526 EXPECT_ABORT_BEGIN 2527 TEST_ASSERT_LESS_OR_EQUAL_INT8(-128, 127); 2528 VERIFY_FAILS_END 2529} 2530 2531void testLessOrEqualCHAR(void) 2532{ 2533 char v0, v1, v2; 2534 char *p0, *p1, *p2; 2535 2536 v0 = 127; 2537 v1 = -128; 2538 v2 = 127; 2539 p0 = &v0; 2540 p1 = &v1; 2541 p2 = &v2; 2542 2543 TEST_ASSERT_LESS_OR_EQUAL_CHAR(v0, v1); 2544 TEST_ASSERT_LESS_OR_EQUAL_CHAR(*p0, v1); 2545 TEST_ASSERT_LESS_OR_EQUAL_CHAR(v0, *p1); 2546 TEST_ASSERT_LESS_OR_EQUAL_CHAR(*p0, *p1); 2547 TEST_ASSERT_LESS_OR_EQUAL_CHAR(v0, v2); 2548 TEST_ASSERT_LESS_OR_EQUAL_CHAR(*p0, v2); 2549 TEST_ASSERT_LESS_OR_EQUAL_CHAR(v0, *p2); 2550 TEST_ASSERT_LESS_OR_EQUAL_CHAR(*p0, *p2); 2551} 2552 2553void testNotLessOrEqualCHAR(void) 2554{ 2555 EXPECT_ABORT_BEGIN 2556 TEST_ASSERT_LESS_OR_EQUAL_CHAR(-128, 127); 2557 VERIFY_FAILS_END 2558} 2559 2560void testLessOrEqualINT16(void) 2561{ 2562 UNITY_INT16 v0, v1, v2; 2563 UNITY_INT16 *p0, *p1, *p2; 2564 2565 v0 = 32767; 2566 v1 = -32768; 2567 v2 = 32767; 2568 p0 = &v0; 2569 p1 = &v1; 2570 p2 = &v2; 2571 2572 TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, v1); 2573 TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, v1); 2574 TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, *p1); 2575 TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, *p1); 2576 TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, v2); 2577 TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, v2); 2578 TEST_ASSERT_LESS_OR_EQUAL_INT16(v0, *p2); 2579 TEST_ASSERT_LESS_OR_EQUAL_INT16(*p0, *p2); 2580} 2581 2582void testNotLessOrEqualINT16(void) 2583{ 2584 EXPECT_ABORT_BEGIN 2585 TEST_ASSERT_LESS_OR_EQUAL_INT16(-32768, 32767); 2586 VERIFY_FAILS_END 2587} 2588 2589void testLessOrEqualINT32(void) 2590{ 2591 UNITY_INT32 v0, v1, v2; 2592 UNITY_INT32 *p0, *p1, *p2; 2593 2594 v0 = 214783647; 2595 v1 = -214783648; 2596 v2 = 214783647; 2597 p0 = &v0; 2598 p1 = &v1; 2599 p2 = &v2; 2600 2601 TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, v1); 2602 TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, v1); 2603 TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, *p1); 2604 TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, *p1); 2605 TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, v2); 2606 TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, v2); 2607 TEST_ASSERT_LESS_OR_EQUAL_INT32(v0, *p2); 2608 TEST_ASSERT_LESS_OR_EQUAL_INT32(*p0, *p2); 2609} 2610 2611void testNotLessOrEqualINT32(void) 2612{ 2613 EXPECT_ABORT_BEGIN 2614 TEST_ASSERT_LESS_OR_EQUAL_INT32(-214783648, 214783647); 2615 VERIFY_FAILS_END 2616} 2617 2618void testLessOrEqualUINT(void) 2619{ 2620 UNITY_UINT v0, v1, v2; 2621 UNITY_UINT *p0, *p1, *p2; 2622 2623 v0 = 1; 2624 v1 = 0; 2625 v2 = 1; 2626 p0 = &v0; 2627 p1 = &v1; 2628 p2 = &v2; 2629 2630 TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, v1); 2631 TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, v1); 2632 TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, *p1); 2633 TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, *p1); 2634 TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, v2); 2635 TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, v2); 2636 TEST_ASSERT_LESS_OR_EQUAL_UINT(v0, *p2); 2637 TEST_ASSERT_LESS_OR_EQUAL_UINT(*p0, *p2); 2638} 2639 2640void testNotLessOrEqualUINT(void) 2641{ 2642 EXPECT_ABORT_BEGIN 2643 TEST_ASSERT_LESS_OR_EQUAL_UINT(0, 1); 2644 VERIFY_FAILS_END 2645} 2646 2647void testLessOrEqualUINT8(void) 2648{ 2649 UNITY_UINT8 v0, v1, v2; 2650 UNITY_UINT8 *p0, *p1, *p2; 2651 2652 v0 = 255; 2653 v1 = 0; 2654 v2 = 255; 2655 p0 = &v0; 2656 p1 = &v1; 2657 p2 = &v2; 2658 2659 TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, v1); 2660 TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, v1); 2661 TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, *p1); 2662 TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, *p1); 2663 TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, v2); 2664 TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, v2); 2665 TEST_ASSERT_LESS_OR_EQUAL_UINT8(v0, *p2); 2666 TEST_ASSERT_LESS_OR_EQUAL_UINT8(*p0, *p2); 2667} 2668 2669void testNotLessOrEqualUINT8(void) 2670{ 2671 EXPECT_ABORT_BEGIN 2672 TEST_ASSERT_LESS_OR_EQUAL_UINT8(0, 255); 2673 VERIFY_FAILS_END 2674} 2675 2676void testLessOrEqualUINT16(void) 2677{ 2678 UNITY_UINT16 v0, v1, v2; 2679 UNITY_UINT16 *p0, *p1, *p2; 2680 2681 v0 = 65535; 2682 v1 = 0; 2683 v2 = 65535; 2684 p0 = &v0; 2685 p1 = &v1; 2686 p2 = &v2; 2687 2688 TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, v1); 2689 TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, v1); 2690 TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, *p1); 2691 TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, *p1); 2692 TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, v2); 2693 TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, v2); 2694 TEST_ASSERT_LESS_OR_EQUAL_UINT16(v0, *p2); 2695 TEST_ASSERT_LESS_OR_EQUAL_UINT16(*p0, *p2); 2696} 2697 2698void testNotLessOrEqualUINT16(void) 2699{ 2700 EXPECT_ABORT_BEGIN 2701 TEST_ASSERT_LESS_OR_EQUAL_UINT16(0, 65535); 2702 VERIFY_FAILS_END 2703} 2704 2705void testLessOrEqualUINT32(void) 2706{ 2707 UNITY_UINT32 v0, v1, v2; 2708 UNITY_UINT32 *p0, *p1, *p2; 2709 2710 v0 = 4294967295u; 2711 v1 = 0; 2712 v2 = 4294967295u; 2713 p0 = &v0; 2714 p1 = &v1; 2715 p2 = &v2; 2716 2717 TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, v1); 2718 TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, v1); 2719 TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, *p1); 2720 TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, *p1); 2721 TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, v2); 2722 TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, v2); 2723 TEST_ASSERT_LESS_OR_EQUAL_UINT32(v0, *p2); 2724 TEST_ASSERT_LESS_OR_EQUAL_UINT32(*p0, *p2); 2725} 2726 2727void testNotLessOrEqualUINT32(void) 2728{ 2729 EXPECT_ABORT_BEGIN 2730 TEST_ASSERT_LESS_OR_EQUAL_UINT32(0, 4294967295u); 2731 VERIFY_FAILS_END 2732} 2733 2734void testLessOrEqualHEX8(void) 2735{ 2736 UNITY_UINT8 v0, v1, v2; 2737 UNITY_UINT8 *p0, *p1, *p2; 2738 2739 v0 = 0xFF; 2740 v1 = 0x00; 2741 v2 = 0xFF; 2742 p0 = &v0; 2743 p1 = &v1; 2744 p2 = &v2; 2745 2746 TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, v1); 2747 TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, v1); 2748 TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, *p1); 2749 TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, *p1); 2750 TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, v2); 2751 TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, v2); 2752 TEST_ASSERT_LESS_OR_EQUAL_HEX8(v0, *p2); 2753 TEST_ASSERT_LESS_OR_EQUAL_HEX8(*p0, *p2); 2754} 2755 2756void testNotLessOrEqualHEX8(void) 2757{ 2758 EXPECT_ABORT_BEGIN 2759 TEST_ASSERT_LESS_OR_EQUAL_HEX8(0x00, 0xFF); 2760 VERIFY_FAILS_END 2761} 2762 2763void testLessOrEqualHEX16(void) 2764{ 2765 UNITY_UINT16 v0, v1, v2; 2766 UNITY_UINT16 *p0, *p1, *p2; 2767 2768 v0 = 0xFFFF; 2769 v1 = 0x0000; 2770 v2 = 0xFFFF; 2771 p0 = &v0; 2772 p1 = &v1; 2773 p2 = &v2; 2774 2775 TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, v1); 2776 TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, v1); 2777 TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, *p1); 2778 TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, *p1); 2779 TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, v2); 2780 TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, v2); 2781 TEST_ASSERT_LESS_OR_EQUAL_HEX16(v0, *p2); 2782 TEST_ASSERT_LESS_OR_EQUAL_HEX16(*p0, *p2); 2783} 2784 2785void testNotLessOrEqualHEX16(void) 2786{ 2787 EXPECT_ABORT_BEGIN 2788 TEST_ASSERT_LESS_OR_EQUAL_HEX16(0x0000, 0xFFFF); 2789 VERIFY_FAILS_END 2790} 2791 2792void testLessOrEqualHEX32(void) 2793{ 2794 UNITY_UINT32 v0, v1, v2; 2795 UNITY_UINT32 *p0, *p1, *p2; 2796 2797 v0 = 0xFFFFFFFF; 2798 v1 = 0x00000000; 2799 v2 = 0xFFFFFFFF; 2800 p0 = &v0; 2801 p1 = &v1; 2802 p2 = &v2; 2803 2804 TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, v1); 2805 TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, v1); 2806 TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, *p1); 2807 TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, *p1); 2808 TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, v2); 2809 TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, v2); 2810 TEST_ASSERT_LESS_OR_EQUAL_HEX32(v0, *p2); 2811 TEST_ASSERT_LESS_OR_EQUAL_HEX32(*p0, *p2); 2812} 2813 2814void testNotLessOrEqualHEX32(void) 2815{ 2816 EXPECT_ABORT_BEGIN 2817 TEST_ASSERT_LESS_OR_EQUAL_HEX32(0x00000000, 0xFFFFFFFF); 2818 VERIFY_FAILS_END 2819} 2820 2821void testHexPrintsUpToMaxNumberOfNibbles(void) 2822{ 2823#ifndef USING_OUTPUT_SPY 2824 TEST_IGNORE(); 2825#else 2826 startPutcharSpy(); 2827 UnityPrintNumberHex(0xBEE, 21); 2828 endPutcharSpy(); 2829#ifdef UNITY_SUPPORT_64 2830 TEST_ASSERT_EQUAL_INT(16, strlen(getBufferPutcharSpy())); 2831#else 2832 TEST_ASSERT_EQUAL_INT( 8, strlen(getBufferPutcharSpy())); 2833#endif 2834#endif 2835} 2836 2837void testPrintNumbers32(void) 2838{ 2839#ifndef USING_OUTPUT_SPY 2840 TEST_IGNORE_MESSAGE("Compile with '-D UNITY_OUTPUT_CHAR=putcharSpy' to enable print testing"); 2841#else 2842 TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0); 2843 TEST_ASSERT_EQUAL_PRINT_NUMBERS("1", 1); 2844 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", -1); 2845 TEST_ASSERT_EQUAL_PRINT_NUMBERS("2000000000", 2000000000); 2846 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-2147483648", (UNITY_INT32)0x80000000); 2847 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (UNITY_INT32)0xFFFFFFFF); 2848#endif 2849} 2850 2851void testPrintNumbersUnsigned32(void) 2852{ 2853#ifndef USING_OUTPUT_SPY 2854 TEST_IGNORE(); 2855#else 2856 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0); 2857 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1", 1); 2858 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1500000000", 1500000000); 2859 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("2147483648", (UNITY_UINT32)0x80000000); 2860 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("4294967295", (UNITY_UINT32)0xFFFFFFFF); 2861#endif 2862} 2863