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 testInt64ArrayWithinDelta(void) 37{ 38#ifndef UNITY_SUPPORT_64 39 TEST_IGNORE(); 40#else 41 UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; 42 UNITY_INT64 actualSmallDelta[] = {12345001, -12344996, 12345005}; 43 UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; 44 45 TEST_ASSERT_INT64_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 46 TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, actualBigDelta, 3); 47#endif 48} 49 50void testInt64ArrayWithinDeltaAndMessage(void) 51{ 52#ifndef UNITY_SUPPORT_64 53 TEST_IGNORE(); 54#else 55 UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; 56 UNITY_INT64 actualSmallDelta[] = {12345001, -12344996, 12345005}; 57 UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; 58 59 TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 60 TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); 61#endif 62} 63 64void testInt64ArrayNotWithinDelta(void) 65{ 66#ifndef UNITY_SUPPORT_64 67 TEST_IGNORE(); 68#else 69 UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; 70 UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; 71 72 EXPECT_ABORT_BEGIN 73 TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 74 VERIFY_FAILS_END 75#endif 76} 77 78void testInt64ArrayNotWithinDeltaAndMessage(void) 79{ 80#ifndef UNITY_SUPPORT_64 81 TEST_IGNORE(); 82#else 83 UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; 84 UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; 85 86 EXPECT_ABORT_BEGIN 87 TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 88 VERIFY_FAILS_END 89#endif 90} 91 92void testInt64ArrayWithinDeltaPointless(void) 93{ 94#ifndef UNITY_SUPPORT_64 95 TEST_IGNORE(); 96#else 97 UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; 98 UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; 99 100 EXPECT_ABORT_BEGIN 101 TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, actualBigDelta, 0); 102 VERIFY_FAILS_END 103#endif 104} 105 106void testInt64ArrayWithinDeltaPointlessAndMessage(void) 107{ 108#ifndef UNITY_SUPPORT_64 109 TEST_IGNORE(); 110#else 111 UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; 112 UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; 113 114 EXPECT_ABORT_BEGIN 115 TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); 116 VERIFY_FAILS_END 117#endif 118} 119 120void testInt64ArrayWithinDeltaExpectedNull(void) 121{ 122#ifndef UNITY_SUPPORT_64 123 TEST_IGNORE(); 124#else 125 UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; 126 127 EXPECT_ABORT_BEGIN 128 TEST_ASSERT_INT64_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); 129 VERIFY_FAILS_END 130#endif 131} 132 133void testInt64ArrayWithinDeltaExpectedNullAndMessage(void) 134{ 135#ifndef UNITY_SUPPORT_64 136 TEST_IGNORE(); 137#else 138 UNITY_INT64 actualBigDelta[] = {12345101, -12344896, 12345055}; 139 140 EXPECT_ABORT_BEGIN 141 TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); 142 VERIFY_FAILS_END 143#endif 144} 145 146void testInt64ArrayWithinDeltaActualNull(void) 147{ 148#ifndef UNITY_SUPPORT_64 149 TEST_IGNORE(); 150#else 151 UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; 152 153 EXPECT_ABORT_BEGIN 154 TEST_ASSERT_INT64_ARRAY_WITHIN(110, expected, NULL, 3); 155 VERIFY_FAILS_END 156#endif 157} 158 159void testInt64ArrayWithinDeltaActualNullAndMessage(void) 160{ 161#ifndef UNITY_SUPPORT_64 162 TEST_IGNORE(); 163#else 164 UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; 165 166 EXPECT_ABORT_BEGIN 167 TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); 168 VERIFY_FAILS_END 169#endif 170} 171 172void testInt64ArrayWithinDeltaSamePointer(void) 173{ 174#ifndef UNITY_SUPPORT_64 175 TEST_IGNORE(); 176#else 177 UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; 178 179 TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3); 180#endif 181} 182 183void testInt64ArrayWithinDeltaSamePointerAndMessage(void) 184{ 185#ifndef UNITY_SUPPORT_64 186 TEST_IGNORE(); 187#else 188 UNITY_INT64 expected[] = {12345000, -12344995, 12345005}; 189 190 TEST_ASSERT_INT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); 191#endif 192} 193 194void testIntArrayWithinDelta(void) 195{ 196 UNITY_INT expected[] = {5000, -4995, 5005}; 197 UNITY_INT actualSmallDelta[] = {5001, -4996, 5005}; 198 UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; 199 200 TEST_ASSERT_INT_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 201 TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, actualBigDelta, 3); 202} 203 204void testIntArrayWithinDeltaAndMessage(void) 205{ 206 UNITY_INT expected[] = {5000, -4995, 5005}; 207 UNITY_INT actualSmallDelta[] = {5001, -4996, 5005}; 208 UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; 209 210 TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 211 TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); 212} 213 214void testIntArrayNotWithinDelta(void) 215{ 216 UNITY_INT expected[] = {5000, -4995, 5005}; 217 UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; 218 219 EXPECT_ABORT_BEGIN 220 TEST_ASSERT_INT_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 221 VERIFY_FAILS_END 222} 223 224void testIntArrayNotWithinDeltaAndMessage(void) 225{ 226 UNITY_INT expected[] = {5000, -4995, 5005}; 227 UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; 228 229 EXPECT_ABORT_BEGIN 230 TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 231 VERIFY_FAILS_END 232} 233 234void testIntArrayWithinDeltaPointless(void) 235{ 236 UNITY_INT expected[] = {5000, -4995, 5005}; 237 UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; 238 239 EXPECT_ABORT_BEGIN 240 TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, actualBigDelta, 0); 241 VERIFY_FAILS_END 242} 243 244void testIntArrayWithinDeltaPointlessAndMessage(void) 245{ 246 UNITY_INT expected[] = {5000, -4995, 5005}; 247 UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; 248 249 EXPECT_ABORT_BEGIN 250 TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); 251 VERIFY_FAILS_END 252} 253 254void testIntArrayWithinDeltaExpectedNull(void) 255{ 256 UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; 257 258 EXPECT_ABORT_BEGIN 259 TEST_ASSERT_INT_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); 260 VERIFY_FAILS_END 261} 262 263void testIntArrayWithinDeltaExpectedNullAndMessage(void) 264{ 265 UNITY_INT actualBigDelta[] = {5101, -4896, 5055}; 266 267 EXPECT_ABORT_BEGIN 268 TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); 269 VERIFY_FAILS_END 270} 271 272void testIntArrayWithinDeltaActualNull(void) 273{ 274 UNITY_INT expected[] = {5000, -4995, 5005}; 275 276 EXPECT_ABORT_BEGIN 277 TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, NULL, 3); 278 VERIFY_FAILS_END 279} 280 281void testIntArrayWithinDeltaActualNullAndMessage(void) 282{ 283 UNITY_INT expected[] = {5000, -4995, 5005}; 284 285 EXPECT_ABORT_BEGIN 286 TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); 287 VERIFY_FAILS_END 288} 289 290void testIntArrayWithinDeltaSamePointer(void) 291{ 292 UNITY_INT expected[] = {5000, -4995, 5005}; 293 294 TEST_ASSERT_INT_ARRAY_WITHIN(110, expected, expected, 3); 295} 296 297void testIntArrayWithinDeltaSamePointerAndMessage(void) 298{ 299 UNITY_INT expected[] = {5000, -4995, 5005}; 300 301 TEST_ASSERT_INT_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); 302} 303 304void testInt16ArrayWithinDelta(void) 305{ 306 UNITY_INT16 expected[] = {5000, -4995, 5005}; 307 UNITY_INT16 actualSmallDelta[] = {5001, -4996, 5005}; 308 UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; 309 310 TEST_ASSERT_INT16_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 311 TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, actualBigDelta, 3); 312} 313 314void testInt16ArrayWithinDeltaAndMessage(void) 315{ 316 UNITY_INT16 expected[] = {5000, -4995, 5005}; 317 UNITY_INT16 actualSmallDelta[] = {5001, -4996, 5005}; 318 UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; 319 320 TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 321 TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); 322} 323 324void testInt16ArrayNotWithinDelta(void) 325{ 326 UNITY_INT16 expected[] = {5000, -4995, 5005}; 327 UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; 328 329 EXPECT_ABORT_BEGIN 330 TEST_ASSERT_UINT16_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 331 VERIFY_FAILS_END 332} 333 334void testInt16ArrayNotWithinDeltaAndMessage(void) 335{ 336 UNITY_INT16 expected[] = {5000, -4995, 5005}; 337 UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; 338 339 EXPECT_ABORT_BEGIN 340 TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 341 VERIFY_FAILS_END 342} 343 344void testInt16ArrayWithinDeltaPointless(void) 345{ 346 UNITY_INT16 expected[] = {5000, -4995, 5005}; 347 UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; 348 349 EXPECT_ABORT_BEGIN 350 TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, actualBigDelta, 0); 351 VERIFY_FAILS_END 352} 353 354void testInt16ArrayWithinDeltaPointlessAndMessage(void) 355{ 356 UNITY_INT16 expected[] = {5000, -4995, 5005}; 357 UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; 358 359 EXPECT_ABORT_BEGIN 360 TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); 361 VERIFY_FAILS_END 362} 363 364void testInt16ArrayWithinDeltaExpectedNull(void) 365{ 366 UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; 367 368 EXPECT_ABORT_BEGIN 369 TEST_ASSERT_INT16_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); 370 VERIFY_FAILS_END 371} 372 373void testInt16ArrayWithinDeltaExpectedNullAndMessage(void) 374{ 375 UNITY_INT16 actualBigDelta[] = {5101, -4896, 5055}; 376 377 EXPECT_ABORT_BEGIN 378 TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); 379 VERIFY_FAILS_END 380} 381 382void testInt16ArrayWithinDeltaActualNull(void) 383{ 384 UNITY_INT16 expected[] = {5000, -4995, 5005}; 385 386 EXPECT_ABORT_BEGIN 387 TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, NULL, 3); 388 VERIFY_FAILS_END 389} 390 391void testInt16ArrayWithinDeltaActualNullAndMessage(void) 392{ 393 UNITY_INT16 expected[] = {5000, -4995, 5005}; 394 395 EXPECT_ABORT_BEGIN 396 TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); 397 VERIFY_FAILS_END 398} 399 400void testInt16ArrayWithinDeltaSamePointer(void) 401{ 402 UNITY_INT16 expected[] = {5000, -4995, 5005}; 403 404 TEST_ASSERT_INT16_ARRAY_WITHIN(110, expected, expected, 3); 405} 406 407void testInt16ArrayWithinDeltaSamePointerAndMessage(void) 408{ 409 UNITY_INT16 expected[] = {5000, -4995, 5005}; 410 411 TEST_ASSERT_INT16_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); 412} 413 414void testInt8ArrayWithinDelta(void) 415{ 416 UNITY_INT8 expected[] = {20, -95, 55}; 417 UNITY_INT8 actualSmallDelta[] = {21, -94, 55}; 418 UNITY_INT8 actualBigDelta[] = {11, -86, 45}; 419 420 TEST_ASSERT_INT8_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 421 TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, actualBigDelta, 3); 422} 423 424void testInt8ArrayWithinDeltaAndMessage(void) 425{ 426 UNITY_INT8 expected[] = {20, -95, 55}; 427 UNITY_INT8 actualSmallDelta[] = {21, -94, 55}; 428 UNITY_INT8 actualBigDelta[] = {11, -86, 45}; 429 430 TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 431 TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 3, "Custom Message."); 432} 433 434void testInt8ArrayNotWithinDelta(void) 435{ 436 UNITY_INT8 expected[] = {20, -95, 55}; 437 UNITY_INT8 actualBigDelta[] = {11, -86, 45}; 438 439 EXPECT_ABORT_BEGIN 440 TEST_ASSERT_INT8_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 441 VERIFY_FAILS_END 442} 443 444void testInt8ArrayNotWithinDeltaAndMessage(void) 445{ 446 UNITY_INT8 expected[] = {20, -95, 55}; 447 UNITY_INT8 actualBigDelta[] = {11, -86, 45}; 448 449 EXPECT_ABORT_BEGIN 450 TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 451 VERIFY_FAILS_END 452} 453 454void testInt8ArrayWithinDeltaPointless(void) 455{ 456 UNITY_INT8 expected[] = {20, -95, 55}; 457 UNITY_INT8 actualBigDelta[] = {11, -86, 45}; 458 459 EXPECT_ABORT_BEGIN 460 TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, actualBigDelta, 0); 461 VERIFY_FAILS_END 462} 463 464void testInt8ArrayWithinDeltaPointlessAndMessage(void) 465{ 466 UNITY_INT8 expected[] = {20, -95, 55}; 467 UNITY_INT8 actualBigDelta[] = {11, -86, 45}; 468 469 EXPECT_ABORT_BEGIN 470 TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 0, "Custom Message."); 471 VERIFY_FAILS_END 472} 473 474void testInt8ArrayWithinDeltaExpectedNull(void) 475{ 476 UNITY_INT8 actualBigDelta[] = {11, -86, 45}; 477 478 EXPECT_ABORT_BEGIN 479 TEST_ASSERT_INT8_ARRAY_WITHIN(11, NULL, actualBigDelta, 3); 480 VERIFY_FAILS_END 481} 482 483void testInt8ArrayWithinDeltaExpectedNullAndMessage(void) 484{ 485 UNITY_INT8 actualBigDelta[] = {11, -86, 45}; 486 487 EXPECT_ABORT_BEGIN 488 TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, NULL, actualBigDelta, 3, "Custom Message."); 489 VERIFY_FAILS_END 490} 491 492void testInt8ArrayWithinDeltaActualNull(void) 493{ 494 UNITY_INT8 expected[] = {20, -95, 55}; 495 496 EXPECT_ABORT_BEGIN 497 TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, NULL, 3); 498 VERIFY_FAILS_END 499} 500 501void testInt8ArrayWithinDeltaActualNullAndMessage(void) 502{ 503 UNITY_INT8 expected[] = {20, -95, 55}; 504 505 EXPECT_ABORT_BEGIN 506 TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, NULL, 3, "Custom Message."); 507 VERIFY_FAILS_END 508} 509 510void testInt8ArrayWithinDeltaSamePointer(void) 511{ 512 UNITY_INT8 expected[] = {20, -95, 55}; 513 514 TEST_ASSERT_INT8_ARRAY_WITHIN(11, expected, expected, 3); 515} 516 517void testInt8ArrayWithinDeltaSamePointerAndMessage(void) 518{ 519 UNITY_INT8 expected[] = {20, -95, 55}; 520 521 TEST_ASSERT_INT8_ARRAY_WITHIN_MESSAGE(11, expected, expected, 3, "Custom Message."); 522} 523 524void testCHARArrayWithinDelta(void) 525{ 526 char expected[] = {20, -95, 55}; 527 char actualSmallDelta[] = {21, -94, 55}; 528 char actualBigDelta[] = {11, -86, 45}; 529 530 TEST_ASSERT_CHAR_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 531 TEST_ASSERT_CHAR_ARRAY_WITHIN(11, expected, actualBigDelta, 3); 532} 533 534void testCHARArrayWithinDeltaAndMessage(void) 535{ 536 char expected[] = {20, -95, 55}; 537 char actualSmallDelta[] = {21, -94, 55}; 538 char actualBigDelta[] = {11, -86, 45}; 539 540 TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 541 TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 3, "Custom Message."); 542} 543 544void testCHARArrayNotWithinDelta(void) 545{ 546 char expected[] = {20, -95, 55}; 547 char actualBigDelta[] = {11, -86, 45}; 548 549 EXPECT_ABORT_BEGIN 550 TEST_ASSERT_CHAR_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 551 VERIFY_FAILS_END 552} 553 554void testCHARArrayNotWithinDeltaAndMessage(void) 555{ 556 char expected[] = {20, -95, 55}; 557 char actualBigDelta[] = {11, -86, 45}; 558 559 EXPECT_ABORT_BEGIN 560 TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 561 VERIFY_FAILS_END 562} 563 564void testCHARArrayWithinDeltaPointless(void) 565{ 566 char expected[] = {20, -95, 55}; 567 char actualBigDelta[] = {11, -86, 45}; 568 569 EXPECT_ABORT_BEGIN 570 TEST_ASSERT_CHAR_ARRAY_WITHIN(11, expected, actualBigDelta, 0); 571 VERIFY_FAILS_END 572} 573 574void testCHARArrayWithinDeltaPointlessAndMessage(void) 575{ 576 char expected[] = {20, -95, 55}; 577 char actualBigDelta[] = {11, -86, 45}; 578 579 EXPECT_ABORT_BEGIN 580 TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 0, "Custom Message."); 581 VERIFY_FAILS_END 582} 583 584void testCHARArrayWithinDeltaExpectedNull(void) 585{ 586 char actualBigDelta[] = {11, -86, 45}; 587 588 EXPECT_ABORT_BEGIN 589 TEST_ASSERT_CHAR_ARRAY_WITHIN(11, NULL, actualBigDelta, 3); 590 VERIFY_FAILS_END 591} 592 593void testCHARArrayWithinDeltaExpectedNullAndMessage(void) 594{ 595 char actualBigDelta[] = {11, -86, 45}; 596 597 EXPECT_ABORT_BEGIN 598 TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(11, NULL, actualBigDelta, 3, "Custom Message."); 599 VERIFY_FAILS_END 600} 601 602void testCHARArrayWithinDeltaActualNull(void) 603{ 604 char expected[] = {20, -95, 55}; 605 606 EXPECT_ABORT_BEGIN 607 TEST_ASSERT_CHAR_ARRAY_WITHIN(11, expected, NULL, 3); 608 VERIFY_FAILS_END 609} 610 611void testCHARArrayWithinDeltaActualNullAndMessage(void) 612{ 613 char expected[] = {20, -95, 55}; 614 615 EXPECT_ABORT_BEGIN 616 TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(11, expected, NULL, 3, "Custom Message."); 617 VERIFY_FAILS_END 618} 619 620void testCHARArrayWithinDeltaSamePointer(void) 621{ 622 char expected[] = {20, -95, 55}; 623 624 TEST_ASSERT_CHAR_ARRAY_WITHIN(11, expected, expected, 3); 625} 626 627void testCHARArrayWithinDeltaSamePointerAndMessage(void) 628{ 629 char expected[] = {20, -95, 55}; 630 631 TEST_ASSERT_CHAR_ARRAY_WITHIN_MESSAGE(11, expected, expected, 3, "Custom Message."); 632} 633 634void testUInt64ArrayWithinDelta(void) 635{ 636#ifndef UNITY_SUPPORT_64 637 TEST_IGNORE(); 638#else 639 UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; 640 UNITY_UINT64 actualSmallDelta[] = {12345001, 12344996, 12345005}; 641 UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; 642 643 TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 644 TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, actualBigDelta, 3); 645#endif 646} 647 648void testUInt64ArrayWithinDeltaAndMessage(void) 649{ 650#ifndef UNITY_SUPPORT_64 651 TEST_IGNORE(); 652#else 653 UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; 654 UNITY_UINT64 actualSmallDelta[] = {12345001, 12344996, 12345005}; 655 UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; 656 657 TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 658 TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); 659#endif 660} 661 662void testUInt64ArrayNotWithinDelta(void) 663{ 664#ifndef UNITY_SUPPORT_64 665 TEST_IGNORE(); 666#else 667 UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; 668 UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; 669 670 EXPECT_ABORT_BEGIN 671 TEST_ASSERT_UINT64_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 672 VERIFY_FAILS_END 673#endif 674} 675 676void testUInt64ArrayNotWithinDeltaAndMessage(void) 677{ 678#ifndef UNITY_SUPPORT_64 679 TEST_IGNORE(); 680#else 681 UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; 682 UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; 683 684 EXPECT_ABORT_BEGIN 685 TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 686 VERIFY_FAILS_END 687#endif 688} 689 690void testUInt64ArrayWithinDeltaPointless(void) 691{ 692#ifndef UNITY_SUPPORT_64 693 TEST_IGNORE(); 694#else 695 UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; 696 UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; 697 698 EXPECT_ABORT_BEGIN 699 TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, actualBigDelta, 0); 700 VERIFY_FAILS_END 701#endif 702} 703 704void testUInt64ArrayWithinDeltaPointlessAndMessage(void) 705{ 706#ifndef UNITY_SUPPORT_64 707 TEST_IGNORE(); 708#else 709 UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; 710 UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; 711 712 EXPECT_ABORT_BEGIN 713 TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); 714 VERIFY_FAILS_END 715#endif 716} 717 718void testUInt64ArrayWithinDeltaExpectedNull(void) 719{ 720#ifndef UNITY_SUPPORT_64 721 TEST_IGNORE(); 722#else 723 UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; 724 725 EXPECT_ABORT_BEGIN 726 TEST_ASSERT_UINT64_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); 727 VERIFY_FAILS_END 728#endif 729} 730 731void testUInt64ArrayWithinDeltaExpectedNullAndMessage(void) 732{ 733#ifndef UNITY_SUPPORT_64 734 TEST_IGNORE(); 735#else 736 UNITY_UINT64 actualBigDelta[] = {12345101, 12344896, 12345055}; 737 738 EXPECT_ABORT_BEGIN 739 TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); 740 VERIFY_FAILS_END 741#endif 742} 743 744void testUInt64ArrayWithinDeltaActualNull(void) 745{ 746#ifndef UNITY_SUPPORT_64 747 TEST_IGNORE(); 748#else 749 UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; 750 751 EXPECT_ABORT_BEGIN 752 TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, NULL, 3); 753 VERIFY_FAILS_END 754#endif 755} 756 757void testUInt64ArrayWithinDeltaActualNullAndMessage(void) 758{ 759#ifndef UNITY_SUPPORT_64 760 TEST_IGNORE(); 761#else 762 UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; 763 764 EXPECT_ABORT_BEGIN 765 TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); 766 VERIFY_FAILS_END 767#endif 768} 769 770void testUInt64ArrayWithinDeltaSamePointer(void) 771{ 772#ifndef UNITY_SUPPORT_64 773 TEST_IGNORE(); 774#else 775 UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; 776 777 TEST_ASSERT_UINT64_ARRAY_WITHIN(110, expected, expected, 3); 778#endif 779} 780 781void testUInt64ArrayWithinDeltaSamePointerAndMessage(void) 782{ 783#ifndef UNITY_SUPPORT_64 784 TEST_IGNORE(); 785#else 786 UNITY_UINT64 expected[] = {12345000, 12344995, 12345005}; 787 788 TEST_ASSERT_UINT64_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); 789#endif 790} 791 792void testUIntArrayWithinDelta(void) 793{ 794 UNITY_UINT expected[] = {125000, 124995, 125005}; 795 UNITY_UINT actualSmallDelta[] = {125001, 124996, 125005}; 796 UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; 797 798 TEST_ASSERT_UINT_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 799 TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, actualBigDelta, 3); 800} 801 802void testUIntArrayWithinDeltaAndMessage(void) 803{ 804 UNITY_UINT expected[] = {125000, 124995, 125005}; 805 UNITY_UINT actualSmallDelta[] = {125001, 124996, 125005}; 806 UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; 807 808 TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 809 TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); 810} 811 812void testUIntArrayNotWithinDelta(void) 813{ 814 UNITY_UINT expected[] = {125000, 124995, 125005}; 815 UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; 816 817 EXPECT_ABORT_BEGIN 818 TEST_ASSERT_UINT_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 819 VERIFY_FAILS_END 820} 821 822void testUIntArrayNotWithinDeltaAndMessage(void) 823{ 824 UNITY_UINT expected[] = {125000, 124995, 125005}; 825 UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; 826 827 EXPECT_ABORT_BEGIN 828 TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 829 VERIFY_FAILS_END 830} 831 832void testUIntArrayWithinDeltaPointless(void) 833{ 834 UNITY_UINT expected[] = {125000, 124995, 125005}; 835 UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; 836 837 EXPECT_ABORT_BEGIN 838 TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, actualBigDelta, 0); 839 VERIFY_FAILS_END 840} 841 842void testUIntArrayWithinDeltaPointlessAndMessage(void) 843{ 844 UNITY_UINT expected[] = {125000, 124995, 125005}; 845 UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; 846 847 EXPECT_ABORT_BEGIN 848 TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); 849 VERIFY_FAILS_END 850} 851 852void testUIntArrayWithinDeltaExpectedNull(void) 853{ 854 UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; 855 856 EXPECT_ABORT_BEGIN 857 TEST_ASSERT_UINT_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); 858 VERIFY_FAILS_END 859} 860 861void testUIntArrayWithinDeltaExpectedNullAndMessage(void) 862{ 863 UNITY_UINT actualBigDelta[] = {125101, 124896, 125055}; 864 865 EXPECT_ABORT_BEGIN 866 TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); 867 VERIFY_FAILS_END 868} 869 870void testUIntArrayWithinDeltaActualNull(void) 871{ 872 UNITY_UINT expected[] = {125000, 124995, 125005}; 873 874 EXPECT_ABORT_BEGIN 875 TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, NULL, 3); 876 VERIFY_FAILS_END 877} 878 879void testUIntArrayWithinDeltaActualNullAndMessage(void) 880{ 881 UNITY_UINT expected[] = {125000, 124995, 125005}; 882 883 EXPECT_ABORT_BEGIN 884 TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); 885 VERIFY_FAILS_END 886} 887 888void testUIntArrayWithinDeltaSamePointer(void) 889{ 890 UNITY_UINT expected[] = {125000, 124995, 125005}; 891 892 TEST_ASSERT_UINT_ARRAY_WITHIN(110, expected, expected, 3); 893} 894 895void testUIntArrayWithinDeltaSamePointerAndMessage(void) 896{ 897 UNITY_UINT expected[] = {125000, 124995, 125005}; 898 899 TEST_ASSERT_UINT_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); 900} 901 902void testUInt16ArrayWithinDelta(void) 903{ 904 UNITY_UINT16 expected[] = {5000, 4995, 5005}; 905 UNITY_UINT16 actualSmallDelta[] = {5001, 4996, 5005}; 906 UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; 907 908 TEST_ASSERT_UINT16_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 909 TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, actualBigDelta, 3); 910} 911 912void testUInt16ArrayWithinDeltaAndMessage(void) 913{ 914 UNITY_UINT16 expected[] = {5000, 4995, 5005}; 915 UNITY_UINT16 actualSmallDelta[] = {5001, 4996, 5005}; 916 UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; 917 918 TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 919 TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); 920} 921 922void testUInt16ArrayNotWithinDelta(void) 923{ 924 UNITY_UINT16 expected[] = {5000, 4995, 5005}; 925 UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; 926 927 EXPECT_ABORT_BEGIN 928 TEST_ASSERT_UINT16_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 929 VERIFY_FAILS_END 930} 931 932void testUInt16ArrayNotWithinDeltaAndMessage(void) 933{ 934 UNITY_UINT16 expected[] = {5000, 4995, 5005}; 935 UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; 936 937 EXPECT_ABORT_BEGIN 938 TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 939 VERIFY_FAILS_END 940} 941 942void testUInt16ArrayWithinDeltaPointless(void) 943{ 944 UNITY_UINT16 expected[] = {5000, 4995, 5005}; 945 UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; 946 947 EXPECT_ABORT_BEGIN 948 TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, actualBigDelta, 0); 949 VERIFY_FAILS_END 950} 951 952void testUInt16ArrayWithinDeltaPointlessAndMessage(void) 953{ 954 UNITY_UINT16 expected[] = {5000, 4995, 5005}; 955 UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; 956 957 EXPECT_ABORT_BEGIN 958 TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); 959 VERIFY_FAILS_END 960} 961 962void testUInt16ArrayWithinDeltaExpectedNull(void) 963{ 964 UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; 965 966 EXPECT_ABORT_BEGIN 967 TEST_ASSERT_UINT16_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); 968 VERIFY_FAILS_END 969} 970 971void testUInt16ArrayWithinDeltaExpectedNullAndMessage(void) 972{ 973 UNITY_UINT16 actualBigDelta[] = {5101, 4896, 5055}; 974 975 EXPECT_ABORT_BEGIN 976 TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); 977 VERIFY_FAILS_END 978} 979 980void testUInt16ArrayWithinDeltaActualNull(void) 981{ 982 UNITY_UINT16 expected[] = {5000, 4995, 5005}; 983 984 EXPECT_ABORT_BEGIN 985 TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, NULL, 3); 986 VERIFY_FAILS_END 987} 988 989void testUInt16ArrayWithinDeltaActualNullAndMessage(void) 990{ 991 UNITY_UINT16 expected[] = {5000, 4995, 5005}; 992 993 EXPECT_ABORT_BEGIN 994 TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); 995 VERIFY_FAILS_END 996} 997 998void testUInt16ArrayWithinDeltaSamePointer(void) 999{ 1000 UNITY_UINT16 expected[] = {5000, 4995, 5005}; 1001 1002 TEST_ASSERT_UINT16_ARRAY_WITHIN(110, expected, expected, 3); 1003} 1004 1005void testUInt16ArrayWithinDeltaSamePointerAndMessage(void) 1006{ 1007 UNITY_UINT16 expected[] = {5000, 4995, 5005}; 1008 1009 TEST_ASSERT_UINT16_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); 1010} 1011 1012void testUInt8ArrayWithinDelta(void) 1013{ 1014 UNITY_UINT8 expected[] = {20, 95, 55}; 1015 UNITY_UINT8 actualSmallDelta[] = {21, 94, 55}; 1016 UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; 1017 1018 TEST_ASSERT_UINT8_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 1019 TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, actualBigDelta, 3); 1020} 1021 1022void testUInt8ArrayWithinDeltaAndMessage(void) 1023{ 1024 UNITY_UINT8 expected[] = {20, 95, 55}; 1025 UNITY_UINT8 actualSmallDelta[] = {21, 94, 55}; 1026 UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; 1027 1028 TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 1029 TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 3, "Custom Message."); 1030} 1031 1032void testUInt8ArrayNotWithinDelta(void) 1033{ 1034 UNITY_UINT8 expected[] = {20, 95, 55}; 1035 UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; 1036 1037 EXPECT_ABORT_BEGIN 1038 TEST_ASSERT_UINT8_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 1039 VERIFY_FAILS_END 1040} 1041 1042void testUInt8ArrayNotWithinDeltaAndMessage(void) 1043{ 1044 UNITY_UINT8 expected[] = {20, 95, 55}; 1045 UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; 1046 1047 EXPECT_ABORT_BEGIN 1048 TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 1049 VERIFY_FAILS_END 1050} 1051 1052void testUInt8ArrayWithinDeltaPointless(void) 1053{ 1054 UNITY_UINT8 expected[] = {20, 95, 55}; 1055 UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; 1056 1057 EXPECT_ABORT_BEGIN 1058 TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, actualBigDelta, 0); 1059 VERIFY_FAILS_END 1060} 1061 1062void testUInt8ArrayWithinDeltaPointlessAndMessage(void) 1063{ 1064 UNITY_UINT8 expected[] = {20, 95, 55}; 1065 UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; 1066 1067 EXPECT_ABORT_BEGIN 1068 TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, actualBigDelta, 0, "Custom Message."); 1069 VERIFY_FAILS_END 1070} 1071 1072void testUInt8ArrayWithinDeltaExpectedNull(void) 1073{ 1074 UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; 1075 1076 EXPECT_ABORT_BEGIN 1077 TEST_ASSERT_UINT8_ARRAY_WITHIN(11, NULL, actualBigDelta, 3); 1078 VERIFY_FAILS_END 1079} 1080 1081void testUInt8ArrayWithinDeltaExpectedNullAndMessage(void) 1082{ 1083 UNITY_UINT8 actualBigDelta[] = {11, 86, 45}; 1084 1085 EXPECT_ABORT_BEGIN 1086 TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, NULL, actualBigDelta, 3, "Custom Message."); 1087 VERIFY_FAILS_END 1088} 1089 1090void testUInt8ArrayWithinDeltaActualNull(void) 1091{ 1092 UNITY_UINT8 expected[] = {20, 95, 55}; 1093 1094 EXPECT_ABORT_BEGIN 1095 TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, NULL, 3); 1096 VERIFY_FAILS_END 1097} 1098 1099void testUInt8ArrayWithinDeltaActualNullAndMessage(void) 1100{ 1101 UNITY_UINT8 expected[] = {20, 95, 55}; 1102 1103 EXPECT_ABORT_BEGIN 1104 TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, NULL, 3, "Custom Message."); 1105 VERIFY_FAILS_END 1106} 1107 1108void testUInt8ArrayWithinDeltaSamePointer(void) 1109{ 1110 UNITY_UINT8 expected[] = {20, 95, 55}; 1111 1112 TEST_ASSERT_UINT8_ARRAY_WITHIN(11, expected, expected, 3); 1113} 1114 1115void testUInt8ArrayWithinDeltaSamePointerAndMessage(void) 1116{ 1117 UNITY_UINT8 expected[] = {20, 95, 55}; 1118 1119 TEST_ASSERT_UINT8_ARRAY_WITHIN_MESSAGE(11, expected, expected, 3, "Custom Message."); 1120} 1121 1122void testHEX64ArrayWithinDelta(void) 1123{ 1124#ifndef UNITY_SUPPORT_64 1125 TEST_IGNORE(); 1126#else 1127 UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; 1128 UNITY_UINT64 actualSmallDelta[] = {0xABCD123500000000, 0xABCD112100000000, 0xABCD127700000000}; 1129 UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; 1130 1131 TEST_ASSERT_HEX64_ARRAY_WITHIN(0x100000000, expected, actualSmallDelta, 3); 1132 TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, actualBigDelta, 3); 1133#endif 1134} 1135 1136void testHEX64ArrayWithinDeltaShouldNotHaveSignIssues(void) 1137{ 1138#ifndef UNITY_SUPPORT_64 1139 TEST_IGNORE(); 1140#else 1141 UNITY_UINT64 expected[] = {0x7FFFFFFFFFFFFFFF, 0x8000000000000000}; 1142 UNITY_UINT64 actualBigDelta[] = {0x8000000000000000, 0x7FFFFFFFFFFFFFFF}; 1143 1144 TEST_ASSERT_HEX64_ARRAY_WITHIN(1, expected, actualBigDelta, 2); 1145#endif 1146} 1147 1148void testHEX64ArrayWithinDeltaAndMessage(void) 1149{ 1150#ifndef UNITY_SUPPORT_64 1151 TEST_IGNORE(); 1152#else 1153 UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; 1154 UNITY_UINT64 actualSmallDelta[] = {0xABCD123500000000, 0xABCD112100000000, 0xABCD127700000000}; 1155 UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; 1156 1157 TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x100000000, expected, actualSmallDelta, 3, "Custom Message."); 1158 TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, actualBigDelta, 3, "Custom Message."); 1159#endif 1160} 1161 1162void testHEX64ArrayNotWithinDelta(void) 1163{ 1164#ifndef UNITY_SUPPORT_64 1165 TEST_IGNORE(); 1166#else 1167 UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; 1168 UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; 1169 1170 EXPECT_ABORT_BEGIN 1171 TEST_ASSERT_HEX64_ARRAY_WITHIN(0x100000000, expected, actualBigDelta, 3); 1172 VERIFY_FAILS_END 1173#endif 1174} 1175 1176void testHEX64ArrayNotWithinDeltaAndMessage(void) 1177{ 1178#ifndef UNITY_SUPPORT_64 1179 TEST_IGNORE(); 1180#else 1181 UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; 1182 UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; 1183 1184 EXPECT_ABORT_BEGIN 1185 TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x100000000, expected, actualBigDelta, 3, "Custom Message."); 1186 VERIFY_FAILS_END 1187#endif 1188} 1189 1190void testHEX64ArrayWithinDeltaPointless(void) 1191{ 1192#ifndef UNITY_SUPPORT_64 1193 TEST_IGNORE(); 1194#else 1195 UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; 1196 UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; 1197 1198 EXPECT_ABORT_BEGIN 1199 TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, actualBigDelta, 0); 1200 VERIFY_FAILS_END 1201#endif 1202} 1203 1204void testHEX64ArrayWithinDeltaPointlessAndMessage(void) 1205{ 1206#ifndef UNITY_SUPPORT_64 1207 TEST_IGNORE(); 1208#else 1209 UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; 1210 UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; 1211 1212 EXPECT_ABORT_BEGIN 1213 TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, actualBigDelta, 0, "Custom Message."); 1214 VERIFY_FAILS_END 1215#endif 1216} 1217 1218void testHEX64ArrayWithinDeltaExpectedNull(void) 1219{ 1220#ifndef UNITY_SUPPORT_64 1221 TEST_IGNORE(); 1222#else 1223 UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; 1224 1225 EXPECT_ABORT_BEGIN 1226 TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, NULL, actualBigDelta, 3); 1227 VERIFY_FAILS_END 1228#endif 1229} 1230 1231void testHEX64ArrayWithinDeltaExpectedNullAndMessage(void) 1232{ 1233#ifndef UNITY_SUPPORT_64 1234 TEST_IGNORE(); 1235#else 1236 UNITY_UINT64 actualBigDelta[] = {0xABCD126700000000, 0xABCD118800000000, 0xABCD12AC00000000}; 1237 1238 EXPECT_ABORT_BEGIN 1239 TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, NULL, actualBigDelta, 3, "Custom Message."); 1240 VERIFY_FAILS_END 1241#endif 1242} 1243 1244void testHEX64ArrayWithinDeltaActualNull(void) 1245{ 1246#ifndef UNITY_SUPPORT_64 1247 TEST_IGNORE(); 1248#else 1249 UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; 1250 1251 EXPECT_ABORT_BEGIN 1252 TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, NULL, 3); 1253 VERIFY_FAILS_END 1254#endif 1255} 1256 1257void testHEX64ArrayWithinDeltaActualNullAndMessage(void) 1258{ 1259#ifndef UNITY_SUPPORT_64 1260 TEST_IGNORE(); 1261#else 1262 UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; 1263 1264 EXPECT_ABORT_BEGIN 1265 TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, NULL, 3, "Custom Message."); 1266 VERIFY_FAILS_END 1267#endif 1268} 1269 1270void testHEX64ArrayWithinDeltaSamePointer(void) 1271{ 1272#ifndef UNITY_SUPPORT_64 1273 TEST_IGNORE(); 1274#else 1275 UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; 1276 1277 TEST_ASSERT_HEX64_ARRAY_WITHIN(0x6E00000000, expected, expected, 3); 1278#endif 1279} 1280 1281void testHEX64ArrayWithinDeltaSamePointerAndMessage(void) 1282{ 1283#ifndef UNITY_SUPPORT_64 1284 TEST_IGNORE(); 1285#else 1286 UNITY_UINT64 expected[] = {0xABCD123400000000, 0xABCD112200000000, 0xABCD127700000000}; 1287 1288 TEST_ASSERT_HEX64_ARRAY_WITHIN_MESSAGE(0x6E00000000, expected, expected, 3, "Custom Message."); 1289#endif 1290} 1291 1292void testHEX32ArrayWithinDelta(void) 1293{ 1294 UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; 1295 UNITY_UINT actualSmallDelta[] = {0xABCD1235, 0xABCD1121, 0xABCD1277}; 1296 UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; 1297 1298 TEST_ASSERT_HEX32_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 1299 TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, actualBigDelta, 3); 1300} 1301 1302void testHEX32ArrayWithinDeltaShouldNotHaveSignIssues(void) 1303{ 1304 UNITY_UINT32 expected[] = {0x7FFFFFFF, 0x80000000}; 1305 UNITY_UINT32 actualBigDelta[] = {0x80000000, 0x7FFFFFFF}; 1306 1307 TEST_ASSERT_HEX32_ARRAY_WITHIN(1, expected, actualBigDelta, 2); 1308} 1309 1310void testHEX32ArrayWithinDeltaAndMessage(void) 1311{ 1312 UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; 1313 UNITY_UINT actualSmallDelta[] = {0xABCD1235, 0xABCD1121, 0xABCD1277}; 1314 UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; 1315 1316 TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 1317 TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); 1318} 1319 1320void testHEX32ArrayNotWithinDelta(void) 1321{ 1322 UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; 1323 UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; 1324 1325 EXPECT_ABORT_BEGIN 1326 TEST_ASSERT_HEX32_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 1327 VERIFY_FAILS_END 1328} 1329 1330void testHEX32ArrayNotWithinDeltaAndMessage(void) 1331{ 1332 UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; 1333 UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; 1334 1335 EXPECT_ABORT_BEGIN 1336 TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 1337 VERIFY_FAILS_END 1338} 1339 1340void testHEX32ArrayWithinDeltaPointless(void) 1341{ 1342 UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; 1343 UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; 1344 1345 EXPECT_ABORT_BEGIN 1346 TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, actualBigDelta, 0); 1347 VERIFY_FAILS_END 1348} 1349 1350void testHEX32ArrayWithinDeltaPointlessAndMessage(void) 1351{ 1352 UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; 1353 UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; 1354 1355 EXPECT_ABORT_BEGIN 1356 TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); 1357 VERIFY_FAILS_END 1358} 1359 1360void testHEX32ArrayWithinDeltaExpectedNull(void) 1361{ 1362 UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; 1363 1364 EXPECT_ABORT_BEGIN 1365 TEST_ASSERT_HEX32_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); 1366 VERIFY_FAILS_END 1367} 1368 1369void testHEX32ArrayWithinDeltaExpectedNullAndMessage(void) 1370{ 1371 UNITY_UINT actualBigDelta[] = {0xABCD1267, 0xABCD1188, 0xABCD12AC}; 1372 1373 EXPECT_ABORT_BEGIN 1374 TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); 1375 VERIFY_FAILS_END 1376} 1377 1378void testHEX32ArrayWithinDeltaActualNull(void) 1379{ 1380 UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; 1381 1382 EXPECT_ABORT_BEGIN 1383 TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, NULL, 3); 1384 VERIFY_FAILS_END 1385} 1386 1387void testHEX32ArrayWithinDeltaActualNullAndMessage(void) 1388{ 1389 UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; 1390 1391 EXPECT_ABORT_BEGIN 1392 TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); 1393 VERIFY_FAILS_END 1394} 1395 1396void testHEX32ArrayWithinDeltaSamePointer(void) 1397{ 1398 UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; 1399 1400 TEST_ASSERT_HEX32_ARRAY_WITHIN(110, expected, expected, 3); 1401} 1402 1403void testHEX32ArrayWithinDeltaSamePointerAndMessage(void) 1404{ 1405 UNITY_UINT expected[] = {0xABCD1234, 0xABCD1122, 0xABCD1277}; 1406 1407 TEST_ASSERT_HEX32_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); 1408} 1409 1410 1411void testHEX16ArrayWithinDelta(void) 1412{ 1413 UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; 1414 UNITY_UINT16 actualSmallDelta[] = {0x1235, 0x1121, 0x1277}; 1415 UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; 1416 1417 TEST_ASSERT_HEX16_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 1418 TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, actualBigDelta, 3); 1419} 1420 1421void testHEX16ArrayWithinDeltaShouldNotHaveSignIssues(void) 1422{ 1423 UNITY_UINT16 expected[] = {0x7FFF, 0x8000}; 1424 UNITY_UINT16 actualBigDelta[] = {0x8000, 0x7FFF}; 1425 1426 TEST_ASSERT_HEX16_ARRAY_WITHIN(1, expected, actualBigDelta, 2); 1427} 1428 1429void testHEX16ArrayWithinDeltaAndMessage(void) 1430{ 1431 UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; 1432 UNITY_UINT16 actualSmallDelta[] = {0x1235, 0x1121, 0x1277}; 1433 UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; 1434 1435 TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 1436 TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 3, "Custom Message."); 1437} 1438 1439void testHEX16ArrayNotWithinDelta(void) 1440{ 1441 UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; 1442 UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; 1443 1444 EXPECT_ABORT_BEGIN 1445 TEST_ASSERT_HEX16_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 1446 VERIFY_FAILS_END 1447} 1448 1449void testHEX16ArrayNotWithinDeltaAndMessage(void) 1450{ 1451 UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; 1452 UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; 1453 1454 EXPECT_ABORT_BEGIN 1455 TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 1456 VERIFY_FAILS_END 1457} 1458 1459void testHEX16ArrayWithinDeltaPointless(void) 1460{ 1461 UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; 1462 UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; 1463 1464 EXPECT_ABORT_BEGIN 1465 TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, actualBigDelta, 0); 1466 VERIFY_FAILS_END 1467} 1468 1469void testHEX16ArrayWithinDeltaPointlessAndMessage(void) 1470{ 1471 UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; 1472 UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; 1473 1474 EXPECT_ABORT_BEGIN 1475 TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, actualBigDelta, 0, "Custom Message."); 1476 VERIFY_FAILS_END 1477} 1478 1479void testHEX16ArrayWithinDeltaExpectedNull(void) 1480{ 1481 UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; 1482 1483 EXPECT_ABORT_BEGIN 1484 TEST_ASSERT_HEX16_ARRAY_WITHIN(110, NULL, actualBigDelta, 3); 1485 VERIFY_FAILS_END 1486} 1487 1488void testHEX16ArrayWithinDeltaExpectedNullAndMessage(void) 1489{ 1490 UNITY_UINT16 actualBigDelta[] = {0x1267, 0x1188, 0x12AC}; 1491 1492 EXPECT_ABORT_BEGIN 1493 TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, NULL, actualBigDelta, 3, "Custom Message."); 1494 VERIFY_FAILS_END 1495} 1496 1497void testHEX16ArrayWithinDeltaActualNull(void) 1498{ 1499 UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; 1500 1501 EXPECT_ABORT_BEGIN 1502 TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, NULL, 3); 1503 VERIFY_FAILS_END 1504} 1505 1506void testHEX16ArrayWithinDeltaActualNullAndMessage(void) 1507{ 1508 UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; 1509 1510 EXPECT_ABORT_BEGIN 1511 TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, NULL, 3, "Custom Message."); 1512 VERIFY_FAILS_END 1513} 1514 1515void testHEX16ArrayWithinDeltaSamePointer(void) 1516{ 1517 UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; 1518 1519 TEST_ASSERT_HEX16_ARRAY_WITHIN(110, expected, expected, 3); 1520} 1521 1522void testHEX16ArrayWithinDeltaSamePointerAndMessage(void) 1523{ 1524 UNITY_UINT16 expected[] = {0x1234, 0x1122, 0x1277}; 1525 1526 TEST_ASSERT_HEX16_ARRAY_WITHIN_MESSAGE(110, expected, expected, 3, "Custom Message."); 1527} 1528 1529void testHEX8ArrayWithinDelta(void) 1530{ 1531 UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; 1532 UNITY_UINT8 actualSmallDelta[] = {0x35, 0x21, 0x77}; 1533 UNITY_UINT8 actualBigDelta[] = {0x47, 0x48, 0x4C}; 1534 1535 TEST_ASSERT_HEX8_ARRAY_WITHIN(1, expected, actualSmallDelta, 3); 1536 TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, actualBigDelta, 3); 1537} 1538 1539void testHEX8ArrayWithinDeltaAndMessage(void) 1540{ 1541 UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; 1542 UNITY_UINT8 actualSmallDelta[] = {0x35, 0x21, 0x77}; 1543 UNITY_UINT8 actualBigDelta[] = {0x47, 0x48, 0x4C}; 1544 1545 TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(1, expected, actualSmallDelta, 3, "Custom Message."); 1546 TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, actualBigDelta, 3, "Custom Message."); 1547} 1548 1549void testHEX8ArrayNotWithinDelta(void) 1550{ 1551 UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; 1552 UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; 1553 1554 EXPECT_ABORT_BEGIN 1555 TEST_ASSERT_HEX8_ARRAY_WITHIN(1, expected, actualBigDelta, 3); 1556 VERIFY_FAILS_END 1557} 1558 1559void testHEX8ArrayWithinDeltaShouldNotHaveSignIssues(void) 1560{ 1561 UNITY_UINT8 expected[] = {0x7F, 0x80}; 1562 UNITY_UINT8 actualBigDelta[] = {0x80, 0x7F}; 1563 1564 TEST_ASSERT_HEX8_ARRAY_WITHIN(1, expected, actualBigDelta, 2); 1565} 1566 1567void testHEX8ArrayNotWithinDeltaAndMessage(void) 1568{ 1569 UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; 1570 UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; 1571 1572 EXPECT_ABORT_BEGIN 1573 TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(1, expected, actualBigDelta, 3, "Custom Message."); 1574 VERIFY_FAILS_END 1575} 1576 1577void testHEX8ArrayWithinDeltaPointless(void) 1578{ 1579 UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; 1580 UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; 1581 1582 EXPECT_ABORT_BEGIN 1583 TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, actualBigDelta, 0); 1584 VERIFY_FAILS_END 1585} 1586 1587void testHEX8ArrayWithinDeltaPointlessAndMessage(void) 1588{ 1589 UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; 1590 UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; 1591 1592 EXPECT_ABORT_BEGIN 1593 TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, actualBigDelta, 0, "Custom Message."); 1594 VERIFY_FAILS_END 1595} 1596 1597void testHEX8ArrayWithinDeltaExpectedNull(void) 1598{ 1599 UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; 1600 1601 EXPECT_ABORT_BEGIN 1602 TEST_ASSERT_HEX8_ARRAY_WITHIN(60, NULL, actualBigDelta, 3); 1603 VERIFY_FAILS_END 1604} 1605 1606void testHEX8ArrayWithinDeltaExpectedNullAndMessage(void) 1607{ 1608 UNITY_UINT8 actualBigDelta[] = {0x67, 0x88, 0xAC}; 1609 1610 EXPECT_ABORT_BEGIN 1611 TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, NULL, actualBigDelta, 3, "Custom Message."); 1612 VERIFY_FAILS_END 1613} 1614 1615void testHEX8ArrayWithinDeltaActualNull(void) 1616{ 1617 UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; 1618 1619 EXPECT_ABORT_BEGIN 1620 TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, NULL, 3); 1621 VERIFY_FAILS_END 1622} 1623 1624void testHEX8ArrayWithinDeltaActualNullAndMessage(void) 1625{ 1626 UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; 1627 1628 EXPECT_ABORT_BEGIN 1629 TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, NULL, 3, "Custom Message."); 1630 VERIFY_FAILS_END 1631} 1632 1633void testHEX8ArrayWithinDeltaSamePointer(void) 1634{ 1635 UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; 1636 1637 TEST_ASSERT_HEX8_ARRAY_WITHIN(60, expected, expected, 3); 1638} 1639 1640void testHEX8ArrayWithinDeltaSamePointerAndMessage(void) 1641{ 1642 UNITY_UINT8 expected[] = {0x34, 0x22, 0x77}; 1643 1644 TEST_ASSERT_HEX8_ARRAY_WITHIN_MESSAGE(60, expected, expected, 3, "Custom Message."); 1645} 1646 1647void testEqualIntArrays(void) 1648{ 1649 int p0[] = {1, 8, 987, -2}; 1650 int p1[] = {1, 8, 987, -2}; 1651 int p2[] = {1, 8, 987, 2}; 1652 int p3[] = {1, 500, 600, 700}; 1653 1654 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 1); 1655 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 4); 1656 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 1657 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p2, 3); 1658 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p3, 1); 1659 TEST_ASSERT_EQUAL_INT_ARRAY(NULL, NULL, 1); 1660} 1661 1662void testNotEqualIntArraysNullExpected(void) 1663{ 1664 int* p0 = NULL; 1665 int p1[] = {1, 8, 987, 2}; 1666 1667 EXPECT_ABORT_BEGIN 1668 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 1669 VERIFY_FAILS_END 1670} 1671 1672void testNotEqualIntArraysNullActual(void) 1673{ 1674 int* p1 = NULL; 1675 int p0[] = {1, 8, 987, 2}; 1676 1677 EXPECT_ABORT_BEGIN 1678 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 1679 VERIFY_FAILS_END 1680} 1681 1682void testNotEqualIntArrays1(void) 1683{ 1684 int p0[] = {1, 8, 987, -2}; 1685 int p1[] = {1, 8, 987, 2}; 1686 1687 EXPECT_ABORT_BEGIN 1688 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 1689 VERIFY_FAILS_END 1690} 1691 1692void testNotEqualIntArrays2(void) 1693{ 1694 int p0[] = {1, 8, 987, -2}; 1695 int p1[] = {2, 8, 987, -2}; 1696 1697 EXPECT_ABORT_BEGIN 1698 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 1699 VERIFY_FAILS_END 1700} 1701 1702void testNotEqualIntArrays3(void) 1703{ 1704 int p0[] = {1, 8, 987, -2}; 1705 int p1[] = {1, 8, 986, -2}; 1706 1707 EXPECT_ABORT_BEGIN 1708 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 1709 VERIFY_FAILS_END 1710} 1711 1712void testNotEqualIntArraysLengthZero(void) 1713{ 1714 UNITY_UINT32 p0[1] = {1}; 1715 UNITY_UINT32 p1[1] = {1}; 1716 1717 EXPECT_ABORT_BEGIN 1718 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 0); 1719 VERIFY_FAILS_END 1720} 1721 1722void testEqualIntEachEqual(void) 1723{ 1724 int p0[] = {1, 1, 1, 1}; 1725 int p1[] = {987, 987, 987, 987}; 1726 int p2[] = {-2, -2, -2, -3}; 1727 int p3[] = {1, 5, 600, 700}; 1728 1729 TEST_ASSERT_EACH_EQUAL_INT(1, p0, 1); 1730 TEST_ASSERT_EACH_EQUAL_INT(1, p0, 4); 1731 TEST_ASSERT_EACH_EQUAL_INT(987, p1, 4); 1732 TEST_ASSERT_EACH_EQUAL_INT(-2, p2, 3); 1733 TEST_ASSERT_EACH_EQUAL_INT(1, p3, 1); 1734} 1735 1736void testNotEqualIntEachEqualNullActual(void) 1737{ 1738 int* p1 = NULL; 1739 1740 EXPECT_ABORT_BEGIN 1741 TEST_ASSERT_EACH_EQUAL_INT(1, p1, 4); 1742 VERIFY_FAILS_END 1743} 1744 1745void testNotEqualIntEachEqual1(void) 1746{ 1747 int p0[] = {1, 1, 1, -2}; 1748 1749 EXPECT_ABORT_BEGIN 1750 TEST_ASSERT_EACH_EQUAL_INT(1, p0, 4); 1751 VERIFY_FAILS_END 1752} 1753 1754void testNotEqualIntEachEqual2(void) 1755{ 1756 int p0[] = {-5, -5, -1, -5}; 1757 1758 EXPECT_ABORT_BEGIN 1759 TEST_ASSERT_EACH_EQUAL_INT(-5, p0, 4); 1760 VERIFY_FAILS_END 1761} 1762 1763void testNotEqualIntEachEqual3(void) 1764{ 1765 int p0[] = {1, 88, 88, 88}; 1766 1767 EXPECT_ABORT_BEGIN 1768 TEST_ASSERT_EACH_EQUAL_INT(88, p0, 4); 1769 VERIFY_FAILS_END 1770} 1771 1772void testNotEqualEachEqualLengthZero(void) 1773{ 1774 UNITY_UINT32 p0[1] = {1}; 1775 1776 EXPECT_ABORT_BEGIN 1777 TEST_ASSERT_EACH_EQUAL_INT(0, p0, 0); 1778 VERIFY_FAILS_END 1779} 1780 1781void testEqualPtrArrays(void) 1782{ 1783 char A = 1; 1784 char B = 2; 1785 char C = 3; 1786 char* p0[] = {&A, &B, &C}; 1787 char* p1[] = {&A, &B, &C, &A}; 1788 char* p2[] = {&A, &B}; 1789 char* p3[] = {&A}; 1790 1791 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 1); 1792 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 3); 1793 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 3); 1794 TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p2, 2); 1795 TEST_ASSERT_EQUAL_PTR_ARRAY(p3, p0, 1); 1796} 1797 1798void testNotEqualPtrArraysNullExpected(void) 1799{ 1800 char A = 1; 1801 char B = 2; 1802 char** p0 = NULL; 1803 char* p1[] = {&A, &B}; 1804 1805 EXPECT_ABORT_BEGIN 1806 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 2); 1807 VERIFY_FAILS_END 1808} 1809 1810void testNotEqualPtrArraysNullActual(void) 1811{ 1812 char A = 1; 1813 char B = 2; 1814 char** p0 = NULL; 1815 char* p1[] = {&A, &B}; 1816 1817 EXPECT_ABORT_BEGIN 1818 TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p0, 2); 1819 VERIFY_FAILS_END 1820} 1821 1822void testNotEqualPtrArrays1(void) 1823{ 1824 char A = 1; 1825 char B = 2; 1826 char C = 3; 1827 char* p0[] = {&A, &B, &C, &B}; 1828 char* p1[] = {&A, &B, &C, &A}; 1829 1830 EXPECT_ABORT_BEGIN 1831 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); 1832 VERIFY_FAILS_END 1833} 1834 1835void testNotEqualPtrArrays2(void) 1836{ 1837 char A = 1; 1838 char B = 2; 1839 char C = 3; 1840 char* p0[] = {&B, &B, &C, &A}; 1841 char* p1[] = {&A, &B, &C, &A}; 1842 1843 EXPECT_ABORT_BEGIN 1844 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); 1845 VERIFY_FAILS_END 1846} 1847 1848void testNotEqualPtrArrays3(void) 1849{ 1850 char A = 1; 1851 char B = 2; 1852 char C = 3; 1853 char* p0[] = {&A, &B, &B, &A}; 1854 char* p1[] = {&A, &B, &C, &A}; 1855 1856 EXPECT_ABORT_BEGIN 1857 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); 1858 VERIFY_FAILS_END 1859} 1860 1861void testEqualPtrEachEqual(void) 1862{ 1863 char A = 1; 1864 char B = 2; 1865 char C = 3; 1866 char* p0[] = {&A, &A, &A}; 1867 char* p1[] = {&A, &B, &C, &A}; 1868 char* p2[] = {&B, &B}; 1869 char* p3[] = {&C}; 1870 1871 TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 1); 1872 TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 3); 1873 TEST_ASSERT_EACH_EQUAL_PTR(&A, p1, 1); 1874 TEST_ASSERT_EACH_EQUAL_PTR(&B, p2, 2); 1875 TEST_ASSERT_EACH_EQUAL_PTR(&C, p3, 1); 1876} 1877 1878void testNotEqualPtrEachEqualNullExpected(void) 1879{ 1880 char A = 1; 1881 char B = 1; 1882 char* p0[] = {&A, &B}; 1883 1884 EXPECT_ABORT_BEGIN 1885 TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 2); 1886 VERIFY_FAILS_END 1887} 1888 1889void testNotEqualPtrEachEqualNullActual(void) 1890{ 1891 char A = 1; 1892 char** p0 = NULL; 1893 1894 EXPECT_ABORT_BEGIN 1895 TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 2); 1896 VERIFY_FAILS_END 1897} 1898 1899void testNotEqualPtrEachEqual1(void) 1900{ 1901 char A = 1; 1902 char B = 1; 1903 char* p0[] = {&A, &A, &A, &B}; 1904 1905 EXPECT_ABORT_BEGIN 1906 TEST_ASSERT_EACH_EQUAL_PTR(&A, p0, 4); 1907 VERIFY_FAILS_END 1908} 1909 1910void testNotEqualPtrEachEqual2(void) 1911{ 1912 char A = 1; 1913 char B = 1; 1914 char* p0[] = {&B, &B, &A, &B}; 1915 1916 EXPECT_ABORT_BEGIN 1917 TEST_ASSERT_EACH_EQUAL_PTR(&B, p0, 4); 1918 VERIFY_FAILS_END 1919} 1920 1921void testNotEqualPtrEachEqual3(void) 1922{ 1923 char A = 1; 1924 char B = 1; 1925 char* p0[] = {&A, &B, &B, &B}; 1926 1927 EXPECT_ABORT_BEGIN 1928 TEST_ASSERT_EACH_EQUAL_PTR(&B, p0, 4); 1929 VERIFY_FAILS_END 1930} 1931 1932void testEqualInt8Arrays(void) 1933{ 1934 UNITY_INT8 p0[] = {1, 8, 117, -2}; 1935 UNITY_INT8 p1[] = {1, 8, 117, -2}; 1936 UNITY_INT8 p2[] = {1, 8, 117, 2}; 1937 UNITY_INT8 p3[] = {1, 50, 60, 70}; 1938 1939 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 1); 1940 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 4); 1941 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4); 1942 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p2, 3); 1943 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p3, 1); 1944} 1945 1946void testNotEqualInt8Arrays(void) 1947{ 1948 UNITY_INT8 p0[] = {1, 8, 36, -2}; 1949 UNITY_INT8 p1[] = {1, 8, 36, 2}; 1950 1951 EXPECT_ABORT_BEGIN 1952 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4); 1953 VERIFY_FAILS_END 1954} 1955 1956void testEqualInt8EachEqual(void) 1957{ 1958 UNITY_INT8 p0[] = {1, 1, 1, 1}; 1959 UNITY_INT8 p1[] = {117, 117, 117, -2}; 1960 UNITY_INT8 p2[] = {-1, -1, 117, 2}; 1961 UNITY_INT8 p3[] = {1, 50, 60, 70}; 1962 1963 TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 1); 1964 TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 4); 1965 TEST_ASSERT_EACH_EQUAL_INT8(117, p1, 3); 1966 TEST_ASSERT_EACH_EQUAL_INT8(-1, p2, 2); 1967 TEST_ASSERT_EACH_EQUAL_INT8(1, p3, 1); 1968} 1969 1970void testNotEqualInt8EachEqual(void) 1971{ 1972 UNITY_INT8 p0[] = {1, 8, 36, -2}; 1973 1974 EXPECT_ABORT_BEGIN 1975 TEST_ASSERT_EACH_EQUAL_INT8(1, p0, 2); 1976 VERIFY_FAILS_END 1977} 1978 1979void testEqualCHARArrays(void) 1980{ 1981 char p0[] = {1, 8, 117, -2}; 1982 char p1[] = {1, 8, 117, -2}; 1983 char p2[] = {1, 8, 117, 2}; 1984 char p3[] = {1, 50, 60, 70}; 1985 1986 TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p0, 1); 1987 TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p0, 4); 1988 TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p1, 4); 1989 TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p2, 3); 1990 TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p3, 1); 1991} 1992 1993void testNotEqualCHARArrays(void) 1994{ 1995 char p0[] = {1, 8, 36, -2}; 1996 char p1[] = {1, 8, 36, 2}; 1997 1998 EXPECT_ABORT_BEGIN 1999 TEST_ASSERT_EQUAL_CHAR_ARRAY(p0, p1, 4); 2000 VERIFY_FAILS_END 2001} 2002 2003void testEqualCHAREachEqual(void) 2004{ 2005 char p0[] = {1, 1, 1, 1}; 2006 char p1[] = {117, 117, 117, -2}; 2007 char p2[] = {-1, -1, 117, 2}; 2008 char p3[] = {1, 50, 60, 70}; 2009 2010 TEST_ASSERT_EACH_EQUAL_CHAR(1, p0, 1); 2011 TEST_ASSERT_EACH_EQUAL_CHAR(1, p0, 4); 2012 TEST_ASSERT_EACH_EQUAL_CHAR(117, p1, 3); 2013 TEST_ASSERT_EACH_EQUAL_CHAR(-1, p2, 2); 2014 TEST_ASSERT_EACH_EQUAL_CHAR(1, p3, 1); 2015} 2016 2017void testNotEqualCHAREachEqual(void) 2018{ 2019 char p0[] = {1, 8, 36, -2}; 2020 2021 EXPECT_ABORT_BEGIN 2022 TEST_ASSERT_EACH_EQUAL_CHAR(1, p0, 2); 2023 VERIFY_FAILS_END 2024} 2025 2026void testEqualUIntArrays(void) 2027{ 2028 unsigned int p0[] = {1, 8, 987, 65132u}; 2029 unsigned int p1[] = {1, 8, 987, 65132u}; 2030 unsigned int p2[] = {1, 8, 987, 2}; 2031 unsigned int p3[] = {1, 500, 600, 700}; 2032 2033 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 1); 2034 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 4); 2035 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); 2036 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p2, 3); 2037 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p3, 1); 2038} 2039 2040void testNotEqualUIntArrays1(void) 2041{ 2042 unsigned int p0[] = {1, 8, 987, 65132u}; 2043 unsigned int p1[] = {1, 8, 987, 65131u}; 2044 2045 EXPECT_ABORT_BEGIN 2046 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); 2047 VERIFY_FAILS_END 2048} 2049 2050void testNotEqualUIntArrays2(void) 2051{ 2052 unsigned int p0[] = {1, 8, 987, 65132u}; 2053 unsigned int p1[] = {2, 8, 987, 65132u}; 2054 2055 EXPECT_ABORT_BEGIN 2056 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); 2057 VERIFY_FAILS_END 2058} 2059 2060void testNotEqualUIntArrays3(void) 2061{ 2062 unsigned int p0[] = {1, 8, 987, 65132u}; 2063 unsigned int p1[] = {1, 8, 986, 65132u}; 2064 2065 EXPECT_ABORT_BEGIN 2066 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); 2067 VERIFY_FAILS_END 2068} 2069 2070void testEqualUIntEachEqual(void) 2071{ 2072 unsigned int p0[] = {1, 1, 1, 1}; 2073 unsigned int p1[] = {65132u, 65132u, 65132u, 65132u}; 2074 unsigned int p2[] = {8, 8, 987, 2}; 2075 unsigned int p3[] = {1, 500, 600, 700}; 2076 2077 TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 1); 2078 TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 4); 2079 TEST_ASSERT_EACH_EQUAL_UINT(65132u, p1, 4); 2080 TEST_ASSERT_EACH_EQUAL_UINT(8, p2, 2); 2081 TEST_ASSERT_EACH_EQUAL_UINT(1, p3, 1); 2082} 2083 2084void testNotEqualUIntEachEqual1(void) 2085{ 2086 unsigned int p0[] = {1, 65132u, 65132u, 65132u}; 2087 2088 EXPECT_ABORT_BEGIN 2089 TEST_ASSERT_EACH_EQUAL_UINT(65132u, p0, 4); 2090 VERIFY_FAILS_END 2091} 2092 2093void testNotEqualUIntEachEqual2(void) 2094{ 2095 unsigned int p0[] = {987, 8, 987, 987}; 2096 2097 EXPECT_ABORT_BEGIN 2098 TEST_ASSERT_EACH_EQUAL_UINT(987, p0, 4); 2099 VERIFY_FAILS_END 2100} 2101 2102void testNotEqualUIntEachEqual3(void) 2103{ 2104 unsigned int p0[] = {1, 1, 1, 65132u}; 2105 2106 EXPECT_ABORT_BEGIN 2107 TEST_ASSERT_EACH_EQUAL_UINT(1, p0, 4); 2108 VERIFY_FAILS_END 2109} 2110 2111void testEqualInt16Arrays(void) 2112{ 2113 UNITY_INT16 p0[] = {1, 8, 117, 3}; 2114 UNITY_INT16 p1[] = {1, 8, 117, 3}; 2115 UNITY_INT16 p2[] = {1, 8, 117, 2}; 2116 UNITY_INT16 p3[] = {1, 50, 60, 70}; 2117 2118 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 1); 2119 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 4); 2120 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4); 2121 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p2, 3); 2122 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p3, 1); 2123} 2124 2125void testNotEqualInt16Arrays(void) 2126{ 2127 UNITY_INT16 p0[] = {1, 8, 127, 3}; 2128 UNITY_INT16 p1[] = {1, 8, 127, 2}; 2129 2130 EXPECT_ABORT_BEGIN 2131 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4); 2132 VERIFY_FAILS_END 2133} 2134 2135void testEqualInt16EachEqual(void) 2136{ 2137 UNITY_INT16 p0[] = {1, 1, 1, 1}; 2138 UNITY_INT16 p1[] = {32111, 32111, 32111, 3}; 2139 UNITY_INT16 p2[] = {-1, -1, -1, 2}; 2140 UNITY_INT16 p3[] = {1, 50, 60, 70}; 2141 2142 TEST_ASSERT_EACH_EQUAL_INT16(1, p0, 1); 2143 TEST_ASSERT_EACH_EQUAL_INT16(1, p0, 4); 2144 TEST_ASSERT_EACH_EQUAL_INT16(32111, p1, 3); 2145 TEST_ASSERT_EACH_EQUAL_INT16(-1, p2, 3); 2146 TEST_ASSERT_EACH_EQUAL_INT16(1, p3, 1); 2147} 2148 2149void testNotEqualInt16EachEqual(void) 2150{ 2151 UNITY_INT16 p0[] = {127, 127, 127, 3}; 2152 2153 EXPECT_ABORT_BEGIN 2154 TEST_ASSERT_EACH_EQUAL_INT16(127, p0, 4); 2155 VERIFY_FAILS_END 2156} 2157 2158void testEqualInt32Arrays(void) 2159{ 2160 UNITY_INT32 p0[] = {1, 8, 117, 3}; 2161 UNITY_INT32 p1[] = {1, 8, 117, 3}; 2162 UNITY_INT32 p2[] = {1, 8, 117, 2}; 2163 UNITY_INT32 p3[] = {1, 50, 60, 70}; 2164 2165 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 1); 2166 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 4); 2167 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4); 2168 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p2, 3); 2169 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p3, 1); 2170} 2171 2172void testNotEqualInt32Arrays(void) 2173{ 2174 UNITY_INT32 p0[] = {1, 8, 127, 3}; 2175 UNITY_INT32 p1[] = {1, 8, 127, 2}; 2176 2177 EXPECT_ABORT_BEGIN 2178 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4); 2179 VERIFY_FAILS_END 2180} 2181 2182void testEqualInt32EachEqual(void) 2183{ 2184 UNITY_INT32 p0[] = {8, 8, 8, 8}; 2185 UNITY_INT32 p1[] = {65537, 65537, 65537, 65537}; 2186 UNITY_INT32 p2[] = {-3, -3, -3, 2}; 2187 UNITY_INT32 p3[] = {1, 50, 60, 70}; 2188 2189 TEST_ASSERT_EACH_EQUAL_INT32(8, p0, 1); 2190 TEST_ASSERT_EACH_EQUAL_INT32(8, p0, 4); 2191 TEST_ASSERT_EACH_EQUAL_INT32(65537, p1, 4); 2192 TEST_ASSERT_EACH_EQUAL_INT32(-3, p2, 3); 2193 TEST_ASSERT_EACH_EQUAL_INT32(1, p3, 1); 2194} 2195 2196void testNotEqualInt32EachEqual(void) 2197{ 2198 UNITY_INT32 p0[] = {127, 8, 127, 127}; 2199 2200 EXPECT_ABORT_BEGIN 2201 TEST_ASSERT_EACH_EQUAL_INT32(127, p0, 4); 2202 VERIFY_FAILS_END 2203} 2204 2205void testEqualUINT8Arrays(void) 2206{ 2207 UNITY_UINT8 p0[] = {1, 8, 100, 127}; 2208 UNITY_UINT8 p1[] = {1, 8, 100, 127}; 2209 UNITY_UINT8 p2[] = {1, 8, 100, 2}; 2210 UNITY_UINT8 p3[] = {1, 50, 60, 70}; 2211 2212 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 1); 2213 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 4); 2214 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); 2215 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p2, 3); 2216 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p3, 1); 2217} 2218 2219void testNotEqualUINT8Arrays1(void) 2220{ 2221 unsigned char p0[] = {1, 8, 100, 127u}; 2222 unsigned char p1[] = {1, 8, 100, 255u}; 2223 2224 EXPECT_ABORT_BEGIN 2225 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); 2226 VERIFY_FAILS_END 2227} 2228 2229void testNotEqualUINT8Arrays2(void) 2230{ 2231 unsigned char p0[] = {1, 8, 100, 127u}; 2232 unsigned char p1[] = {1, 8, 100, 255u}; 2233 2234 EXPECT_ABORT_BEGIN 2235 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); 2236 VERIFY_FAILS_END 2237} 2238 2239void testNotEqualUINT8Arrays3(void) 2240{ 2241 unsigned char p0[] = {1, 8, 100, 127u}; 2242 unsigned char p1[] = {1, 8, 100, 255u}; 2243 2244 EXPECT_ABORT_BEGIN 2245 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); 2246 VERIFY_FAILS_END 2247} 2248 2249 2250void testEqualUINT16Arrays(void) 2251{ 2252 unsigned short p0[] = {1, 8, 987, 65132u}; 2253 unsigned short p1[] = {1, 8, 987, 65132u}; 2254 unsigned short p2[] = {1, 8, 987, 2}; 2255 unsigned short p3[] = {1, 500, 600, 700}; 2256 2257 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 1); 2258 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 4); 2259 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); 2260 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p2, 3); 2261 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p3, 1); 2262} 2263 2264void testNotEqualUINT16Arrays1(void) 2265{ 2266 unsigned short p0[] = {1, 8, 987, 65132u}; 2267 unsigned short p1[] = {1, 8, 987, 65131u}; 2268 2269 EXPECT_ABORT_BEGIN 2270 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); 2271 VERIFY_FAILS_END 2272} 2273 2274void testNotEqualUINT16Arrays2(void) 2275{ 2276 unsigned short p0[] = {1, 8, 987, 65132u}; 2277 unsigned short p1[] = {2, 8, 987, 65132u}; 2278 2279 EXPECT_ABORT_BEGIN 2280 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); 2281 VERIFY_FAILS_END 2282} 2283 2284void testNotEqualUINT16Arrays3(void) 2285{ 2286 unsigned short p0[] = {1, 8, 987, 65132u}; 2287 unsigned short p1[] = {1, 8, 986, 65132u}; 2288 2289 EXPECT_ABORT_BEGIN 2290 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); 2291 VERIFY_FAILS_END 2292} 2293 2294void testEqualUINT32Arrays(void) 2295{ 2296 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2297 UNITY_UINT32 p1[] = {1, 8, 987, 65132u}; 2298 UNITY_UINT32 p2[] = {1, 8, 987, 2}; 2299 UNITY_UINT32 p3[] = {1, 500, 600, 700}; 2300 2301 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 1); 2302 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 4); 2303 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); 2304 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p2, 3); 2305 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p3, 1); 2306} 2307 2308void testNotEqualUINT32Arrays1(void) 2309{ 2310 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2311 UNITY_UINT32 p1[] = {1, 8, 987, 65131u}; 2312 2313 EXPECT_ABORT_BEGIN 2314 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); 2315 VERIFY_FAILS_END 2316} 2317 2318void testNotEqualUINT32Arrays2(void) 2319{ 2320 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2321 UNITY_UINT32 p1[] = {2, 8, 987, 65132u}; 2322 2323 EXPECT_ABORT_BEGIN 2324 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); 2325 VERIFY_FAILS_END 2326} 2327 2328void testNotEqualUINT32Arrays3(void) 2329{ 2330 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2331 UNITY_UINT32 p1[] = {1, 8, 986, 65132u}; 2332 2333 EXPECT_ABORT_BEGIN 2334 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); 2335 VERIFY_FAILS_END 2336} 2337 2338void testEqualHEXArrays(void) 2339{ 2340 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2341 UNITY_UINT32 p1[] = {1, 8, 987, 65132u}; 2342 UNITY_UINT32 p2[] = {1, 8, 987, 2}; 2343 UNITY_UINT32 p3[] = {1, 500, 600, 700}; 2344 2345 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 1); 2346 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 4); 2347 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4); 2348 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3); 2349 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1); 2350} 2351 2352void testNotEqualHEXArrays1(void) 2353{ 2354 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2355 UNITY_UINT32 p1[] = {1, 8, 987, 65131u}; 2356 2357 EXPECT_ABORT_BEGIN 2358 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 2359 VERIFY_FAILS_END 2360} 2361 2362void testNotEqualHEXArrays2(void) 2363{ 2364 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2365 UNITY_UINT32 p1[] = {2, 8, 987, 65132u}; 2366 2367 EXPECT_ABORT_BEGIN 2368 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 2369 VERIFY_FAILS_END 2370} 2371 2372void testNotEqualHEXArrays3(void) 2373{ 2374 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2375 UNITY_UINT32 p1[] = {1, 8, 986, 65132u}; 2376 2377 EXPECT_ABORT_BEGIN 2378 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4); 2379 VERIFY_FAILS_END 2380} 2381 2382void testEqualHEX32Arrays(void) 2383{ 2384 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2385 UNITY_UINT32 p1[] = {1, 8, 987, 65132u}; 2386 UNITY_UINT32 p2[] = {1, 8, 987, 2}; 2387 UNITY_UINT32 p3[] = {1, 500, 600, 700}; 2388 2389 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 1); 2390 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 4); 2391 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 2392 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3); 2393 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1); 2394} 2395 2396void testNotEqualHEX32Arrays1(void) 2397{ 2398 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2399 UNITY_UINT32 p1[] = {1, 8, 987, 65131u}; 2400 2401 EXPECT_ABORT_BEGIN 2402 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 2403 VERIFY_FAILS_END 2404} 2405 2406void testNotEqualHEX32Arrays2(void) 2407{ 2408 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2409 UNITY_UINT32 p1[] = {2, 8, 987, 65132u}; 2410 2411 EXPECT_ABORT_BEGIN 2412 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 2413 VERIFY_FAILS_END 2414} 2415 2416void testNotEqualHEX32Arrays3(void) 2417{ 2418 UNITY_UINT32 p0[] = {1, 8, 987, 65132u}; 2419 UNITY_UINT32 p1[] = {1, 8, 986, 65132u}; 2420 2421 EXPECT_ABORT_BEGIN 2422 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 2423 VERIFY_FAILS_END 2424} 2425 2426void testEqualHEX16Arrays(void) 2427{ 2428 unsigned short p0[] = {1, 8, 987, 65132u}; 2429 unsigned short p1[] = {1, 8, 987, 65132u}; 2430 unsigned short p2[] = {1, 8, 987, 2}; 2431 unsigned short p3[] = {1, 500, 600, 700}; 2432 2433 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 1); 2434 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 4); 2435 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); 2436 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p2, 3); 2437 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p3, 1); 2438} 2439 2440void testNotEqualHEX16Arrays1(void) 2441{ 2442 unsigned short p0[] = {1, 8, 987, 65132u}; 2443 unsigned short p1[] = {1, 8, 987, 65131u}; 2444 2445 EXPECT_ABORT_BEGIN 2446 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); 2447 VERIFY_FAILS_END 2448} 2449 2450void testNotEqualHEX16Arrays2(void) 2451{ 2452 unsigned short p0[] = {1, 8, 987, 65132u}; 2453 unsigned short p1[] = {2, 8, 987, 65132u}; 2454 2455 EXPECT_ABORT_BEGIN 2456 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); 2457 VERIFY_FAILS_END 2458} 2459 2460void testNotEqualHEX16Arrays3(void) 2461{ 2462 unsigned short p0[] = {1, 8, 987, 65132u}; 2463 unsigned short p1[] = {1, 8, 986, 65132u}; 2464 2465 EXPECT_ABORT_BEGIN 2466 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); 2467 VERIFY_FAILS_END 2468} 2469 2470void testEqualHEX8Arrays(void) 2471{ 2472 unsigned char p0[] = {1, 8, 254u, 123}; 2473 unsigned char p1[] = {1, 8, 254u, 123}; 2474 unsigned char p2[] = {1, 8, 254u, 2}; 2475 unsigned char p3[] = {1, 23, 25, 26}; 2476 2477 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 1); 2478 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 4); 2479 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); 2480 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p2, 3); 2481 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p3, 1); 2482} 2483 2484void testNotEqualHEX8Arrays1(void) 2485{ 2486 unsigned char p0[] = {1, 8, 254u, 253u}; 2487 unsigned char p1[] = {1, 8, 254u, 252u}; 2488 2489 EXPECT_ABORT_BEGIN 2490 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); 2491 VERIFY_FAILS_END 2492} 2493 2494void testNotEqualHEX8Arrays2(void) 2495{ 2496 unsigned char p0[] = {1, 8, 254u, 253u}; 2497 unsigned char p1[] = {2, 8, 254u, 253u}; 2498 2499 EXPECT_ABORT_BEGIN 2500 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); 2501 VERIFY_FAILS_END 2502} 2503 2504void testNotEqualHEX8Arrays3(void) 2505{ 2506 unsigned char p0[] = {1, 8, 254u, 253u}; 2507 unsigned char p1[] = {1, 8, 255u, 253u}; 2508 2509 EXPECT_ABORT_BEGIN 2510 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); 2511 VERIFY_FAILS_END 2512} 2513 2514void testEqualUINT8EachEqual(void) 2515{ 2516 UNITY_UINT8 p0[] = {127u, 127u, 127u, 127u}; 2517 UNITY_UINT8 p1[] = {1u, 1u, 1u, 1u}; 2518 UNITY_UINT8 p2[] = {128u, 128u, 128u, 2u}; 2519 UNITY_UINT8 p3[] = {1u, 50u, 60u, 70u}; 2520 2521 TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 1); 2522 TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 4); 2523 TEST_ASSERT_EACH_EQUAL_UINT8(1u, p1, 4); 2524 TEST_ASSERT_EACH_EQUAL_UINT8(128u, p2, 3); 2525 TEST_ASSERT_EACH_EQUAL_UINT8(1u, p3, 1); 2526} 2527 2528void testNotEqualUINT8EachEqual1(void) 2529{ 2530 unsigned char p0[] = {127u, 127u, 128u, 127u}; 2531 2532 EXPECT_ABORT_BEGIN 2533 TEST_ASSERT_EACH_EQUAL_UINT8(127u, p0, 4); 2534 VERIFY_FAILS_END 2535} 2536 2537void testNotEqualUINT8EachEqual2(void) 2538{ 2539 unsigned char p0[] = {1, 1, 1, 127u}; 2540 2541 EXPECT_ABORT_BEGIN 2542 TEST_ASSERT_EACH_EQUAL_UINT8(1, p0, 4); 2543 VERIFY_FAILS_END 2544} 2545 2546void testNotEqualUINT8EachEqual3(void) 2547{ 2548 unsigned char p0[] = {54u, 55u, 55u, 55u}; 2549 2550 EXPECT_ABORT_BEGIN 2551 TEST_ASSERT_EACH_EQUAL_UINT8(55u, p0, 4); 2552 VERIFY_FAILS_END 2553} 2554 2555void testEqualUINT16EachEqual(void) 2556{ 2557 unsigned short p0[] = {65132u, 65132u, 65132u, 65132u}; 2558 unsigned short p1[] = {987, 987, 987, 987}; 2559 unsigned short p2[] = {1, 1, 1, 2}; 2560 unsigned short p3[] = {1, 500, 600, 700}; 2561 2562 TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 1); 2563 TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); 2564 TEST_ASSERT_EACH_EQUAL_UINT16(987, p1, 4); 2565 TEST_ASSERT_EACH_EQUAL_UINT16(1, p2, 3); 2566 TEST_ASSERT_EACH_EQUAL_UINT16(1, p3, 1); 2567} 2568 2569void testNotEqualUINT16EachEqual1(void) 2570{ 2571 unsigned short p0[] = {1, 65132u, 65132u, 65132u}; 2572 2573 EXPECT_ABORT_BEGIN 2574 TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); 2575 VERIFY_FAILS_END 2576} 2577 2578void testNotEqualUINT16EachEqual2(void) 2579{ 2580 unsigned short p0[] = {65132u, 65132u, 987, 65132u}; 2581 2582 EXPECT_ABORT_BEGIN 2583 TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); 2584 VERIFY_FAILS_END 2585} 2586 2587void testNotEqualUINT16EachEqual3(void) 2588{ 2589 unsigned short p0[] = {65132u, 65132u, 65132u, 65133u}; 2590 2591 EXPECT_ABORT_BEGIN 2592 TEST_ASSERT_EACH_EQUAL_UINT16(65132u, p0, 4); 2593 VERIFY_FAILS_END 2594} 2595 2596void testEqualUINT32EachEqual(void) 2597{ 2598 UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u}; 2599 UNITY_UINT32 p1[] = {987, 987, 987, 987}; 2600 UNITY_UINT32 p2[] = {8, 8, 8, 2}; 2601 UNITY_UINT32 p3[] = {1, 500, 600, 700}; 2602 2603 TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 1); 2604 TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 4); 2605 TEST_ASSERT_EACH_EQUAL_UINT32(987, p1, 4); 2606 TEST_ASSERT_EACH_EQUAL_UINT32(8, p2, 3); 2607 TEST_ASSERT_EACH_EQUAL_UINT32(1, p3, 1); 2608} 2609 2610void testNotEqualUINT32EachEqual1(void) 2611{ 2612 UNITY_UINT32 p0[] = {65132u, 65132u, 987, 65132u}; 2613 2614 EXPECT_ABORT_BEGIN 2615 TEST_ASSERT_EACH_EQUAL_UINT32(65132u, p0, 4); 2616 VERIFY_FAILS_END 2617} 2618 2619void testNotEqualUINT32EachEqual2(void) 2620{ 2621 UNITY_UINT32 p0[] = {1, 987, 987, 987}; 2622 2623 EXPECT_ABORT_BEGIN 2624 TEST_ASSERT_EACH_EQUAL_UINT32(987, p0, 4); 2625 VERIFY_FAILS_END 2626} 2627 2628void testNotEqualUINT32EachEqual3(void) 2629{ 2630 UNITY_UINT32 p0[] = {1, 1, 1, 65132u}; 2631 2632 EXPECT_ABORT_BEGIN 2633 TEST_ASSERT_EACH_EQUAL_UINT32(1, p0, 4); 2634 VERIFY_FAILS_END 2635} 2636 2637void testEqualHEXEachEqual(void) 2638{ 2639 UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u}; 2640 UNITY_UINT32 p1[] = {987, 987, 987, 987}; 2641 UNITY_UINT32 p2[] = {8, 8, 8, 2}; 2642 UNITY_UINT32 p3[] = {1, 500, 600, 700}; 2643 2644 TEST_ASSERT_EACH_EQUAL_HEX(65132u, p0, 1); 2645 TEST_ASSERT_EACH_EQUAL_HEX(65132u, p0, 4); 2646 TEST_ASSERT_EACH_EQUAL_HEX(987, p1, 4); 2647 TEST_ASSERT_EACH_EQUAL_HEX(8, p2, 3); 2648 TEST_ASSERT_EACH_EQUAL_HEX(1, p3, 1); 2649} 2650 2651void testNotEqualHEXEachEqual1(void) 2652{ 2653 UNITY_UINT32 p0[] = {1, 65132u, 65132u, 65132u}; 2654 2655 EXPECT_ABORT_BEGIN 2656 TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4); 2657 VERIFY_FAILS_END 2658} 2659 2660void testNotEqualHEXEachEqual2(void) 2661{ 2662 UNITY_UINT32 p0[] = {987, 987, 987, 65132u}; 2663 2664 EXPECT_ABORT_BEGIN 2665 TEST_ASSERT_EACH_EQUAL_HEX32(987, p0, 4); 2666 VERIFY_FAILS_END 2667} 2668 2669void testNotEqualHEXEachEqual3(void) 2670{ 2671 UNITY_UINT32 p0[] = {8, 8, 987, 8}; 2672 2673 EXPECT_ABORT_BEGIN 2674 TEST_ASSERT_EACH_EQUAL_HEX(8, p0, 4); 2675 VERIFY_FAILS_END 2676} 2677 2678void testEqualHEX32EachEqual(void) 2679{ 2680 UNITY_UINT32 p0[] = {65132u, 65132u, 65132u, 65132u}; 2681 UNITY_UINT32 p1[] = {987, 987, 987, 987}; 2682 UNITY_UINT32 p2[] = {8, 8, 8, 2}; 2683 UNITY_UINT32 p3[] = {1, 500, 600, 700}; 2684 2685 TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 1); 2686 TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4); 2687 TEST_ASSERT_EACH_EQUAL_HEX32(987, p1, 4); 2688 TEST_ASSERT_EACH_EQUAL_HEX32(8, p2, 3); 2689 TEST_ASSERT_EACH_EQUAL_HEX32(1, p3, 1); 2690} 2691 2692void testNotEqualHEX32EachEqual1(void) 2693{ 2694 UNITY_UINT32 p0[] = {65132u, 8, 65132u, 65132u}; 2695 2696 EXPECT_ABORT_BEGIN 2697 TEST_ASSERT_EACH_EQUAL_HEX32(65132u, p0, 4); 2698 VERIFY_FAILS_END 2699} 2700 2701void testNotEqualHEX32EachEqual2(void) 2702{ 2703 UNITY_UINT32 p0[] = {1, 987, 987, 987}; 2704 2705 EXPECT_ABORT_BEGIN 2706 TEST_ASSERT_EACH_EQUAL_HEX32(987, p0, 4); 2707 VERIFY_FAILS_END 2708} 2709 2710void testNotEqualHEX32EachEqual3(void) 2711{ 2712 UNITY_UINT32 p0[] = {8, 8, 8, 65132u}; 2713 2714 EXPECT_ABORT_BEGIN 2715 TEST_ASSERT_EACH_EQUAL_HEX32(8, p0, 4); 2716 VERIFY_FAILS_END 2717} 2718 2719void testEqualHEX16EachEqual(void) 2720{ 2721 UNITY_UINT16 p0[] = {65132u, 65132u, 65132u, 65132u}; 2722 UNITY_UINT16 p1[] = {987, 987, 987, 987}; 2723 UNITY_UINT16 p2[] = {8, 8, 8, 2}; 2724 UNITY_UINT16 p3[] = {1, 500, 600, 700}; 2725 2726 TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 1); 2727 TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 4); 2728 TEST_ASSERT_EACH_EQUAL_HEX16(987, p1, 4); 2729 TEST_ASSERT_EACH_EQUAL_HEX16(8, p2, 3); 2730 TEST_ASSERT_EACH_EQUAL_HEX16(1, p3, 1); 2731} 2732 2733void testNotEqualHEX16EachEqual1(void) 2734{ 2735 unsigned short p0[] = {65132u, 65132u, 987, 65132u}; 2736 2737 EXPECT_ABORT_BEGIN 2738 TEST_ASSERT_EACH_EQUAL_HEX16(65132u, p0, 4); 2739 VERIFY_FAILS_END 2740} 2741 2742void testNotEqualHEX16EachEqual2(void) 2743{ 2744 unsigned short p0[] = {1, 987, 987, 987}; 2745 2746 EXPECT_ABORT_BEGIN 2747 TEST_ASSERT_EACH_EQUAL_HEX16(987, p0, 4); 2748 VERIFY_FAILS_END 2749} 2750 2751void testNotEqualHEX16EachEqual3(void) 2752{ 2753 unsigned short p0[] = {8, 8, 8, 65132u}; 2754 2755 EXPECT_ABORT_BEGIN 2756 TEST_ASSERT_EACH_EQUAL_HEX16(8, p0, 4); 2757 VERIFY_FAILS_END 2758} 2759 2760void testEqualHEX8EachEqual(void) 2761{ 2762 unsigned char p0[] = {254u, 254u, 254u, 254u}; 2763 unsigned char p1[] = {123, 123, 123, 123}; 2764 unsigned char p2[] = {8, 8, 8, 2}; 2765 unsigned char p3[] = {1, 23, 25, 26}; 2766 2767 TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 1); 2768 TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 4); 2769 TEST_ASSERT_EACH_EQUAL_HEX8(123, p1, 4); 2770 TEST_ASSERT_EACH_EQUAL_HEX8(8, p2, 3); 2771 TEST_ASSERT_EACH_EQUAL_HEX8(1, p3, 1); 2772} 2773 2774void testNotEqualHEX8EachEqual1(void) 2775{ 2776 unsigned char p0[] = {253u, 253u, 254u, 253u}; 2777 2778 EXPECT_ABORT_BEGIN 2779 TEST_ASSERT_EACH_EQUAL_HEX8(253u, p0, 4); 2780 VERIFY_FAILS_END 2781} 2782 2783void testNotEqualHEX8EachEqual2(void) 2784{ 2785 unsigned char p0[] = {254u, 254u, 254u, 253u}; 2786 2787 EXPECT_ABORT_BEGIN 2788 TEST_ASSERT_EACH_EQUAL_HEX8(254u, p0, 4); 2789 VERIFY_FAILS_END 2790} 2791 2792void testNotEqualHEX8EachEqual3(void) 2793{ 2794 unsigned char p0[] = {1, 8, 8, 8}; 2795 2796 EXPECT_ABORT_BEGIN 2797 TEST_ASSERT_EACH_EQUAL_HEX8(8, p0, 4); 2798 VERIFY_FAILS_END 2799} 2800 2801void testEqualHEX64Arrays(void) 2802{ 2803#ifndef UNITY_SUPPORT_64 2804 TEST_IGNORE(); 2805#else 2806 UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; 2807 UNITY_UINT64 p1[] = {1, 8, 987, 65132u}; 2808 UNITY_UINT64 p2[] = {1, 8, 987, 2}; 2809 UNITY_UINT64 p3[] = {1, 500, 600, 700}; 2810 2811 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 1); 2812 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 4); 2813 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); 2814 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p2, 3); 2815 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p3, 1); 2816#endif 2817} 2818 2819void testEqualUint64Arrays(void) 2820{ 2821#ifndef UNITY_SUPPORT_64 2822 TEST_IGNORE(); 2823#else 2824 UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; 2825 UNITY_UINT64 p1[] = {1, 8, 987, 65132u}; 2826 UNITY_UINT64 p2[] = {1, 8, 987, 2}; 2827 UNITY_UINT64 p3[] = {1, 500, 600, 700}; 2828 2829 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 1); 2830 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 4); 2831 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4); 2832 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p2, 3); 2833 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p3, 1); 2834#endif 2835} 2836 2837void testEqualInt64Arrays(void) 2838{ 2839#ifndef UNITY_SUPPORT_64 2840 TEST_IGNORE(); 2841#else 2842 UNITY_INT64 p0[] = {1, 8, 987, -65132}; 2843 UNITY_INT64 p1[] = {1, 8, 987, -65132}; 2844 UNITY_INT64 p2[] = {1, 8, 987, -2}; 2845 UNITY_INT64 p3[] = {1, 500, 600, 700}; 2846 2847 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 1); 2848 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 4); 2849 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4); 2850 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p2, 3); 2851 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p3, 1); 2852#endif 2853} 2854 2855 2856void testNotEqualHEX64Arrays1(void) 2857{ 2858#ifndef UNITY_SUPPORT_64 2859 TEST_IGNORE(); 2860#else 2861 UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; 2862 UNITY_UINT64 p1[] = {1, 8, 987, 65131u}; 2863 2864 EXPECT_ABORT_BEGIN 2865 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); 2866 VERIFY_FAILS_END 2867#endif 2868} 2869 2870void testNotEqualHEX64Arrays2(void) 2871{ 2872#ifndef UNITY_SUPPORT_64 2873 TEST_IGNORE(); 2874#else 2875 UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; 2876 UNITY_UINT64 p1[] = {2, 8, 987, 65132u}; 2877 2878 EXPECT_ABORT_BEGIN 2879 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); 2880 VERIFY_FAILS_END 2881#endif 2882} 2883 2884void testNotEqualUint64Arrays(void) 2885{ 2886#ifndef UNITY_SUPPORT_64 2887 TEST_IGNORE(); 2888#else 2889 UNITY_UINT64 p0[] = {1, 8, 987, 65132u}; 2890 UNITY_UINT64 p1[] = {1, 8, 987, 65131u}; 2891 2892 EXPECT_ABORT_BEGIN 2893 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4); 2894 VERIFY_FAILS_END 2895#endif 2896} 2897 2898void testNotEqualInt64Arrays(void) 2899{ 2900#ifndef UNITY_SUPPORT_64 2901 TEST_IGNORE(); 2902#else 2903 UNITY_INT64 p0[] = {1, 8, 987, -65132}; 2904 UNITY_INT64 p1[] = {1, 8, 987, -65131}; 2905 2906 EXPECT_ABORT_BEGIN 2907 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4); 2908 VERIFY_FAILS_END 2909#endif 2910} 2911 2912void testVerifyIntPassingPointerComparisonOnZeroLengthArray(void) 2913{ 2914 int a[] = { 1 }; 2915 2916#ifndef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY 2917 EXPECT_ABORT_BEGIN 2918 TEST_ASSERT_EQUAL_INT_ARRAY(a, a, 0); 2919 VERIFY_FAILS_END 2920#else 2921 2922 TEST_ASSERT_EQUAL_INT_ARRAY(a, a, 0); 2923#endif 2924} 2925 2926void testVerifyIntFailingPointerComparisonOnZeroLengthArray(void) 2927{ 2928 int a[] = { 1 }; 2929 int b[] = { 1 }; 2930 2931#ifndef UNITY_COMPARE_PTRS_ON_ZERO_ARRAY 2932 EXPECT_ABORT_BEGIN 2933 TEST_ASSERT_EQUAL_INT_ARRAY(a, b, 0); 2934 VERIFY_FAILS_END 2935#else 2936 EXPECT_ABORT_BEGIN 2937 TEST_ASSERT_EQUAL_INT_ARRAY(a, b, 0); 2938 VERIFY_FAILS_END 2939#endif 2940} 2941