Jim Carver
Fork for workshops
Embed:
(wiki syntax)
Show/hide line numbers
testunity.c
00001 /* ========================================== 00002 Unity Project - A Test Framework for C 00003 Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams 00004 [Released under MIT License. Please refer to license.txt for details] 00005 ========================================== */ 00006 00007 #include <setjmp.h> 00008 #include "unity.h" 00009 #include <string.h> 00010 00011 // Dividing by these constants produces +/- infinity. 00012 // The rationale is given in UnityAssertFloatIsInf's body. 00013 #ifndef UNITY_EXCLUDE_FLOAT 00014 static const _UF f_zero = 0.0f; 00015 #endif 00016 00017 #ifndef UNITY_EXCLUDE_DOUBLE 00018 static const _UD d_zero = 0.0; 00019 #endif 00020 00021 #define EXPECT_ABORT_BEGIN \ 00022 if (TEST_PROTECT()) \ 00023 { 00024 00025 #define VERIFY_FAILS_END \ 00026 } \ 00027 Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1; \ 00028 if (Unity.CurrentTestFailed == 1) { \ 00029 SetToOneMeanWeAlreadyCheckedThisGuy = 1; \ 00030 UnityPrintNumberUnsigned(Unity.CurrentTestLineNumber); \ 00031 UNITY_OUTPUT_CHAR(':'); \ 00032 UnityPrint(Unity.CurrentTestName); \ 00033 UnityPrint("[[[[ Previous Test Should Have Failed But Did Not ]]]]"); \ 00034 UNITY_OUTPUT_CHAR('\n'); \ 00035 } 00036 00037 #define VERIFY_IGNORES_END \ 00038 } \ 00039 Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1; \ 00040 Unity.CurrentTestIgnored = 0; \ 00041 if (Unity.CurrentTestFailed == 1) { \ 00042 SetToOneMeanWeAlreadyCheckedThisGuy = 1; \ 00043 UnityPrint("[[[[ Previous Test Should Have Ignored But Did Not ]]]]"); \ 00044 UNITY_OUTPUT_CHAR('\n'); \ 00045 } 00046 00047 static int SetToOneToFailInTearDown; 00048 static int SetToOneMeanWeAlreadyCheckedThisGuy; 00049 00050 void setUp(void) 00051 { 00052 SetToOneToFailInTearDown = 0; 00053 SetToOneMeanWeAlreadyCheckedThisGuy = 0; 00054 } 00055 00056 void tearDown(void) 00057 { 00058 if (SetToOneToFailInTearDown == 1) 00059 TEST_FAIL_MESSAGE("<= Failed in tearDown"); 00060 if ((SetToOneMeanWeAlreadyCheckedThisGuy == 0) && (Unity.CurrentTestFailed > 0)) 00061 { 00062 UnityPrint("[[[[ Previous Test Should Have Passed But Did Not ]]]]"); 00063 UNITY_OUTPUT_CHAR('\n'); 00064 } 00065 } 00066 00067 void testUnitySizeInitializationReminder(void) 00068 { 00069 /* This test ensures that sizeof(struct _Unity) doesn't change. If this 00070 * test breaks, go look at the initialization of the Unity global variable 00071 * in unity.c and make sure we're filling in the proper fields. */ 00072 const char* message = "Unexpected size for _Unity struct. Please check that " 00073 "the initialization of the Unity symbol in unity.c is " 00074 "still correct."; 00075 00076 /* Define a structure with all the same fields as `struct _Unity`. */ 00077 #ifdef UNITY_EXCLUDE_DETAILS 00078 struct { 00079 const char* TestFile; 00080 const char* CurrentTestName; 00081 UNITY_LINE_TYPE CurrentTestLineNumber; 00082 UNITY_COUNTER_TYPE NumberOfTests; 00083 UNITY_COUNTER_TYPE TestFailures; 00084 UNITY_COUNTER_TYPE TestIgnores; 00085 UNITY_COUNTER_TYPE CurrentTestFailed; 00086 UNITY_COUNTER_TYPE CurrentTestIgnored; 00087 jmp_buf AbortFrame; 00088 } _Expected_Unity; 00089 #else 00090 struct { 00091 const char* TestFile; 00092 const char* CurrentTestName; 00093 const char* CurrentDetails1; 00094 const char* CurrentDetails2; 00095 UNITY_LINE_TYPE CurrentTestLineNumber; 00096 UNITY_COUNTER_TYPE NumberOfTests; 00097 UNITY_COUNTER_TYPE TestFailures; 00098 UNITY_COUNTER_TYPE TestIgnores; 00099 UNITY_COUNTER_TYPE CurrentTestFailed; 00100 UNITY_COUNTER_TYPE CurrentTestIgnored; 00101 jmp_buf AbortFrame; 00102 } _Expected_Unity; 00103 #endif 00104 00105 /* Compare our fake structure's size to the actual structure's size. They 00106 * should be the same. 00107 * 00108 * This accounts for alignment, padding, and packing issues that might come 00109 * up between different architectures. */ 00110 TEST_ASSERT_EQUAL_MESSAGE(sizeof(_Expected_Unity), sizeof(Unity), message); 00111 } 00112 00113 void testPassShouldEndImmediatelyWithPass(void) 00114 { 00115 TEST_PASS(); 00116 TEST_FAIL_MESSAGE("We should have passed already and finished this test"); 00117 } 00118 00119 void testTrue(void) 00120 { 00121 TEST_ASSERT(1); 00122 00123 TEST_ASSERT_TRUE(1); 00124 } 00125 00126 void testFalse(void) 00127 { 00128 TEST_ASSERT_FALSE(0); 00129 00130 TEST_ASSERT_UNLESS(0); 00131 } 00132 00133 void testPreviousPass(void) 00134 { 00135 TEST_ASSERT_EQUAL_INT(0U, Unity.TestFailures); 00136 } 00137 00138 void testNotVanilla(void) 00139 { 00140 EXPECT_ABORT_BEGIN 00141 TEST_ASSERT(0); 00142 VERIFY_FAILS_END 00143 } 00144 00145 void testNotTrue(void) 00146 { 00147 EXPECT_ABORT_BEGIN 00148 TEST_ASSERT_TRUE(0); 00149 VERIFY_FAILS_END 00150 } 00151 00152 void testNotFalse(void) 00153 { 00154 EXPECT_ABORT_BEGIN 00155 TEST_ASSERT_FALSE(1); 00156 VERIFY_FAILS_END 00157 } 00158 00159 void testNotUnless(void) 00160 { 00161 EXPECT_ABORT_BEGIN 00162 TEST_ASSERT_UNLESS(1); 00163 VERIFY_FAILS_END 00164 } 00165 00166 void testNotNotEqual(void) 00167 { 00168 EXPECT_ABORT_BEGIN 00169 TEST_ASSERT_NOT_EQUAL(10, 10); 00170 VERIFY_FAILS_END 00171 } 00172 00173 void testFail(void) 00174 { 00175 EXPECT_ABORT_BEGIN 00176 TEST_FAIL_MESSAGE("Expected for testing"); 00177 VERIFY_FAILS_END 00178 } 00179 00180 void testIsNull(void) 00181 { 00182 char* ptr1 = NULL; 00183 const char* ptr2 = "hello"; 00184 00185 TEST_ASSERT_NULL(ptr1); 00186 TEST_ASSERT_NOT_NULL(ptr2); 00187 } 00188 00189 void testIsNullShouldFailIfNot(void) 00190 { 00191 const char* ptr1 = "hello"; 00192 00193 EXPECT_ABORT_BEGIN 00194 TEST_ASSERT_NULL(ptr1); 00195 VERIFY_FAILS_END 00196 } 00197 00198 void testNotNullShouldFailIfNULL(void) 00199 { 00200 char* ptr1 = NULL; 00201 00202 EXPECT_ABORT_BEGIN 00203 TEST_ASSERT_NOT_NULL(ptr1); 00204 VERIFY_FAILS_END 00205 } 00206 00207 void testIgnore(void) 00208 { 00209 EXPECT_ABORT_BEGIN 00210 TEST_IGNORE(); 00211 TEST_FAIL_MESSAGE("This should not be reached"); 00212 VERIFY_IGNORES_END 00213 } 00214 00215 void testIgnoreMessage(void) 00216 { 00217 EXPECT_ABORT_BEGIN 00218 TEST_IGNORE_MESSAGE("This is an expected TEST_IGNORE_MESSAGE string!"); 00219 TEST_FAIL_MESSAGE("This should not be reached"); 00220 VERIFY_IGNORES_END 00221 } 00222 00223 void testNotEqualInts(void) 00224 { 00225 EXPECT_ABORT_BEGIN 00226 TEST_ASSERT_EQUAL_INT(3982, 3983); 00227 VERIFY_FAILS_END 00228 } 00229 00230 void testNotEqualInt8s(void) 00231 { 00232 EXPECT_ABORT_BEGIN 00233 TEST_ASSERT_EQUAL_INT8(-127, -126); 00234 VERIFY_FAILS_END 00235 } 00236 00237 void testNotEqualInt16s(void) 00238 { 00239 EXPECT_ABORT_BEGIN 00240 TEST_ASSERT_EQUAL_INT16(-16383, -16382); 00241 VERIFY_FAILS_END 00242 } 00243 00244 void testNotEqualInt32s(void) 00245 { 00246 EXPECT_ABORT_BEGIN 00247 TEST_ASSERT_EQUAL_INT32(-2147483647, -2147483648); //use largest 32 bit negative to test printability 00248 VERIFY_FAILS_END 00249 } 00250 00251 void testNotEqualBits(void) 00252 { 00253 EXPECT_ABORT_BEGIN 00254 TEST_ASSERT_BITS(0xFF00, 0x5555, 0x5A55); 00255 VERIFY_FAILS_END 00256 } 00257 00258 void testNotEqualUInts(void) 00259 { 00260 _UU16 v0, v1; 00261 00262 v0 = 9000; 00263 v1 = 9001; 00264 00265 EXPECT_ABORT_BEGIN 00266 TEST_ASSERT_EQUAL_UINT(v0, v1); 00267 VERIFY_FAILS_END 00268 } 00269 00270 void testNotEqualUInt8s(void) 00271 { 00272 _UU8 v0, v1; 00273 00274 v0 = 254; 00275 v1 = 255; 00276 00277 EXPECT_ABORT_BEGIN 00278 TEST_ASSERT_EQUAL_UINT8(v0, v1); 00279 VERIFY_FAILS_END 00280 } 00281 00282 void testNotEqualUInt16s(void) 00283 { 00284 _UU16 v0, v1; 00285 00286 v0 = 65535; 00287 v1 = 65534; 00288 00289 EXPECT_ABORT_BEGIN 00290 TEST_ASSERT_EQUAL_UINT16(v0, v1); 00291 VERIFY_FAILS_END 00292 } 00293 00294 void testNotEqualUInt32s(void) 00295 { 00296 _UU32 v0, v1; 00297 00298 v0 = 4294967295; 00299 v1 = 4294967294; 00300 00301 EXPECT_ABORT_BEGIN 00302 TEST_ASSERT_EQUAL_UINT32(v0, v1); 00303 VERIFY_FAILS_END 00304 } 00305 00306 void testNotEqualHex8s(void) 00307 { 00308 _UU8 v0, v1; 00309 00310 v0 = 0x23; 00311 v1 = 0x22; 00312 00313 EXPECT_ABORT_BEGIN 00314 TEST_ASSERT_EQUAL_HEX8(v0, v1); 00315 VERIFY_FAILS_END 00316 } 00317 00318 void testNotEqualHex8sIfSigned(void) 00319 { 00320 _US8 v0, v1; 00321 00322 v0 = -2; 00323 v1 = 2; 00324 00325 EXPECT_ABORT_BEGIN 00326 TEST_ASSERT_EQUAL_HEX8(v0, v1); 00327 VERIFY_FAILS_END 00328 } 00329 00330 void testNotEqualHex16s(void) 00331 { 00332 _UU16 v0, v1; 00333 00334 v0 = 0x1234; 00335 v1 = 0x1235; 00336 00337 EXPECT_ABORT_BEGIN 00338 TEST_ASSERT_EQUAL_HEX16(v0, v1); 00339 VERIFY_FAILS_END 00340 } 00341 00342 void testNotEqualHex16sIfSigned(void) 00343 { 00344 _US16 v0, v1; 00345 00346 v0 = -1024; 00347 v1 = -1028; 00348 00349 EXPECT_ABORT_BEGIN 00350 TEST_ASSERT_EQUAL_HEX16(v0, v1); 00351 VERIFY_FAILS_END 00352 } 00353 00354 void testNotEqualHex32s(void) 00355 { 00356 _UU32 v0, v1; 00357 00358 v0 = 900000; 00359 v1 = 900001; 00360 00361 EXPECT_ABORT_BEGIN 00362 TEST_ASSERT_EQUAL_HEX32(v0, v1); 00363 VERIFY_FAILS_END 00364 } 00365 00366 void testNotEqualHex32sIfSigned(void) 00367 { 00368 _US32 v0, v1; 00369 00370 v0 = -900000; 00371 v1 = 900001; 00372 00373 EXPECT_ABORT_BEGIN 00374 TEST_ASSERT_EQUAL_HEX32(v0, v1); 00375 VERIFY_FAILS_END 00376 } 00377 00378 void testEqualInts(void) 00379 { 00380 int v0, v1; 00381 int *p0, *p1; 00382 00383 v0 = 19467; 00384 v1 = 19467; 00385 p0 = &v0; 00386 p1 = &v1; 00387 00388 TEST_ASSERT_EQUAL_INT(1837, 1837); 00389 TEST_ASSERT_EQUAL_INT(-27365, -27365); 00390 TEST_ASSERT_EQUAL_INT(v0, v1); 00391 TEST_ASSERT_EQUAL_INT(19467, v1); 00392 TEST_ASSERT_EQUAL_INT(v0, 19467); 00393 TEST_ASSERT_EQUAL_INT(*p0, v1); 00394 TEST_ASSERT_EQUAL_INT(*p0, *p1); 00395 TEST_ASSERT_EQUAL_INT(*p0, 19467); 00396 } 00397 00398 void testEqualInt8s(void) 00399 { 00400 _US8 v0, v1; 00401 _US8 *p0, *p1; 00402 00403 v0 = 0x22; 00404 v1 = 0x22; 00405 p0 = &v0; 00406 p1 = &v1; 00407 00408 TEST_ASSERT_EQUAL_INT8(0x22, 0x22); 00409 TEST_ASSERT_EQUAL_INT8(v0, v1); 00410 TEST_ASSERT_EQUAL_INT8(0x22, v1); 00411 TEST_ASSERT_EQUAL_INT8(v0, 0x22); 00412 TEST_ASSERT_EQUAL_INT8(*p0, v1); 00413 TEST_ASSERT_EQUAL_INT8(*p0, *p1); 00414 TEST_ASSERT_EQUAL_INT8(*p0, 0x22); 00415 } 00416 00417 void testEqualInt8sWhenThereAreDifferencesOutside8Bits(void) 00418 { 00419 TEST_ASSERT_EQUAL_INT8(0x321,0x421); 00420 TEST_ASSERT_EQUAL_INT8(0xFF21,0x0021); 00421 } 00422 00423 void testEqualInt16s(void) 00424 { 00425 _US16 v0, v1; 00426 _US16 *p0, *p1; 00427 00428 v0 = 0x7876; 00429 v1 = 0x7876; 00430 p0 = &v0; 00431 p1 = &v1; 00432 00433 TEST_ASSERT_EQUAL_INT16(0x7876, 0x7876); 00434 TEST_ASSERT_EQUAL_INT16(v0, v1); 00435 TEST_ASSERT_EQUAL_INT16(0x7876, v1); 00436 TEST_ASSERT_EQUAL_INT16(v0, 0x7876); 00437 TEST_ASSERT_EQUAL_INT16(*p0, v1); 00438 TEST_ASSERT_EQUAL_INT16(*p0, *p1); 00439 TEST_ASSERT_EQUAL_INT16(*p0, 0x7876); 00440 } 00441 00442 void testEqualInt16sNegatives(void) 00443 { 00444 _US16 v0, v1; 00445 _US16 *p0, *p1; 00446 00447 v0 = -7876; 00448 v1 = -7876; 00449 p0 = &v0; 00450 p1 = &v1; 00451 00452 TEST_ASSERT_EQUAL_INT16(-7876, -7876); 00453 TEST_ASSERT_EQUAL_INT16(v0, v1); 00454 TEST_ASSERT_EQUAL_INT16(-7876, v1); 00455 TEST_ASSERT_EQUAL_INT16(v0, -7876); 00456 TEST_ASSERT_EQUAL_INT16(*p0, v1); 00457 TEST_ASSERT_EQUAL_INT16(*p0, *p1); 00458 TEST_ASSERT_EQUAL_INT16(*p0, -7876); 00459 } 00460 00461 void testEqualInt16sWhenThereAreDifferencesOutside16Bits(void) 00462 { 00463 TEST_ASSERT_EQUAL_INT16(0x54321,0x64321); 00464 TEST_ASSERT_EQUAL_INT16(0xFFFF4321,0x00004321); 00465 } 00466 00467 void testEqualInt32s(void) 00468 { 00469 _US32 v0, v1; 00470 _US32 *p0, *p1; 00471 00472 v0 = 0x78760000; 00473 v1 = 0x78760000; 00474 p0 = &v0; 00475 p1 = &v1; 00476 00477 TEST_ASSERT_EQUAL_INT32(0x78760000, 0x78760000); 00478 TEST_ASSERT_EQUAL_INT32(v0, v1); 00479 TEST_ASSERT_EQUAL_INT32(0x78760000, v1); 00480 TEST_ASSERT_EQUAL_INT32(v0, 0x78760000); 00481 TEST_ASSERT_EQUAL_INT32(*p0, v1); 00482 TEST_ASSERT_EQUAL_INT32(*p0, *p1); 00483 TEST_ASSERT_EQUAL_INT32(*p0, 0x78760000); 00484 } 00485 00486 void testEqualInt32sNegatives(void) 00487 { 00488 _US32 v0, v1; 00489 _US32 *p0, *p1; 00490 00491 v0 = -123456789; 00492 v1 = -123456789; 00493 p0 = &v0; 00494 p1 = &v1; 00495 00496 TEST_ASSERT_EQUAL_INT32(-123456789, -123456789); 00497 TEST_ASSERT_EQUAL_INT32(v0, v1); 00498 TEST_ASSERT_EQUAL_INT32(-123456789, v1); 00499 TEST_ASSERT_EQUAL_INT32(v0, -123456789); 00500 TEST_ASSERT_EQUAL_INT32(*p0, v1); 00501 TEST_ASSERT_EQUAL_INT32(*p0, *p1); 00502 TEST_ASSERT_EQUAL_INT32(*p0, -123456789); 00503 } 00504 00505 00506 void testEqualUints(void) 00507 { 00508 unsigned int v0, v1; 00509 unsigned int *p0, *p1; 00510 00511 v0 = 19467; 00512 v1 = 19467; 00513 p0 = &v0; 00514 p1 = &v1; 00515 00516 TEST_ASSERT_EQUAL_UINT(1837, 1837); 00517 TEST_ASSERT_EQUAL_UINT(v0, v1); 00518 TEST_ASSERT_EQUAL_UINT(19467, v1); 00519 TEST_ASSERT_EQUAL_UINT(v0, 19467); 00520 TEST_ASSERT_EQUAL_UINT(*p0, v1); 00521 TEST_ASSERT_EQUAL_UINT(*p0, *p1); 00522 TEST_ASSERT_EQUAL_UINT(*p0, 19467); 00523 TEST_ASSERT_EQUAL_UINT(60872u, 60872u); 00524 } 00525 00526 00527 void testEqualUint8s(void) 00528 { 00529 _UU8 v0, v1; 00530 _UU8 *p0, *p1; 00531 00532 v0 = 0x22; 00533 v1 = 0x22; 00534 p0 = &v0; 00535 p1 = &v1; 00536 00537 TEST_ASSERT_EQUAL_UINT8(0x22, 0x22); 00538 TEST_ASSERT_EQUAL_UINT8(v0, v1); 00539 TEST_ASSERT_EQUAL_UINT8(0x22, v1); 00540 TEST_ASSERT_EQUAL_UINT8(v0, 0x22); 00541 TEST_ASSERT_EQUAL_UINT8(*p0, v1); 00542 TEST_ASSERT_EQUAL_UINT8(*p0, *p1); 00543 TEST_ASSERT_EQUAL_UINT8(*p0, 0x22); 00544 } 00545 00546 void testEqualUint8sWhenThereAreDifferencesOutside8Bits(void) 00547 { 00548 TEST_ASSERT_EQUAL_UINT8(0x321,0x421); 00549 TEST_ASSERT_EQUAL_UINT8(0xFF21,0x0021); 00550 } 00551 00552 void testEqualUint16s(void) 00553 { 00554 _UU16 v0, v1; 00555 _UU16 *p0, *p1; 00556 00557 v0 = 0x9876; 00558 v1 = 0x9876; 00559 p0 = &v0; 00560 p1 = &v1; 00561 00562 TEST_ASSERT_EQUAL_UINT16(0x9876, 0x9876); 00563 TEST_ASSERT_EQUAL_UINT16(v0, v1); 00564 TEST_ASSERT_EQUAL_UINT16(0x9876, v1); 00565 TEST_ASSERT_EQUAL_UINT16(v0, 0x9876); 00566 TEST_ASSERT_EQUAL_UINT16(*p0, v1); 00567 TEST_ASSERT_EQUAL_UINT16(*p0, *p1); 00568 TEST_ASSERT_EQUAL_UINT16(*p0, 0x9876); 00569 } 00570 00571 void testEqualUint16sWhenThereAreDifferencesOutside16Bits(void) 00572 { 00573 TEST_ASSERT_EQUAL_UINT16(0x54321,0x64321); 00574 TEST_ASSERT_EQUAL_UINT16(0xFFFF4321,0x00004321); 00575 } 00576 00577 void testEqualUint32s(void) 00578 { 00579 _UU32 v0, v1; 00580 _UU32 *p0, *p1; 00581 00582 v0 = 0x98760000; 00583 v1 = 0x98760000; 00584 p0 = &v0; 00585 p1 = &v1; 00586 00587 TEST_ASSERT_EQUAL_UINT32(0x98760000, 0x98760000); 00588 TEST_ASSERT_EQUAL_UINT32(v0, v1); 00589 TEST_ASSERT_EQUAL_UINT32(0x98760000, v1); 00590 TEST_ASSERT_EQUAL_UINT32(v0, 0x98760000); 00591 TEST_ASSERT_EQUAL_UINT32(*p0, v1); 00592 TEST_ASSERT_EQUAL_UINT32(*p0, *p1); 00593 TEST_ASSERT_EQUAL_UINT32(*p0, 0x98760000); 00594 } 00595 00596 void testNotEqual(void) 00597 { 00598 TEST_ASSERT_NOT_EQUAL(0, 1); 00599 TEST_ASSERT_NOT_EQUAL(1, 0); 00600 TEST_ASSERT_NOT_EQUAL(100, 101); 00601 TEST_ASSERT_NOT_EQUAL(0, -1); 00602 TEST_ASSERT_NOT_EQUAL(65535, -65535); 00603 TEST_ASSERT_NOT_EQUAL(75, 900); 00604 TEST_ASSERT_NOT_EQUAL(-100, -101); 00605 } 00606 00607 void testEqualHex8s(void) 00608 { 00609 _UU8 v0, v1; 00610 _UU8 *p0, *p1; 00611 00612 v0 = 0x22; 00613 v1 = 0x22; 00614 p0 = &v0; 00615 p1 = &v1; 00616 00617 TEST_ASSERT_EQUAL_HEX8(0x22, 0x22); 00618 TEST_ASSERT_EQUAL_HEX8(v0, v1); 00619 TEST_ASSERT_EQUAL_HEX8(0x22, v1); 00620 TEST_ASSERT_EQUAL_HEX8(v0, 0x22); 00621 TEST_ASSERT_EQUAL_HEX8(*p0, v1); 00622 TEST_ASSERT_EQUAL_HEX8(*p0, *p1); 00623 TEST_ASSERT_EQUAL_HEX8(*p0, 0x22); 00624 } 00625 00626 void testEqualHex8sWhenThereAreDifferencesOutside8Bits(void) 00627 { 00628 TEST_ASSERT_EQUAL_HEX8(0x321,0x421); 00629 TEST_ASSERT_EQUAL_HEX8(0xFF21,0x0021); 00630 } 00631 00632 void testEqualHex8sNegatives(void) 00633 { 00634 _UU8 v0, v1; 00635 _UU8 *p0, *p1; 00636 00637 v0 = 0xDD; 00638 v1 = 0xDD; 00639 p0 = &v0; 00640 p1 = &v1; 00641 00642 TEST_ASSERT_EQUAL_HEX8(0xDD, 0xDD); 00643 TEST_ASSERT_EQUAL_HEX8(v0, v1); 00644 TEST_ASSERT_EQUAL_HEX8(0xDD, v1); 00645 TEST_ASSERT_EQUAL_HEX8(v0, 0xDD); 00646 TEST_ASSERT_EQUAL_HEX8(*p0, v1); 00647 TEST_ASSERT_EQUAL_HEX8(*p0, *p1); 00648 TEST_ASSERT_EQUAL_HEX8(*p0, 0xDD); 00649 } 00650 00651 void testEqualHex16s(void) 00652 { 00653 _UU16 v0, v1; 00654 _UU16 *p0, *p1; 00655 00656 v0 = 0x9876; 00657 v1 = 0x9876; 00658 p0 = &v0; 00659 p1 = &v1; 00660 00661 TEST_ASSERT_EQUAL_HEX16(0x9876, 0x9876); 00662 TEST_ASSERT_EQUAL_HEX16(v0, v1); 00663 TEST_ASSERT_EQUAL_HEX16(0x9876, v1); 00664 TEST_ASSERT_EQUAL_HEX16(v0, 0x9876); 00665 TEST_ASSERT_EQUAL_HEX16(*p0, v1); 00666 TEST_ASSERT_EQUAL_HEX16(*p0, *p1); 00667 TEST_ASSERT_EQUAL_HEX16(*p0, 0x9876); 00668 } 00669 00670 void testEqualHex16sWhenThereAreDifferencesOutside16Bits(void) 00671 { 00672 TEST_ASSERT_EQUAL_HEX16(0x54321,0x64321); 00673 TEST_ASSERT_EQUAL_HEX16(0xFFFF4321,0x00004321); 00674 } 00675 00676 void testEqualHex32s(void) 00677 { 00678 _UU32 v0, v1; 00679 _UU32 *p0, *p1; 00680 00681 v0 = 0x98765432ul; 00682 v1 = 0x98765432ul; 00683 p0 = &v0; 00684 p1 = &v1; 00685 00686 TEST_ASSERT_EQUAL_HEX32(0x98765432ul, 0x98765432ul); 00687 TEST_ASSERT_EQUAL_HEX32(v0, v1); 00688 TEST_ASSERT_EQUAL_HEX32(0x98765432ul, v1); 00689 TEST_ASSERT_EQUAL_HEX32(v0, 0x98765432ul); 00690 TEST_ASSERT_EQUAL_HEX32(*p0, v1); 00691 TEST_ASSERT_EQUAL_HEX32(*p0, *p1); 00692 TEST_ASSERT_EQUAL_HEX32(*p0, 0x98765432ul); 00693 } 00694 00695 void testEqualBits(void) 00696 { 00697 _UU32 v0 = 0xFF55AA00; 00698 _UU32 v1 = 0x55550000; 00699 00700 TEST_ASSERT_BITS(v1, v0, 0x55550000); 00701 TEST_ASSERT_BITS(v1, v0, 0xFF55CC00); 00702 TEST_ASSERT_BITS(0xFFFFFFFF, v0, 0xFF55AA00); 00703 TEST_ASSERT_BITS(0xFFFFFFFF, v0, v0); 00704 TEST_ASSERT_BITS(0xF0F0F0F0, v0, 0xFC5DAE0F); 00705 TEST_ASSERT_BITS_HIGH(v1, v0); 00706 TEST_ASSERT_BITS_LOW(0x000055FF, v0); 00707 TEST_ASSERT_BIT_HIGH(30, v0); 00708 TEST_ASSERT_BIT_LOW(5, v0); 00709 } 00710 00711 void testNotEqualBitHigh(void) 00712 { 00713 _UU32 v0 = 0x7F55AA00; 00714 00715 EXPECT_ABORT_BEGIN 00716 TEST_ASSERT_BIT_HIGH(31, v0); 00717 VERIFY_FAILS_END 00718 } 00719 00720 void testNotEqualBitLow(void) 00721 { 00722 _UU32 v0 = 0xFF55AA00; 00723 00724 EXPECT_ABORT_BEGIN 00725 TEST_ASSERT_BIT_LOW(30, v0); 00726 VERIFY_FAILS_END 00727 } 00728 00729 void testNotEqualBitsHigh(void) 00730 { 00731 _UU32 v0 = 0xFF55AA00; 00732 _UU32 v1 = 0x55550000; 00733 00734 EXPECT_ABORT_BEGIN 00735 TEST_ASSERT_BITS_HIGH(v0, v1); 00736 VERIFY_FAILS_END 00737 00738 } 00739 00740 void testNotEqualBitsLow(void) 00741 { 00742 _UU32 v0 = 0xFF55AA00; 00743 _UU32 v1 = 0x55550000; 00744 00745 EXPECT_ABORT_BEGIN 00746 TEST_ASSERT_BITS_LOW(v0, v1); 00747 VERIFY_FAILS_END 00748 00749 } 00750 void testEqualShorts(void) 00751 { 00752 short v0, v1; 00753 short *p0, *p1; 00754 00755 v0 = 19467; 00756 v1 = 19467; 00757 p0 = &v0; 00758 p1 = &v1; 00759 00760 TEST_ASSERT_EQUAL_INT(1837, 1837); 00761 TEST_ASSERT_EQUAL_INT(-2987, -2987); 00762 TEST_ASSERT_EQUAL_INT(v0, v1); 00763 TEST_ASSERT_EQUAL_INT(19467, v1); 00764 TEST_ASSERT_EQUAL_INT(v0, 19467); 00765 TEST_ASSERT_EQUAL_INT(*p0, v1); 00766 TEST_ASSERT_EQUAL_INT(*p0, *p1); 00767 TEST_ASSERT_EQUAL_INT(*p0, 19467); 00768 } 00769 00770 void testEqualUShorts(void) 00771 { 00772 unsigned short v0, v1; 00773 unsigned short *p0, *p1; 00774 00775 v0 = 19467; 00776 v1 = 19467; 00777 p0 = &v0; 00778 p1 = &v1; 00779 00780 TEST_ASSERT_EQUAL_UINT(1837, 1837); 00781 TEST_ASSERT_EQUAL_UINT(2987, 2987); 00782 TEST_ASSERT_EQUAL_UINT(v0, v1); 00783 TEST_ASSERT_EQUAL_UINT(19467, v1); 00784 TEST_ASSERT_EQUAL_UINT(v0, 19467); 00785 TEST_ASSERT_EQUAL_UINT(*p0, v1); 00786 TEST_ASSERT_EQUAL_UINT(*p0, *p1); 00787 TEST_ASSERT_EQUAL_UINT(*p0, 19467); 00788 } 00789 00790 void testEqualChars(void) 00791 { 00792 signed char v0, v1; 00793 signed char *p0, *p1; 00794 00795 v0 = 109; 00796 v1 = 109; 00797 p0 = &v0; 00798 p1 = &v1; 00799 00800 TEST_ASSERT_EQUAL_INT(42, 42); 00801 TEST_ASSERT_EQUAL_INT(-116, -116); 00802 TEST_ASSERT_EQUAL_INT(v0, v1); 00803 TEST_ASSERT_EQUAL_INT(109, v1); 00804 TEST_ASSERT_EQUAL_INT(v0, 109); 00805 TEST_ASSERT_EQUAL_INT(*p0, v1); 00806 TEST_ASSERT_EQUAL_INT(*p0, *p1); 00807 TEST_ASSERT_EQUAL_INT(*p0, 109); 00808 } 00809 00810 void testEqualUChars(void) 00811 { 00812 unsigned char v0, v1; 00813 unsigned char *p0, *p1; 00814 00815 v0 = 251; 00816 v1 = 251; 00817 p0 = &v0; 00818 p1 = &v1; 00819 00820 TEST_ASSERT_EQUAL_INT(42, 42); 00821 TEST_ASSERT_EQUAL_INT(v0, v1); 00822 TEST_ASSERT_EQUAL_INT(251, v1); 00823 TEST_ASSERT_EQUAL_INT(v0, 251); 00824 TEST_ASSERT_EQUAL_INT(*p0, v1); 00825 TEST_ASSERT_EQUAL_INT(*p0, *p1); 00826 TEST_ASSERT_EQUAL_INT(*p0, 251); 00827 } 00828 00829 void testEqualPointers(void) 00830 { 00831 int v0, v1; 00832 int *p0, *p1, *p2; 00833 00834 v0 = 19467; 00835 v1 = 18271; 00836 p0 = &v0; 00837 p1 = &v1; 00838 p2 = &v1; 00839 00840 TEST_ASSERT_EQUAL_PTR(p0, &v0); 00841 TEST_ASSERT_EQUAL_PTR(&v1, p1); 00842 TEST_ASSERT_EQUAL_PTR(p2, p1); 00843 TEST_ASSERT_EQUAL_PTR(&v0, &v0); 00844 } 00845 00846 void testNotEqualPointers(void) 00847 { 00848 EXPECT_ABORT_BEGIN 00849 TEST_ASSERT_EQUAL_PTR(0x12345678, 0x12345677); 00850 VERIFY_FAILS_END 00851 } 00852 00853 void testIntsWithinDelta(void) 00854 { 00855 TEST_ASSERT_INT_WITHIN(1, 5000, 5001); 00856 TEST_ASSERT_INT_WITHIN(5, 5000, 4996); 00857 TEST_ASSERT_INT_WITHIN(5, 5000, 5005); 00858 TEST_ASSERT_INT_WITHIN(500, 50, -440); 00859 00860 TEST_ASSERT_INT_WITHIN(2, -1, -1); 00861 TEST_ASSERT_INT_WITHIN(5, 1, -1); 00862 TEST_ASSERT_INT_WITHIN(5, -1, 1); 00863 } 00864 00865 void testIntsWithinDeltaAndCustomMessage(void) 00866 { 00867 TEST_ASSERT_INT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 00868 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 00869 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 00870 TEST_ASSERT_INT_WITHIN_MESSAGE(500, 50, -440, "Custom Message."); 00871 00872 TEST_ASSERT_INT_WITHIN_MESSAGE(2, -1, -1, "Custom Message."); 00873 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); 00874 TEST_ASSERT_INT_WITHIN_MESSAGE(5, -1, 1, "Custom Message."); 00875 } 00876 00877 void testIntsNotWithinDelta(void) 00878 { 00879 EXPECT_ABORT_BEGIN 00880 TEST_ASSERT_INT_WITHIN(5, 5000, 5006); 00881 VERIFY_FAILS_END 00882 } 00883 00884 void testIntsNotWithinDeltaAndCustomMessage(void) 00885 { 00886 EXPECT_ABORT_BEGIN 00887 TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5006, "Custom Message."); 00888 VERIFY_FAILS_END 00889 } 00890 00891 void testUIntsWithinDelta(void) 00892 { 00893 TEST_ASSERT_UINT_WITHIN(1, 5000, 5001); 00894 TEST_ASSERT_UINT_WITHIN(5, 5000, 4996); 00895 TEST_ASSERT_UINT_WITHIN(5, 5000, 5005); 00896 } 00897 00898 void testUIntsWithinDeltaAndCustomMessage(void) 00899 { 00900 TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 00901 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 00902 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 00903 } 00904 00905 void testUIntsNotWithinDelta(void) 00906 { 00907 EXPECT_ABORT_BEGIN 00908 TEST_ASSERT_UINT_WITHIN(1, 2147483647u, 2147483649u); 00909 VERIFY_FAILS_END 00910 } 00911 00912 void testUIntsNotWithinDeltaAndCustomMessage(void) 00913 { 00914 EXPECT_ABORT_BEGIN 00915 TEST_ASSERT_UINT_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); 00916 VERIFY_FAILS_END 00917 } 00918 00919 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirst(void) 00920 { 00921 EXPECT_ABORT_BEGIN 00922 TEST_ASSERT_UINT_WITHIN(5, 1, -1); 00923 VERIFY_FAILS_END 00924 } 00925 00926 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassSmallFirstAndCustomMessage(void) 00927 { 00928 EXPECT_ABORT_BEGIN 00929 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); 00930 VERIFY_FAILS_END 00931 } 00932 00933 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirst(void) 00934 { 00935 EXPECT_ABORT_BEGIN 00936 TEST_ASSERT_UINT_WITHIN(5, -1, 1); 00937 VERIFY_FAILS_END 00938 } 00939 00940 void testUIntsNotWithinDeltaEvenThoughASignedIntWouldPassBigFirstAndCustomMessage(void) 00941 { 00942 EXPECT_ABORT_BEGIN 00943 TEST_ASSERT_UINT_WITHIN_MESSAGE(5, -1, 1, "Custom Message."); 00944 VERIFY_FAILS_END 00945 } 00946 00947 void testHEX32sWithinDelta(void) 00948 { 00949 TEST_ASSERT_HEX32_WITHIN(1, 5000, 5001); 00950 TEST_ASSERT_HEX32_WITHIN(5, 5000, 4996); 00951 TEST_ASSERT_HEX32_WITHIN(5, 5000, 5005); 00952 } 00953 00954 void testHEX32sWithinDeltaAndCustomMessage(void) 00955 { 00956 TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 00957 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 00958 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 00959 } 00960 00961 void testHEX32sNotWithinDelta(void) 00962 { 00963 EXPECT_ABORT_BEGIN 00964 TEST_ASSERT_HEX32_WITHIN(1, 2147483647u, 2147483649u); 00965 VERIFY_FAILS_END 00966 } 00967 00968 void testHEX32sNotWithinDeltaAndCustomMessage(void) 00969 { 00970 EXPECT_ABORT_BEGIN 00971 TEST_ASSERT_HEX32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); 00972 VERIFY_FAILS_END 00973 } 00974 00975 void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPass(void) 00976 { 00977 EXPECT_ABORT_BEGIN 00978 TEST_ASSERT_HEX32_WITHIN(5, 1, -1); 00979 VERIFY_FAILS_END 00980 } 00981 00982 void testHEX32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void) 00983 { 00984 EXPECT_ABORT_BEGIN 00985 TEST_ASSERT_HEX32_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); 00986 VERIFY_FAILS_END 00987 } 00988 00989 void testHEX16sWithinDelta(void) 00990 { 00991 TEST_ASSERT_HEX16_WITHIN(1, 5000, 5001); 00992 TEST_ASSERT_HEX16_WITHIN(5, 5000, 4996); 00993 TEST_ASSERT_HEX16_WITHIN(5, 5000, 5005); 00994 } 00995 00996 void testHEX16sWithinDeltaAndCustomMessage(void) 00997 { 00998 TEST_ASSERT_HEX16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 00999 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 01000 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 01001 } 01002 01003 void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) 01004 { 01005 TEST_ASSERT_HEX16_WITHIN(5, 0x54321, 0x44321); 01006 } 01007 01008 void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) 01009 { 01010 TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); 01011 } 01012 01013 void testHEX16sNotWithinDelta(void) 01014 { 01015 EXPECT_ABORT_BEGIN 01016 TEST_ASSERT_HEX16_WITHIN(2, 65535, 0); 01017 VERIFY_FAILS_END 01018 } 01019 01020 void testHEX16sNotWithinDeltaAndCustomMessage(void) 01021 { 01022 EXPECT_ABORT_BEGIN 01023 TEST_ASSERT_HEX16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message."); 01024 VERIFY_FAILS_END 01025 } 01026 01027 void testHEX8sWithinDelta(void) 01028 { 01029 TEST_ASSERT_HEX8_WITHIN(1, 254, 255); 01030 TEST_ASSERT_HEX8_WITHIN(5, 251, 255); 01031 TEST_ASSERT_HEX8_WITHIN(5, 1, 4); 01032 } 01033 01034 void testHEX8sWithinDeltaAndCustomMessage(void) 01035 { 01036 TEST_ASSERT_HEX8_WITHIN_MESSAGE(1, 254, 255, "Custom Message."); 01037 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 251, 255, "Custom Message."); 01038 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); 01039 } 01040 01041 void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) 01042 { 01043 TEST_ASSERT_HEX8_WITHIN(5, 0x123, 0xF23); 01044 } 01045 01046 void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) 01047 { 01048 TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); 01049 } 01050 01051 void testHEX8sNotWithinDelta(void) 01052 { 01053 EXPECT_ABORT_BEGIN 01054 TEST_ASSERT_HEX8_WITHIN(2, 255, 0); 01055 VERIFY_FAILS_END 01056 } 01057 01058 void testHEX8sNotWithinDeltaAndCustomMessage(void) 01059 { 01060 EXPECT_ABORT_BEGIN 01061 TEST_ASSERT_HEX8_WITHIN_MESSAGE(2, 255, 0, "Custom Message."); 01062 VERIFY_FAILS_END 01063 } 01064 01065 //----------------- 01066 01067 void testUINT32sWithinDelta(void) 01068 { 01069 TEST_ASSERT_UINT32_WITHIN(1, 5000, 5001); 01070 TEST_ASSERT_UINT32_WITHIN(5, 5000, 4996); 01071 TEST_ASSERT_UINT32_WITHIN(5, 5000, 5005); 01072 } 01073 01074 void testUINT32sWithinDeltaAndCustomMessage(void) 01075 { 01076 TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 01077 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 01078 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 01079 } 01080 01081 void testUINT32sNotWithinDelta(void) 01082 { 01083 EXPECT_ABORT_BEGIN 01084 TEST_ASSERT_UINT32_WITHIN(1, 2147483647u, 2147483649u); 01085 VERIFY_FAILS_END 01086 } 01087 01088 void testUINT32sNotWithinDeltaAndCustomMessage(void) 01089 { 01090 EXPECT_ABORT_BEGIN 01091 TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message."); 01092 VERIFY_FAILS_END 01093 } 01094 01095 void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPass(void) 01096 { 01097 EXPECT_ABORT_BEGIN 01098 TEST_ASSERT_UINT32_WITHIN(5, 1, -1); 01099 VERIFY_FAILS_END 01100 } 01101 01102 void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void) 01103 { 01104 EXPECT_ABORT_BEGIN 01105 TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 1, -1, "Custom Message."); 01106 VERIFY_FAILS_END 01107 } 01108 01109 void testUINT16sWithinDelta(void) 01110 { 01111 TEST_ASSERT_UINT16_WITHIN(1, 5000, 5001); 01112 TEST_ASSERT_UINT16_WITHIN(5, 5000, 4996); 01113 TEST_ASSERT_UINT16_WITHIN(5, 5000, 5005); 01114 } 01115 01116 void testUINT16sWithinDeltaAndCustomMessage(void) 01117 { 01118 TEST_ASSERT_UINT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 01119 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message."); 01120 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message."); 01121 } 01122 01123 void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) 01124 { 01125 TEST_ASSERT_UINT16_WITHIN(5, 0x54321, 0x44321); 01126 } 01127 01128 void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) 01129 { 01130 TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); 01131 } 01132 01133 void testUINT16sNotWithinDelta(void) 01134 { 01135 EXPECT_ABORT_BEGIN 01136 TEST_ASSERT_UINT16_WITHIN(2, 65535, 0); 01137 VERIFY_FAILS_END 01138 } 01139 01140 void testUINT16sNotWithinDeltaAndCustomMessage(void) 01141 { 01142 EXPECT_ABORT_BEGIN 01143 TEST_ASSERT_UINT16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message."); 01144 VERIFY_FAILS_END 01145 } 01146 01147 void testUINT8sWithinDelta(void) 01148 { 01149 TEST_ASSERT_UINT8_WITHIN(1, 254, 255); 01150 TEST_ASSERT_UINT8_WITHIN(5, 251, 255); 01151 TEST_ASSERT_UINT8_WITHIN(5, 1, 4); 01152 } 01153 01154 void testUINT8sWithinDeltaAndCustomMessage(void) 01155 { 01156 TEST_ASSERT_UINT8_WITHIN_MESSAGE(1, 254, 255, "Custom Message."); 01157 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 251, 255, "Custom Message."); 01158 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); 01159 } 01160 01161 void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) 01162 { 01163 TEST_ASSERT_UINT8_WITHIN(5, 0x123, 0xF23); 01164 } 01165 01166 void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) 01167 { 01168 TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); 01169 } 01170 01171 void testUINT8sNotWithinDelta(void) 01172 { 01173 EXPECT_ABORT_BEGIN 01174 TEST_ASSERT_UINT8_WITHIN(2, 255, 0); 01175 VERIFY_FAILS_END 01176 } 01177 01178 void testUINT8sNotWithinDeltaAndCustomMessage(void) 01179 { 01180 EXPECT_ABORT_BEGIN 01181 TEST_ASSERT_UINT8_WITHIN_MESSAGE(2, 255, 0, "Custom Message."); 01182 VERIFY_FAILS_END 01183 } 01184 01185 void testINT32sWithinDelta(void) 01186 { 01187 TEST_ASSERT_INT32_WITHIN(1, 5000, 5001); 01188 TEST_ASSERT_INT32_WITHIN(5, 1, -2); 01189 TEST_ASSERT_INT32_WITHIN(5, -2, 1); 01190 } 01191 01192 void testINT32sWithinDeltaAndCustomMessage(void) 01193 { 01194 TEST_ASSERT_INT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 01195 } 01196 01197 void testINT32sNotWithinDelta(void) 01198 { 01199 EXPECT_ABORT_BEGIN 01200 TEST_ASSERT_INT32_WITHIN(1, -3, 1); 01201 VERIFY_FAILS_END 01202 } 01203 01204 void testINT32sNotWithinDeltaAndDifferenceOverflows(void) 01205 { 01206 EXPECT_ABORT_BEGIN 01207 TEST_ASSERT_INT32_WITHIN(1, -1, 0x7FFFFFFF); 01208 VERIFY_FAILS_END 01209 } 01210 void testINT32sNotWithinDeltaAndCustomMessage(void) 01211 { 01212 EXPECT_ABORT_BEGIN 01213 TEST_ASSERT_INT32_WITHIN_MESSAGE(1, -2, 1, "Custom Message."); 01214 VERIFY_FAILS_END 01215 } 01216 01217 void testINT16sWithinDelta(void) 01218 { 01219 TEST_ASSERT_INT16_WITHIN(1, 5000, 5001); 01220 TEST_ASSERT_INT16_WITHIN(5, 2, -2); 01221 TEST_ASSERT_INT16_WITHIN(5, -2, 2); 01222 } 01223 01224 void testINT16sWithinDeltaAndCustomMessage(void) 01225 { 01226 TEST_ASSERT_INT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message."); 01227 } 01228 01229 void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void) 01230 { 01231 TEST_ASSERT_INT16_WITHIN(5, 0x54321, 0x44321); 01232 } 01233 01234 void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void) 01235 { 01236 TEST_ASSERT_INT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); 01237 } 01238 01239 void testINT16sNotWithinDelta(void) 01240 { 01241 EXPECT_ABORT_BEGIN 01242 TEST_ASSERT_INT16_WITHIN(2, 4, -2); 01243 VERIFY_FAILS_END 01244 } 01245 01246 void testINT16sNotWithinDeltaAndCustomMessage(void) 01247 { 01248 EXPECT_ABORT_BEGIN 01249 TEST_ASSERT_INT16_WITHIN_MESSAGE(2, 3, 0, "Custom Message."); 01250 VERIFY_FAILS_END 01251 } 01252 01253 void testINT8sWithinDelta(void) 01254 { 01255 TEST_ASSERT_INT8_WITHIN(1, 127, 126); 01256 TEST_ASSERT_INT8_WITHIN(5, -2, 2); 01257 TEST_ASSERT_INT8_WITHIN(5, 2, -2); 01258 } 01259 01260 void testINT8sWithinDeltaAndCustomMessage(void) 01261 { 01262 TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message."); 01263 } 01264 01265 void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void) 01266 { 01267 TEST_ASSERT_INT8_WITHIN(5, 0x123, 0xF23); 01268 } 01269 01270 void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void) 01271 { 01272 TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); 01273 } 01274 01275 void testINT8sNotWithinDelta(void) 01276 { 01277 EXPECT_ABORT_BEGIN 01278 TEST_ASSERT_INT8_WITHIN(2, -3, 0); 01279 VERIFY_FAILS_END 01280 } 01281 01282 void testINT8sNotWithinDeltaAndCustomMessage(void) 01283 { 01284 EXPECT_ABORT_BEGIN 01285 TEST_ASSERT_INT8_WITHIN_MESSAGE(2, -4, 0, "Custom Message."); 01286 VERIFY_FAILS_END 01287 } 01288 01289 void testEqualStrings(void) 01290 { 01291 const char *testString = "foo"; 01292 01293 TEST_ASSERT_EQUAL_STRING(testString, testString); 01294 TEST_ASSERT_EQUAL_STRING_MESSAGE("foo", "foo", "foo isn't foo"); 01295 TEST_ASSERT_EQUAL_STRING("foo", testString); 01296 TEST_ASSERT_EQUAL_STRING(testString, "foo"); 01297 TEST_ASSERT_EQUAL_STRING("", ""); 01298 } 01299 01300 void testEqualStringsLen(void) 01301 { 01302 const char *testString = "foobar"; 01303 TEST_ASSERT_EQUAL_STRING_LEN(testString, testString, strlen(testString)); 01304 TEST_ASSERT_EQUAL_STRING_LEN_MESSAGE("foobar", "foobaz", 5, "fooba isn't fooba"); 01305 TEST_ASSERT_EQUAL_STRING_LEN("foo", testString, 3); 01306 TEST_ASSERT_EQUAL_STRING_LEN(testString, "foo", 3); 01307 TEST_ASSERT_EQUAL_STRING_LEN("", "", 3); 01308 } 01309 01310 void testEqualStringsWithCarriageReturnsAndLineFeeds(void) 01311 { 01312 const char *testString = "foo\r\nbar"; 01313 01314 TEST_ASSERT_EQUAL_STRING(testString, testString); 01315 TEST_ASSERT_EQUAL_STRING("foo\r\nbar", "foo\r\nbar"); 01316 TEST_ASSERT_EQUAL_STRING("foo\r\nbar", testString); 01317 TEST_ASSERT_EQUAL_STRING(testString, "foo\r\nbar"); 01318 TEST_ASSERT_EQUAL_STRING("", ""); 01319 } 01320 01321 void testNotEqualString1(void) 01322 { 01323 EXPECT_ABORT_BEGIN 01324 TEST_ASSERT_EQUAL_STRING("foo", "bar"); 01325 VERIFY_FAILS_END 01326 } 01327 01328 void testNotEqualStringLen1(void) 01329 { 01330 EXPECT_ABORT_BEGIN 01331 TEST_ASSERT_EQUAL_STRING_LEN("foobar", "foobaz", 6); 01332 VERIFY_FAILS_END 01333 } 01334 01335 void testNotEqualString2(void) 01336 { 01337 EXPECT_ABORT_BEGIN 01338 TEST_ASSERT_EQUAL_STRING("foo", ""); 01339 VERIFY_FAILS_END 01340 } 01341 01342 void testNotEqualStringLen2(void) 01343 { 01344 EXPECT_ABORT_BEGIN 01345 TEST_ASSERT_EQUAL_STRING_LEN("foo", "", 3); 01346 VERIFY_FAILS_END 01347 } 01348 01349 void testNotEqualString3(void) 01350 { 01351 EXPECT_ABORT_BEGIN 01352 TEST_ASSERT_EQUAL_STRING("", "bar"); 01353 VERIFY_FAILS_END 01354 } 01355 01356 void testNotEqualStringLen3(void) 01357 { 01358 EXPECT_ABORT_BEGIN 01359 TEST_ASSERT_EQUAL_STRING_LEN("", "bar", 3); 01360 VERIFY_FAILS_END 01361 } 01362 01363 void testNotEqualString4(void) 01364 { 01365 EXPECT_ABORT_BEGIN 01366 TEST_ASSERT_EQUAL_STRING("bar\r", "bar\n"); 01367 VERIFY_FAILS_END 01368 } 01369 01370 void testNotEqualStringLen4(void) 01371 { 01372 EXPECT_ABORT_BEGIN 01373 TEST_ASSERT_EQUAL_STRING_LEN("\r\x16", "bar\n", 4); 01374 VERIFY_FAILS_END 01375 } 01376 01377 void testNotEqualString5(void) 01378 { 01379 const char str1[] = { 0x41, 0x42, 0x03, 0x00 }; 01380 const char str2[] = { 0x41, 0x42, 0x04, 0x00 }; 01381 EXPECT_ABORT_BEGIN 01382 TEST_ASSERT_EQUAL_STRING(str1, str2); 01383 VERIFY_FAILS_END 01384 } 01385 01386 void testNotEqualString_ExpectedStringIsNull(void) 01387 { 01388 EXPECT_ABORT_BEGIN 01389 TEST_ASSERT_EQUAL_STRING(NULL, "bar"); 01390 VERIFY_FAILS_END 01391 } 01392 01393 void testNotEqualStringLen_ExpectedStringIsNull(void) 01394 { 01395 EXPECT_ABORT_BEGIN 01396 TEST_ASSERT_EQUAL_STRING_LEN(NULL, "bar", 1); 01397 VERIFY_FAILS_END 01398 } 01399 01400 void testNotEqualString_ActualStringIsNull(void) 01401 { 01402 EXPECT_ABORT_BEGIN 01403 TEST_ASSERT_EQUAL_STRING("foo", NULL); 01404 VERIFY_FAILS_END 01405 } 01406 01407 void testNotEqualStringLen_ActualStringIsNull(void) 01408 { 01409 EXPECT_ABORT_BEGIN 01410 TEST_ASSERT_EQUAL_STRING_LEN("foo", NULL, 1); 01411 VERIFY_FAILS_END 01412 } 01413 01414 void testEqualStringArrays(void) 01415 { 01416 const char *testStrings[] = { "foo", "boo", "woo", "moo" }; 01417 const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; 01418 01419 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, expStrings, 3); 01420 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 3); 01421 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 2); 01422 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 1); 01423 } 01424 01425 void testNotEqualStringArray1(void) 01426 { 01427 const char *testStrings[] = { "foo", "boo", "woo", "moo" }; 01428 const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; 01429 01430 EXPECT_ABORT_BEGIN 01431 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); 01432 VERIFY_FAILS_END 01433 } 01434 01435 void testNotEqualStringArray2(void) 01436 { 01437 const char *testStrings[] = { "zoo", "boo", "woo", "moo" }; 01438 const char *expStrings[] = { "foo", "boo", "woo", "moo" }; 01439 01440 EXPECT_ABORT_BEGIN 01441 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); 01442 VERIFY_FAILS_END 01443 } 01444 01445 void testNotEqualStringArray3(void) 01446 { 01447 const char *testStrings[] = { "foo", "boo", "woo", NULL }; 01448 const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; 01449 01450 EXPECT_ABORT_BEGIN 01451 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); 01452 VERIFY_FAILS_END 01453 } 01454 01455 void testNotEqualStringArray4(void) 01456 { 01457 const char *testStrings[] = { "foo", "boo", "woo", "moo" }; 01458 const char *expStrings[] = { "foo", NULL, "woo", "moo" }; 01459 01460 EXPECT_ABORT_BEGIN 01461 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); 01462 VERIFY_FAILS_END 01463 } 01464 01465 void testNotEqualStringArray5(void) 01466 { 01467 const char **testStrings = NULL; 01468 const char *expStrings[] = { "foo", "boo", "woo", "zoo" }; 01469 01470 EXPECT_ABORT_BEGIN 01471 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); 01472 VERIFY_FAILS_END 01473 } 01474 01475 void testNotEqualStringArray6(void) 01476 { 01477 const char *testStrings[] = { "foo", "boo", "woo", "zoo" }; 01478 const char **expStrings = NULL; 01479 01480 EXPECT_ABORT_BEGIN 01481 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); 01482 VERIFY_FAILS_END 01483 } 01484 01485 void testEqualStringArrayIfBothNulls(void) 01486 { 01487 const char **testStrings = NULL; 01488 const char **expStrings = NULL; 01489 01490 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 4); 01491 } 01492 01493 void testNotEqualStringArrayLengthZero(void) 01494 { 01495 const char *testStrings[] = {NULL}; 01496 const char **expStrings = NULL; 01497 01498 EXPECT_ABORT_BEGIN 01499 TEST_ASSERT_EQUAL_STRING_ARRAY(expStrings, testStrings, 0); 01500 VERIFY_FAILS_END 01501 } 01502 01503 void testEqualMemory(void) 01504 { 01505 const char *testString = "whatever"; 01506 01507 TEST_ASSERT_EQUAL_MEMORY(testString, testString, 8); 01508 TEST_ASSERT_EQUAL_MEMORY("whatever", "whatever", 8); 01509 TEST_ASSERT_EQUAL_MEMORY("whatever", testString, 8); 01510 TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 8); 01511 TEST_ASSERT_EQUAL_MEMORY(testString, "whatever", 2); 01512 TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 1); 01513 } 01514 01515 void testNotEqualMemory1(void) 01516 { 01517 EXPECT_ABORT_BEGIN 01518 TEST_ASSERT_EQUAL_MEMORY("foo", "bar", 3); 01519 VERIFY_FAILS_END 01520 } 01521 01522 void testNotEqualMemory2(void) 01523 { 01524 EXPECT_ABORT_BEGIN 01525 TEST_ASSERT_EQUAL_MEMORY("fool", "food", 4); 01526 VERIFY_FAILS_END 01527 } 01528 01529 void testNotEqualMemory3(void) 01530 { 01531 EXPECT_ABORT_BEGIN 01532 TEST_ASSERT_EQUAL_MEMORY(NULL, "food", 4); 01533 VERIFY_FAILS_END 01534 } 01535 01536 void testNotEqualMemory4(void) 01537 { 01538 EXPECT_ABORT_BEGIN 01539 TEST_ASSERT_EQUAL_MEMORY("fool", NULL, 4); 01540 VERIFY_FAILS_END 01541 } 01542 01543 void testNotEqualMemoryLengthZero(void) 01544 { 01545 EXPECT_ABORT_BEGIN 01546 TEST_ASSERT_EQUAL_MEMORY(NULL, NULL, 0); 01547 VERIFY_FAILS_END 01548 } 01549 01550 void testEqualIntArrays(void) 01551 { 01552 int p0[] = {1, 8, 987, -2}; 01553 int p1[] = {1, 8, 987, -2}; 01554 int p2[] = {1, 8, 987, 2}; 01555 int p3[] = {1, 500, 600, 700}; 01556 01557 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 1); 01558 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p0, 4); 01559 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 01560 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p2, 3); 01561 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p3, 1); 01562 TEST_ASSERT_EQUAL_INT_ARRAY(NULL, NULL, 1); 01563 } 01564 01565 void testNotEqualIntArraysNullExpected(void) 01566 { 01567 int* p0 = NULL; 01568 int p1[] = {1, 8, 987, 2}; 01569 01570 EXPECT_ABORT_BEGIN 01571 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 01572 VERIFY_FAILS_END 01573 } 01574 01575 void testNotEqualIntArraysNullActual(void) 01576 { 01577 int* p1 = NULL; 01578 int p0[] = {1, 8, 987, 2}; 01579 01580 EXPECT_ABORT_BEGIN 01581 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 01582 VERIFY_FAILS_END 01583 } 01584 01585 void testNotEqualIntArrays1(void) 01586 { 01587 int p0[] = {1, 8, 987, -2}; 01588 int p1[] = {1, 8, 987, 2}; 01589 01590 EXPECT_ABORT_BEGIN 01591 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 01592 VERIFY_FAILS_END 01593 } 01594 01595 void testNotEqualIntArrays2(void) 01596 { 01597 int p0[] = {1, 8, 987, -2}; 01598 int p1[] = {2, 8, 987, -2}; 01599 01600 EXPECT_ABORT_BEGIN 01601 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 01602 VERIFY_FAILS_END 01603 } 01604 01605 void testNotEqualIntArrays3(void) 01606 { 01607 int p0[] = {1, 8, 987, -2}; 01608 int p1[] = {1, 8, 986, -2}; 01609 01610 EXPECT_ABORT_BEGIN 01611 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 4); 01612 VERIFY_FAILS_END 01613 } 01614 01615 void testNotEqualIntArraysLengthZero(void) 01616 { 01617 _UU32 p0[1] = {1}; 01618 _UU32 p1[1] = {1}; 01619 01620 EXPECT_ABORT_BEGIN 01621 TEST_ASSERT_EQUAL_INT_ARRAY(p0, p1, 0); 01622 VERIFY_FAILS_END 01623 } 01624 01625 void testEqualPtrArrays(void) 01626 { 01627 char A = 1; 01628 char B = 2; 01629 char C = 3; 01630 char* p0[] = {&A, &B, &C}; 01631 char* p1[] = {&A, &B, &C, &A}; 01632 char* p2[] = {&A, &B}; 01633 char* p3[] = {&A}; 01634 01635 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 1); 01636 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p0, 3); 01637 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 3); 01638 TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p2, 2); 01639 TEST_ASSERT_EQUAL_PTR_ARRAY(p3, p0, 1); 01640 } 01641 01642 void testNotEqualPtrArraysNullExpected(void) 01643 { 01644 char A = 1; 01645 char B = 2; 01646 char** p0 = NULL; 01647 char* p1[] = {&A, &B}; 01648 01649 EXPECT_ABORT_BEGIN 01650 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 2); 01651 VERIFY_FAILS_END 01652 } 01653 01654 void testNotEqualPtrArraysNullActual(void) 01655 { 01656 char A = 1; 01657 char B = 2; 01658 char** p0 = NULL; 01659 char* p1[] = {&A, &B}; 01660 01661 EXPECT_ABORT_BEGIN 01662 TEST_ASSERT_EQUAL_PTR_ARRAY(p1, p0, 2); 01663 VERIFY_FAILS_END 01664 } 01665 01666 void testNotEqualPtrArrays1(void) 01667 { 01668 char A = 1; 01669 char B = 2; 01670 char C = 3; 01671 char* p0[] = {&A, &B, &C, &B}; 01672 char* p1[] = {&A, &B, &C, &A}; 01673 01674 EXPECT_ABORT_BEGIN 01675 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); 01676 VERIFY_FAILS_END 01677 } 01678 01679 void testNotEqualPtrArrays2(void) 01680 { 01681 char A = 1; 01682 char B = 2; 01683 char C = 3; 01684 char* p0[] = {&B, &B, &C, &A}; 01685 char* p1[] = {&A, &B, &C, &A}; 01686 01687 EXPECT_ABORT_BEGIN 01688 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); 01689 VERIFY_FAILS_END 01690 } 01691 01692 void testNotEqualPtrArrays3(void) 01693 { 01694 char A = 1; 01695 char B = 2; 01696 char C = 3; 01697 char* p0[] = {&A, &B, &B, &A}; 01698 char* p1[] = {&A, &B, &C, &A}; 01699 01700 EXPECT_ABORT_BEGIN 01701 TEST_ASSERT_EQUAL_PTR_ARRAY(p0, p1, 4); 01702 VERIFY_FAILS_END 01703 } 01704 01705 void testEqualInt8Arrays(void) 01706 { 01707 _US8 p0[] = {1, 8, 117, -2}; 01708 _US8 p1[] = {1, 8, 117, -2}; 01709 _US8 p2[] = {1, 8, 117, 2}; 01710 _US8 p3[] = {1, 50, 60, 70}; 01711 01712 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 1); 01713 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p0, 4); 01714 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4); 01715 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p2, 3); 01716 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p3, 1); 01717 } 01718 01719 void testNotEqualInt8Arrays(void) 01720 { 01721 _US8 p0[] = {1, 8, 36, -2}; 01722 _US8 p1[] = {1, 8, 36, 2}; 01723 01724 EXPECT_ABORT_BEGIN 01725 TEST_ASSERT_EQUAL_INT8_ARRAY(p0, p1, 4); 01726 VERIFY_FAILS_END 01727 } 01728 01729 void testEqualUIntArrays(void) 01730 { 01731 unsigned int p0[] = {1, 8, 987, 65132u}; 01732 unsigned int p1[] = {1, 8, 987, 65132u}; 01733 unsigned int p2[] = {1, 8, 987, 2}; 01734 unsigned int p3[] = {1, 500, 600, 700}; 01735 01736 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 1); 01737 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p0, 4); 01738 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); 01739 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p2, 3); 01740 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p3, 1); 01741 } 01742 01743 void testNotEqualUIntArrays1(void) 01744 { 01745 unsigned int p0[] = {1, 8, 987, 65132u}; 01746 unsigned int p1[] = {1, 8, 987, 65131u}; 01747 01748 EXPECT_ABORT_BEGIN 01749 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); 01750 VERIFY_FAILS_END 01751 } 01752 01753 void testNotEqualUIntArrays2(void) 01754 { 01755 unsigned int p0[] = {1, 8, 987, 65132u}; 01756 unsigned int p1[] = {2, 8, 987, 65132u}; 01757 01758 EXPECT_ABORT_BEGIN 01759 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); 01760 VERIFY_FAILS_END 01761 } 01762 01763 void testNotEqualUIntArrays3(void) 01764 { 01765 unsigned int p0[] = {1, 8, 987, 65132u}; 01766 unsigned int p1[] = {1, 8, 986, 65132u}; 01767 01768 EXPECT_ABORT_BEGIN 01769 TEST_ASSERT_EQUAL_UINT_ARRAY(p0, p1, 4); 01770 VERIFY_FAILS_END 01771 } 01772 01773 void testEqualInt16Arrays(void) 01774 { 01775 _US16 p0[] = {1, 8, 117, 3}; 01776 _US16 p1[] = {1, 8, 117, 3}; 01777 _US16 p2[] = {1, 8, 117, 2}; 01778 _US16 p3[] = {1, 50, 60, 70}; 01779 01780 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 1); 01781 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p0, 4); 01782 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4); 01783 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p2, 3); 01784 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p3, 1); 01785 } 01786 01787 void testNotEqualInt16Arrays(void) 01788 { 01789 _US16 p0[] = {1, 8, 127, 3}; 01790 _US16 p1[] = {1, 8, 127, 2}; 01791 01792 EXPECT_ABORT_BEGIN 01793 TEST_ASSERT_EQUAL_INT16_ARRAY(p0, p1, 4); 01794 VERIFY_FAILS_END 01795 } 01796 01797 void testEqualInt32Arrays(void) 01798 { 01799 _US32 p0[] = {1, 8, 117, 3}; 01800 _US32 p1[] = {1, 8, 117, 3}; 01801 _US32 p2[] = {1, 8, 117, 2}; 01802 _US32 p3[] = {1, 50, 60, 70}; 01803 01804 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 1); 01805 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 4); 01806 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4); 01807 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p2, 3); 01808 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p3, 1); 01809 } 01810 01811 void testNotEqualInt32Arrays(void) 01812 { 01813 _US32 p0[] = {1, 8, 127, 3}; 01814 _US32 p1[] = {1, 8, 127, 2}; 01815 01816 EXPECT_ABORT_BEGIN 01817 TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4); 01818 VERIFY_FAILS_END 01819 } 01820 01821 void testEqualUINT8Arrays(void) 01822 { 01823 _UU8 p0[] = {1, 8, 100, 127}; 01824 _UU8 p1[] = {1, 8, 100, 127}; 01825 _UU8 p2[] = {1, 8, 100, 2}; 01826 _UU8 p3[] = {1, 50, 60, 70}; 01827 01828 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 1); 01829 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 4); 01830 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); 01831 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p2, 3); 01832 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p3, 1); 01833 } 01834 01835 void testNotEqualUINT8Arrays1(void) 01836 { 01837 unsigned char p0[] = {1, 8, 100, 127u}; 01838 unsigned char p1[] = {1, 8, 100, 255u}; 01839 01840 EXPECT_ABORT_BEGIN 01841 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); 01842 VERIFY_FAILS_END 01843 } 01844 01845 void testNotEqualUINT8Arrays2(void) 01846 { 01847 unsigned char p0[] = {1, 8, 100, 127u}; 01848 unsigned char p1[] = {1, 8, 100, 255u}; 01849 01850 EXPECT_ABORT_BEGIN 01851 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); 01852 VERIFY_FAILS_END 01853 } 01854 01855 void testNotEqualUINT8Arrays3(void) 01856 { 01857 unsigned char p0[] = {1, 8, 100, 127u}; 01858 unsigned char p1[] = {1, 8, 100, 255u}; 01859 01860 EXPECT_ABORT_BEGIN 01861 TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4); 01862 VERIFY_FAILS_END 01863 } 01864 01865 01866 void testEqualUINT16Arrays(void) 01867 { 01868 unsigned short p0[] = {1, 8, 987, 65132u}; 01869 unsigned short p1[] = {1, 8, 987, 65132u}; 01870 unsigned short p2[] = {1, 8, 987, 2}; 01871 unsigned short p3[] = {1, 500, 600, 700}; 01872 01873 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 1); 01874 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 4); 01875 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); 01876 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p2, 3); 01877 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p3, 1); 01878 } 01879 01880 void testNotEqualUINT16Arrays1(void) 01881 { 01882 unsigned short p0[] = {1, 8, 987, 65132u}; 01883 unsigned short p1[] = {1, 8, 987, 65131u}; 01884 01885 EXPECT_ABORT_BEGIN 01886 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); 01887 VERIFY_FAILS_END 01888 } 01889 01890 void testNotEqualUINT16Arrays2(void) 01891 { 01892 unsigned short p0[] = {1, 8, 987, 65132u}; 01893 unsigned short p1[] = {2, 8, 987, 65132u}; 01894 01895 EXPECT_ABORT_BEGIN 01896 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); 01897 VERIFY_FAILS_END 01898 } 01899 01900 void testNotEqualUINT16Arrays3(void) 01901 { 01902 unsigned short p0[] = {1, 8, 987, 65132u}; 01903 unsigned short p1[] = {1, 8, 986, 65132u}; 01904 01905 EXPECT_ABORT_BEGIN 01906 TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4); 01907 VERIFY_FAILS_END 01908 } 01909 01910 void testEqualUINT32Arrays(void) 01911 { 01912 _UU32 p0[] = {1, 8, 987, 65132u}; 01913 _UU32 p1[] = {1, 8, 987, 65132u}; 01914 _UU32 p2[] = {1, 8, 987, 2}; 01915 _UU32 p3[] = {1, 500, 600, 700}; 01916 01917 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 1); 01918 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 4); 01919 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); 01920 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p2, 3); 01921 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p3, 1); 01922 } 01923 01924 void testNotEqualUINT32Arrays1(void) 01925 { 01926 _UU32 p0[] = {1, 8, 987, 65132u}; 01927 _UU32 p1[] = {1, 8, 987, 65131u}; 01928 01929 EXPECT_ABORT_BEGIN 01930 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); 01931 VERIFY_FAILS_END 01932 } 01933 01934 void testNotEqualUINT32Arrays2(void) 01935 { 01936 _UU32 p0[] = {1, 8, 987, 65132u}; 01937 _UU32 p1[] = {2, 8, 987, 65132u}; 01938 01939 EXPECT_ABORT_BEGIN 01940 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); 01941 VERIFY_FAILS_END 01942 } 01943 01944 void testNotEqualUINT32Arrays3(void) 01945 { 01946 _UU32 p0[] = {1, 8, 987, 65132u}; 01947 _UU32 p1[] = {1, 8, 986, 65132u}; 01948 01949 EXPECT_ABORT_BEGIN 01950 TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4); 01951 VERIFY_FAILS_END 01952 } 01953 01954 void testEqualHEXArrays(void) 01955 { 01956 _UU32 p0[] = {1, 8, 987, 65132u}; 01957 _UU32 p1[] = {1, 8, 987, 65132u}; 01958 _UU32 p2[] = {1, 8, 987, 2}; 01959 _UU32 p3[] = {1, 500, 600, 700}; 01960 01961 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 1); 01962 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 4); 01963 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4); 01964 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3); 01965 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1); 01966 } 01967 01968 void testNotEqualHEXArrays1(void) 01969 { 01970 _UU32 p0[] = {1, 8, 987, 65132u}; 01971 _UU32 p1[] = {1, 8, 987, 65131u}; 01972 01973 EXPECT_ABORT_BEGIN 01974 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 01975 VERIFY_FAILS_END 01976 } 01977 01978 void testNotEqualHEXArrays2(void) 01979 { 01980 _UU32 p0[] = {1, 8, 987, 65132u}; 01981 _UU32 p1[] = {2, 8, 987, 65132u}; 01982 01983 EXPECT_ABORT_BEGIN 01984 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 01985 VERIFY_FAILS_END 01986 } 01987 01988 void testNotEqualHEXArrays3(void) 01989 { 01990 _UU32 p0[] = {1, 8, 987, 65132u}; 01991 _UU32 p1[] = {1, 8, 986, 65132u}; 01992 01993 EXPECT_ABORT_BEGIN 01994 TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4); 01995 VERIFY_FAILS_END 01996 } 01997 01998 void testEqualHEX32Arrays(void) 01999 { 02000 _UU32 p0[] = {1, 8, 987, 65132u}; 02001 _UU32 p1[] = {1, 8, 987, 65132u}; 02002 _UU32 p2[] = {1, 8, 987, 2}; 02003 _UU32 p3[] = {1, 500, 600, 700}; 02004 02005 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 1); 02006 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 4); 02007 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 02008 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p2, 3); 02009 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p3, 1); 02010 } 02011 02012 void testNotEqualHEX32Arrays1(void) 02013 { 02014 _UU32 p0[] = {1, 8, 987, 65132u}; 02015 _UU32 p1[] = {1, 8, 987, 65131u}; 02016 02017 EXPECT_ABORT_BEGIN 02018 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 02019 VERIFY_FAILS_END 02020 } 02021 02022 void testNotEqualHEX32Arrays2(void) 02023 { 02024 _UU32 p0[] = {1, 8, 987, 65132u}; 02025 _UU32 p1[] = {2, 8, 987, 65132u}; 02026 02027 EXPECT_ABORT_BEGIN 02028 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 02029 VERIFY_FAILS_END 02030 } 02031 02032 void testNotEqualHEX32Arrays3(void) 02033 { 02034 _UU32 p0[] = {1, 8, 987, 65132u}; 02035 _UU32 p1[] = {1, 8, 986, 65132u}; 02036 02037 EXPECT_ABORT_BEGIN 02038 TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4); 02039 VERIFY_FAILS_END 02040 } 02041 02042 void testEqualHEX16Arrays(void) 02043 { 02044 unsigned short p0[] = {1, 8, 987, 65132u}; 02045 unsigned short p1[] = {1, 8, 987, 65132u}; 02046 unsigned short p2[] = {1, 8, 987, 2}; 02047 unsigned short p3[] = {1, 500, 600, 700}; 02048 02049 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 1); 02050 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p0, 4); 02051 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); 02052 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p2, 3); 02053 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p3, 1); 02054 } 02055 02056 void testNotEqualHEX16Arrays1(void) 02057 { 02058 unsigned short p0[] = {1, 8, 987, 65132u}; 02059 unsigned short p1[] = {1, 8, 987, 65131u}; 02060 02061 EXPECT_ABORT_BEGIN 02062 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); 02063 VERIFY_FAILS_END 02064 } 02065 02066 void testNotEqualHEX16Arrays2(void) 02067 { 02068 unsigned short p0[] = {1, 8, 987, 65132u}; 02069 unsigned short p1[] = {2, 8, 987, 65132u}; 02070 02071 EXPECT_ABORT_BEGIN 02072 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); 02073 VERIFY_FAILS_END 02074 } 02075 02076 void testNotEqualHEX16Arrays3(void) 02077 { 02078 unsigned short p0[] = {1, 8, 987, 65132u}; 02079 unsigned short p1[] = {1, 8, 986, 65132u}; 02080 02081 EXPECT_ABORT_BEGIN 02082 TEST_ASSERT_EQUAL_HEX16_ARRAY(p0, p1, 4); 02083 VERIFY_FAILS_END 02084 } 02085 02086 void testEqualHEX8Arrays(void) 02087 { 02088 unsigned short p0[] = {1, 8, 254u, 123}; 02089 unsigned short p1[] = {1, 8, 254u, 123}; 02090 unsigned short p2[] = {1, 8, 254u, 2}; 02091 unsigned short p3[] = {1, 23, 25, 26}; 02092 02093 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 1); 02094 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p0, 4); 02095 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); 02096 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p2, 3); 02097 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p3, 1); 02098 } 02099 02100 void testNotEqualHEX8Arrays1(void) 02101 { 02102 unsigned char p0[] = {1, 8, 254u, 253u}; 02103 unsigned char p1[] = {1, 8, 254u, 252u}; 02104 02105 EXPECT_ABORT_BEGIN 02106 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); 02107 VERIFY_FAILS_END 02108 } 02109 02110 void testNotEqualHEX8Arrays2(void) 02111 { 02112 unsigned char p0[] = {1, 8, 254u, 253u}; 02113 unsigned char p1[] = {2, 8, 254u, 253u}; 02114 02115 EXPECT_ABORT_BEGIN 02116 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); 02117 VERIFY_FAILS_END 02118 } 02119 02120 void testNotEqualHEX8Arrays3(void) 02121 { 02122 unsigned char p0[] = {1, 8, 254u, 253u}; 02123 unsigned char p1[] = {1, 8, 255u, 253u}; 02124 02125 EXPECT_ABORT_BEGIN 02126 TEST_ASSERT_EQUAL_HEX8_ARRAY(p0, p1, 4); 02127 VERIFY_FAILS_END 02128 } 02129 02130 void testEqualMemoryArrays(void) 02131 { 02132 int p0[] = {1, 8, 987, -2}; 02133 int p1[] = {1, 8, 987, -2}; 02134 int p2[] = {1, 8, 987, 2}; 02135 int p3[] = {1, 500, 600, 700}; 02136 02137 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, sizeof(int), 1); 02138 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p0, sizeof(int), 4); 02139 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); 02140 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p2, sizeof(int), 3); 02141 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p3, sizeof(int), 1); 02142 } 02143 02144 void testNotEqualMemoryArraysExpectedNull(void) 02145 { 02146 int* p0 = NULL; 02147 int p1[] = {1, 8, 987, 2}; 02148 02149 EXPECT_ABORT_BEGIN 02150 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); 02151 VERIFY_FAILS_END 02152 } 02153 02154 void testNotEqualMemoryArraysActualNull(void) 02155 { 02156 int p0[] = {1, 8, 987, -2}; 02157 int* p1 = NULL; 02158 02159 EXPECT_ABORT_BEGIN 02160 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); 02161 VERIFY_FAILS_END 02162 } 02163 02164 void testNotEqualMemoryArrays1(void) 02165 { 02166 int p0[] = {1, 8, 987, -2}; 02167 int p1[] = {1, 8, 987, 2}; 02168 02169 EXPECT_ABORT_BEGIN 02170 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); 02171 VERIFY_FAILS_END 02172 } 02173 02174 void testNotEqualMemoryArrays2(void) 02175 { 02176 int p0[] = {1, 8, 987, -2}; 02177 int p1[] = {2, 8, 987, -2}; 02178 02179 EXPECT_ABORT_BEGIN 02180 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); 02181 VERIFY_FAILS_END 02182 } 02183 02184 void testNotEqualMemoryArrays3(void) 02185 { 02186 int p0[] = {1, 8, 987, -2}; 02187 int p1[] = {1, 8, 986, -2}; 02188 02189 EXPECT_ABORT_BEGIN 02190 TEST_ASSERT_EQUAL_MEMORY_ARRAY(p0, p1, sizeof(int), 4); 02191 VERIFY_FAILS_END 02192 } 02193 02194 void testProtection(void) 02195 { 02196 volatile int mask = 0; 02197 02198 if (TEST_PROTECT()) 02199 { 02200 mask |= 1; 02201 TEST_ABORT(); 02202 } 02203 else 02204 { 02205 Unity.CurrentTestFailed = 0; 02206 mask |= 2; 02207 } 02208 02209 TEST_ASSERT_EQUAL(3, mask); 02210 } 02211 02212 void testIgnoredAndThenFailInTearDown(void) 02213 { 02214 SetToOneToFailInTearDown = 1; 02215 TEST_IGNORE(); 02216 } 02217 02218 // Tricky series of macros to set USING_OUTPUT_SPY 02219 #define USING_SPY_AS(a) EXPAND_AND_USE_2ND(ASSIGN_VALUE(a), 0) 02220 #define ASSIGN_VALUE(a) VAL_##a 02221 #define VAL_putcharSpy 0, 1 02222 #define EXPAND_AND_USE_2ND(a, b) SECOND_PARAM(a, b, throwaway) 02223 #define SECOND_PARAM(a, b, ...) b 02224 #if USING_SPY_AS(UNITY_OUTPUT_CHAR) 02225 #define USING_OUTPUT_SPY // true only if UNITY_OUTPUT_CHAR = putcharSpy 02226 #endif 02227 02228 #ifdef USING_OUTPUT_SPY 02229 #include <stdio.h> 02230 #define SPY_BUFFER_MAX 40 02231 static char putcharSpyBuffer[SPY_BUFFER_MAX]; 02232 #endif 02233 static int indexSpyBuffer; 02234 static int putcharSpyEnabled; 02235 02236 void startPutcharSpy(void) {indexSpyBuffer = 0; putcharSpyEnabled = 1;} 02237 02238 void endPutcharSpy(void) {putcharSpyEnabled = 0;} 02239 02240 char* getBufferPutcharSpy(void) 02241 { 02242 #ifdef USING_OUTPUT_SPY 02243 putcharSpyBuffer[indexSpyBuffer] = '\0'; 02244 return putcharSpyBuffer; 02245 #else 02246 return NULL; 02247 #endif 02248 } 02249 02250 void putcharSpy(int c) 02251 { 02252 #ifdef USING_OUTPUT_SPY 02253 if (putcharSpyEnabled) 02254 { 02255 if (indexSpyBuffer < SPY_BUFFER_MAX - 1) 02256 putcharSpyBuffer[indexSpyBuffer++] = (char)c; 02257 } else 02258 c = putchar(c); 02259 #endif 02260 } 02261 02262 void testFailureCountIncrementsAndIsReturnedAtEnd(void) 02263 { 02264 Unity.CurrentTestFailed = 1; 02265 startPutcharSpy(); // Suppress output 02266 UnityConcludeTest(); 02267 TEST_ASSERT_EQUAL(1, Unity.TestFailures); 02268 02269 int failures = UnityEnd(); 02270 Unity.TestFailures--; 02271 endPutcharSpy(); 02272 TEST_ASSERT_EQUAL(1, failures); 02273 } 02274 02275 #define TEST_ASSERT_EQUAL_PRINT_NUMBERS(expected, actual) { \ 02276 startPutcharSpy(); UnityPrintNumber((actual)); endPutcharSpy(); \ 02277 TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \ 02278 } 02279 02280 #define TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS(expected, actual) { \ 02281 startPutcharSpy(); UnityPrintNumberUnsigned((actual)); endPutcharSpy(); \ 02282 TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy()); \ 02283 } 02284 02285 void testPrintNumbers32(void) 02286 { 02287 #ifndef USING_OUTPUT_SPY 02288 TEST_IGNORE_MESSAGE("Compile with '-D UNITY_OUTPUT_CHAR=putcharSpy' to enable print testing"); 02289 #else 02290 TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0); 02291 TEST_ASSERT_EQUAL_PRINT_NUMBERS("1", 1); 02292 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", -1); 02293 TEST_ASSERT_EQUAL_PRINT_NUMBERS("2000000000", 2000000000); 02294 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-2147483648", (_US32)0x80000000); 02295 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (_US32)0xFFFFFFFF); 02296 #endif 02297 } 02298 02299 void testPrintNumbersUnsigned32(void) 02300 { 02301 #ifndef USING_OUTPUT_SPY 02302 TEST_IGNORE(); 02303 #else 02304 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0); 02305 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1", 1); 02306 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("1500000000", 1500000000); 02307 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("2147483648", (_UU32)0x80000000); 02308 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("4294967295", (_UU32)0xFFFFFFFF); 02309 #endif 02310 } 02311 02312 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES 64 BIT SUPPORT ================== 02313 02314 void testPrintNumbersInt64(void) 02315 { 02316 #ifndef UNITY_SUPPORT_64 02317 TEST_IGNORE(); 02318 #else 02319 #ifndef USING_OUTPUT_SPY 02320 TEST_IGNORE(); 02321 #else 02322 TEST_ASSERT_EQUAL_PRINT_NUMBERS("0", 0); 02323 TEST_ASSERT_EQUAL_PRINT_NUMBERS("10000000000", 10000000000); 02324 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-9223372036854775808", (_U_SINT)0x8000000000000000); 02325 TEST_ASSERT_EQUAL_PRINT_NUMBERS("-1", (_U_SINT)0xFFFFFFFFFFFFFFFF); 02326 #endif 02327 #endif 02328 } 02329 02330 void testPrintNumbersUInt64(void) 02331 { 02332 #ifndef UNITY_SUPPORT_64 02333 TEST_IGNORE(); 02334 #else 02335 #ifndef USING_OUTPUT_SPY 02336 TEST_IGNORE(); 02337 #else 02338 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("0", 0); 02339 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("70000000000", 70000000000); 02340 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("9223372036854775808", (_U_UINT)0x8000000000000000); 02341 TEST_ASSERT_EQUAL_PRINT_UNSIGNED_NUMBERS("18446744073709551615", (_U_UINT)0xFFFFFFFFFFFFFFFF); 02342 #endif 02343 #endif 02344 } 02345 02346 void testEqualHex64s(void) 02347 { 02348 #ifndef UNITY_SUPPORT_64 02349 TEST_IGNORE(); 02350 #else 02351 _UU64 v0, v1; 02352 _UU64 *p0, *p1; 02353 02354 v0 = 0x9876543201234567; 02355 v1 = 0x9876543201234567; 02356 p0 = &v0; 02357 p1 = &v1; 02358 02359 TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, 0x9876543201234567); 02360 TEST_ASSERT_EQUAL_HEX64(v0, v1); 02361 TEST_ASSERT_EQUAL_HEX64(0x9876543201234567, v1); 02362 TEST_ASSERT_EQUAL_HEX64(v0, 0x9876543201234567); 02363 TEST_ASSERT_EQUAL_HEX64(*p0, v1); 02364 TEST_ASSERT_EQUAL_HEX64(*p0, *p1); 02365 TEST_ASSERT_EQUAL_HEX64(*p0, 0x9876543201234567); 02366 #endif 02367 } 02368 02369 void testEqualUint64s(void) 02370 { 02371 #ifndef UNITY_SUPPORT_64 02372 TEST_IGNORE(); 02373 #else 02374 _UU64 v0, v1; 02375 _UU64 *p0, *p1; 02376 02377 v0 = 0x9876543201234567; 02378 v1 = 0x9876543201234567; 02379 p0 = &v0; 02380 p1 = &v1; 02381 02382 TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, 0x9876543201234567); 02383 TEST_ASSERT_EQUAL_UINT64(v0, v1); 02384 TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, v1); 02385 TEST_ASSERT_EQUAL_UINT64(v0, 0x9876543201234567); 02386 TEST_ASSERT_EQUAL_UINT64(*p0, v1); 02387 TEST_ASSERT_EQUAL_UINT64(*p0, *p1); 02388 TEST_ASSERT_EQUAL_UINT64(*p0, 0x9876543201234567); 02389 #endif 02390 } 02391 02392 void testEqualInt64s(void) 02393 { 02394 #ifndef UNITY_SUPPORT_64 02395 TEST_IGNORE(); 02396 #else 02397 _US64 v0, v1; 02398 _US64 *p0, *p1; 02399 02400 v0 = (_US64)0x9876543201234567; 02401 v1 = (_US64)0x9876543201234567; 02402 p0 = &v0; 02403 p1 = &v1; 02404 02405 TEST_ASSERT_EQUAL_INT64(0x9876543201234567, 0x9876543201234567); 02406 TEST_ASSERT_EQUAL_INT64(v0, v1); 02407 TEST_ASSERT_EQUAL_INT64(0x9876543201234567, v1); 02408 TEST_ASSERT_EQUAL_INT64(v0, 0x9876543201234567); 02409 TEST_ASSERT_EQUAL_INT64(*p0, v1); 02410 TEST_ASSERT_EQUAL_INT64(*p0, *p1); 02411 TEST_ASSERT_EQUAL_INT64(*p0, 0x9876543201234567); 02412 #endif 02413 } 02414 02415 02416 void testNotEqualHex64s(void) 02417 { 02418 #ifndef UNITY_SUPPORT_64 02419 TEST_IGNORE(); 02420 #else 02421 _UU64 v0, v1; 02422 02423 v0 = 9000000000; 02424 v1 = 9100000000; 02425 02426 EXPECT_ABORT_BEGIN 02427 TEST_ASSERT_EQUAL_HEX64(v0, v1); 02428 VERIFY_FAILS_END 02429 #endif 02430 } 02431 02432 void testNotEqualUint64s(void) 02433 { 02434 #ifndef UNITY_SUPPORT_64 02435 TEST_IGNORE(); 02436 #else 02437 _UU64 v0, v1; 02438 02439 v0 = 9000000000; 02440 v1 = 9100000000; 02441 02442 EXPECT_ABORT_BEGIN 02443 TEST_ASSERT_EQUAL_UINT64(v0, v1); 02444 VERIFY_FAILS_END 02445 #endif 02446 } 02447 02448 void testNotEqualInt64s(void) 02449 { 02450 #ifndef UNITY_SUPPORT_64 02451 TEST_IGNORE(); 02452 #else 02453 _US64 v0, v1; 02454 02455 v0 = -9000000000; 02456 v1 = 9100000000; 02457 02458 EXPECT_ABORT_BEGIN 02459 TEST_ASSERT_EQUAL_INT64(v0, v1); 02460 VERIFY_FAILS_END 02461 #endif 02462 } 02463 02464 void testNotEqualHex64sIfSigned(void) 02465 { 02466 #ifndef UNITY_SUPPORT_64 02467 TEST_IGNORE(); 02468 #else 02469 _US64 v0, v1; 02470 02471 v0 = -9000000000; 02472 v1 = 9000000000; 02473 02474 EXPECT_ABORT_BEGIN 02475 TEST_ASSERT_EQUAL_HEX64(v0, v1); 02476 VERIFY_FAILS_END 02477 #endif 02478 } 02479 02480 void testHEX64sWithinDelta(void) 02481 { 02482 #ifndef UNITY_SUPPORT_64 02483 TEST_IGNORE(); 02484 #else 02485 TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE); 02486 TEST_ASSERT_HEX64_WITHIN(5, 5000, 4996); 02487 TEST_ASSERT_HEX64_WITHIN(5, 5000, 5005); 02488 #endif 02489 } 02490 02491 void testHEX64sNotWithinDelta(void) 02492 { 02493 #ifndef UNITY_SUPPORT_64 02494 TEST_IGNORE(); 02495 #else 02496 EXPECT_ABORT_BEGIN 02497 TEST_ASSERT_HEX64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC); 02498 VERIFY_FAILS_END 02499 #endif 02500 } 02501 02502 void testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void) 02503 { 02504 #ifndef UNITY_SUPPORT_64 02505 TEST_IGNORE(); 02506 #else 02507 EXPECT_ABORT_BEGIN 02508 TEST_ASSERT_HEX64_WITHIN(5, 1, -1); 02509 VERIFY_FAILS_END 02510 #endif 02511 } 02512 02513 void testUINT64sWithinDelta(void) 02514 { 02515 #ifndef UNITY_SUPPORT_64 02516 TEST_IGNORE(); 02517 #else 02518 TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE); 02519 TEST_ASSERT_UINT64_WITHIN(5, 5000, 4996); 02520 TEST_ASSERT_UINT64_WITHIN(5, 5000, 5005); 02521 #endif 02522 } 02523 02524 void testUINT64sNotWithinDelta(void) 02525 { 02526 #ifndef UNITY_SUPPORT_64 02527 TEST_IGNORE(); 02528 #else 02529 EXPECT_ABORT_BEGIN 02530 TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC); 02531 VERIFY_FAILS_END 02532 #endif 02533 } 02534 02535 void testUINT64sNotWithinDeltaEvenThoughASignedIntWouldPass(void) 02536 { 02537 #ifndef UNITY_SUPPORT_64 02538 TEST_IGNORE(); 02539 #else 02540 EXPECT_ABORT_BEGIN 02541 TEST_ASSERT_UINT64_WITHIN(5, 1, -1); 02542 VERIFY_FAILS_END 02543 #endif 02544 } 02545 02546 void testINT64sWithinDelta(void) 02547 { 02548 #ifndef UNITY_SUPPORT_64 02549 TEST_IGNORE(); 02550 #else 02551 TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE); 02552 TEST_ASSERT_INT64_WITHIN(5, 5000, 4996); 02553 TEST_ASSERT_INT64_WITHIN(5, 5000, 5005); 02554 #endif 02555 } 02556 02557 void testINT64sNotWithinDelta(void) 02558 { 02559 #ifndef UNITY_SUPPORT_64 02560 TEST_IGNORE(); 02561 #else 02562 EXPECT_ABORT_BEGIN 02563 TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC); 02564 VERIFY_FAILS_END 02565 #endif 02566 } 02567 02568 void testINT64sNotWithinDeltaAndDifferenceOverflows(void) 02569 { 02570 #ifndef UNITY_SUPPORT_64 02571 TEST_IGNORE(); 02572 #else 02573 EXPECT_ABORT_BEGIN 02574 TEST_ASSERT_INT64_WITHIN(1, 0x8000000000000000, 0x7FFFFFFFFFFFFFFF); 02575 VERIFY_FAILS_END 02576 #endif 02577 } 02578 02579 void testEqualHEX64Arrays(void) 02580 { 02581 #ifndef UNITY_SUPPORT_64 02582 TEST_IGNORE(); 02583 #else 02584 _UU64 p0[] = {1, 8, 987, 65132u}; 02585 _UU64 p1[] = {1, 8, 987, 65132u}; 02586 _UU64 p2[] = {1, 8, 987, 2}; 02587 _UU64 p3[] = {1, 500, 600, 700}; 02588 02589 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 1); 02590 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p0, 4); 02591 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); 02592 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p2, 3); 02593 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p3, 1); 02594 #endif 02595 } 02596 02597 void testEqualUint64Arrays(void) 02598 { 02599 #ifndef UNITY_SUPPORT_64 02600 TEST_IGNORE(); 02601 #else 02602 _UU64 p0[] = {1, 8, 987, 65132u}; 02603 _UU64 p1[] = {1, 8, 987, 65132u}; 02604 _UU64 p2[] = {1, 8, 987, 2}; 02605 _UU64 p3[] = {1, 500, 600, 700}; 02606 02607 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 1); 02608 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 4); 02609 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4); 02610 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p2, 3); 02611 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p3, 1); 02612 #endif 02613 } 02614 02615 void testEqualInt64Arrays(void) 02616 { 02617 #ifndef UNITY_SUPPORT_64 02618 TEST_IGNORE(); 02619 #else 02620 _US64 p0[] = {1, 8, 987, -65132}; 02621 _US64 p1[] = {1, 8, 987, -65132}; 02622 _US64 p2[] = {1, 8, 987, -2}; 02623 _US64 p3[] = {1, 500, 600, 700}; 02624 02625 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 1); 02626 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 4); 02627 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4); 02628 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p2, 3); 02629 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p3, 1); 02630 #endif 02631 } 02632 02633 02634 void testNotEqualHEX64Arrays1(void) 02635 { 02636 #ifndef UNITY_SUPPORT_64 02637 TEST_IGNORE(); 02638 #else 02639 _UU64 p0[] = {1, 8, 987, 65132u}; 02640 _UU64 p1[] = {1, 8, 987, 65131u}; 02641 02642 EXPECT_ABORT_BEGIN 02643 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); 02644 VERIFY_FAILS_END 02645 #endif 02646 } 02647 02648 void testNotEqualHEX64Arrays2(void) 02649 { 02650 #ifndef UNITY_SUPPORT_64 02651 TEST_IGNORE(); 02652 #else 02653 _UU64 p0[] = {1, 8, 987, 65132u}; 02654 _UU64 p1[] = {2, 8, 987, 65132u}; 02655 02656 EXPECT_ABORT_BEGIN 02657 TEST_ASSERT_EQUAL_HEX64_ARRAY(p0, p1, 4); 02658 VERIFY_FAILS_END 02659 #endif 02660 } 02661 02662 void testNotEqualUint64Arrays(void) 02663 { 02664 #ifndef UNITY_SUPPORT_64 02665 TEST_IGNORE(); 02666 #else 02667 _UU64 p0[] = {1, 8, 987, 65132u}; 02668 _UU64 p1[] = {1, 8, 987, 65131u}; 02669 02670 EXPECT_ABORT_BEGIN 02671 TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4); 02672 VERIFY_FAILS_END 02673 #endif 02674 } 02675 02676 void testNotEqualInt64Arrays(void) 02677 { 02678 #ifndef UNITY_SUPPORT_64 02679 TEST_IGNORE(); 02680 #else 02681 _US64 p0[] = {1, 8, 987, -65132}; 02682 _US64 p1[] = {1, 8, 987, -65131}; 02683 02684 EXPECT_ABORT_BEGIN 02685 TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4); 02686 VERIFY_FAILS_END 02687 #endif 02688 } 02689 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES FLOAT SUPPORT ================== 02690 02691 void testFloatsWithinDelta(void) 02692 { 02693 #ifdef UNITY_EXCLUDE_FLOAT 02694 TEST_IGNORE(); 02695 #else 02696 TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f); 02697 TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f); 02698 TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f); 02699 TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f); 02700 #endif 02701 } 02702 02703 void testFloatsNotWithinDelta(void) 02704 { 02705 #ifdef UNITY_EXCLUDE_FLOAT 02706 TEST_IGNORE(); 02707 #else 02708 EXPECT_ABORT_BEGIN 02709 TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f); 02710 VERIFY_FAILS_END 02711 #endif 02712 } 02713 02714 void testFloatsEqual(void) 02715 { 02716 #ifdef UNITY_EXCLUDE_FLOAT 02717 TEST_IGNORE(); 02718 #else 02719 TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f); 02720 TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f); 02721 TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f); 02722 TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f); 02723 #endif 02724 } 02725 02726 void testFloatsNotEqual(void) 02727 { 02728 #ifdef UNITY_EXCLUDE_FLOAT 02729 TEST_IGNORE(); 02730 #else 02731 EXPECT_ABORT_BEGIN 02732 TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f); 02733 VERIFY_FAILS_END 02734 #endif 02735 } 02736 02737 void testFloatsNotEqualNegative1(void) 02738 { 02739 #ifdef UNITY_EXCLUDE_FLOAT 02740 TEST_IGNORE(); 02741 #else 02742 EXPECT_ABORT_BEGIN 02743 TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f); 02744 VERIFY_FAILS_END 02745 #endif 02746 } 02747 02748 void testFloatsNotEqualNegative2(void) 02749 { 02750 #ifdef UNITY_EXCLUDE_FLOAT 02751 TEST_IGNORE(); 02752 #else 02753 EXPECT_ABORT_BEGIN 02754 TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f); 02755 VERIFY_FAILS_END 02756 #endif 02757 } 02758 02759 void testFloatsNotEqualActualNaN(void) 02760 { 02761 #ifdef UNITY_EXCLUDE_FLOAT 02762 TEST_IGNORE(); 02763 #else 02764 EXPECT_ABORT_BEGIN 02765 TEST_ASSERT_EQUAL_FLOAT(85.963f, 0.0f / f_zero); 02766 VERIFY_FAILS_END 02767 #endif 02768 } 02769 02770 void testFloatsNotEqualExpectedNaN(void) 02771 { 02772 #ifdef UNITY_EXCLUDE_FLOAT 02773 TEST_IGNORE(); 02774 #else 02775 EXPECT_ABORT_BEGIN 02776 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 85.963f); 02777 VERIFY_FAILS_END 02778 #endif 02779 } 02780 02781 void testFloatsNotEqualBothNaN(void) 02782 { 02783 #ifdef UNITY_EXCLUDE_FLOAT 02784 TEST_IGNORE(); 02785 #else 02786 EXPECT_ABORT_BEGIN 02787 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); 02788 VERIFY_FAILS_END 02789 #endif 02790 } 02791 02792 void testFloatsNotEqualInfNaN(void) 02793 { 02794 #ifdef UNITY_EXCLUDE_FLOAT 02795 TEST_IGNORE(); 02796 #else 02797 EXPECT_ABORT_BEGIN 02798 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero); 02799 VERIFY_FAILS_END 02800 #endif 02801 } 02802 02803 void testFloatsNotEqualNaNInf(void) 02804 { 02805 #ifdef UNITY_EXCLUDE_FLOAT 02806 TEST_IGNORE(); 02807 #else 02808 EXPECT_ABORT_BEGIN 02809 TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero); 02810 VERIFY_FAILS_END 02811 #endif 02812 } 02813 02814 void testFloatsNotEqualActualInf(void) 02815 { 02816 #ifdef UNITY_EXCLUDE_FLOAT 02817 TEST_IGNORE(); 02818 #else 02819 EXPECT_ABORT_BEGIN 02820 TEST_ASSERT_EQUAL_FLOAT(321.642f, 1.0f / f_zero); 02821 VERIFY_FAILS_END 02822 #endif 02823 } 02824 02825 void testFloatsNotEqualExpectedInf(void) 02826 { 02827 #ifdef UNITY_EXCLUDE_FLOAT 02828 TEST_IGNORE(); 02829 #else 02830 EXPECT_ABORT_BEGIN 02831 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 321.642f); 02832 VERIFY_FAILS_END 02833 #endif 02834 } 02835 02836 void testFloatsNotEqualBothInf(void) 02837 { 02838 #ifdef UNITY_EXCLUDE_FLOAT 02839 TEST_IGNORE(); 02840 #else 02841 EXPECT_ABORT_BEGIN 02842 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); 02843 VERIFY_FAILS_END 02844 #endif 02845 } 02846 02847 void testFloatsNotEqualPlusMinusInf(void) 02848 { 02849 #ifdef UNITY_EXCLUDE_FLOAT 02850 TEST_IGNORE(); 02851 #else 02852 EXPECT_ABORT_BEGIN 02853 TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero); 02854 VERIFY_FAILS_END 02855 #endif 02856 } 02857 02858 void testFloatIsPosInf1(void) 02859 { 02860 #ifdef UNITY_EXCLUDE_FLOAT 02861 TEST_IGNORE(); 02862 #else 02863 TEST_ASSERT_FLOAT_IS_INF(2.0f / f_zero); 02864 #endif 02865 } 02866 02867 void testFloatIsPosInf2(void) 02868 { 02869 #ifdef UNITY_EXCLUDE_FLOAT 02870 TEST_IGNORE(); 02871 #else 02872 EXPECT_ABORT_BEGIN 02873 TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f / f_zero); 02874 VERIFY_FAILS_END 02875 #endif 02876 } 02877 02878 void testFloatIsNegInf1(void) 02879 { 02880 #ifdef UNITY_EXCLUDE_FLOAT 02881 TEST_IGNORE(); 02882 #else 02883 TEST_ASSERT_FLOAT_IS_NEG_INF(-3.0f / f_zero); 02884 #endif 02885 } 02886 02887 void testFloatIsNegInf2(void) 02888 { 02889 #ifdef UNITY_EXCLUDE_FLOAT 02890 TEST_IGNORE(); 02891 #else 02892 EXPECT_ABORT_BEGIN 02893 TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(-3.0f / f_zero); 02894 VERIFY_FAILS_END 02895 #endif 02896 } 02897 02898 void testFloatIsNotPosInf1(void) 02899 { 02900 #ifdef UNITY_EXCLUDE_FLOAT 02901 TEST_IGNORE(); 02902 #else 02903 EXPECT_ABORT_BEGIN 02904 TEST_ASSERT_FLOAT_IS_INF(2.0f); 02905 VERIFY_FAILS_END 02906 #endif 02907 } 02908 02909 void testFloatIsNotPosInf2(void) 02910 { 02911 #ifdef UNITY_EXCLUDE_FLOAT 02912 TEST_IGNORE(); 02913 #else 02914 TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f); 02915 #endif 02916 } 02917 02918 void testFloatIsNotNegInf(void) 02919 { 02920 #ifdef UNITY_EXCLUDE_FLOAT 02921 TEST_IGNORE(); 02922 #else 02923 EXPECT_ABORT_BEGIN 02924 TEST_ASSERT_FLOAT_IS_NEG_INF(-999.876f); 02925 VERIFY_FAILS_END 02926 #endif 02927 } 02928 02929 void testFloatIsNan1(void) 02930 { 02931 #ifdef UNITY_EXCLUDE_FLOAT 02932 TEST_IGNORE(); 02933 #else 02934 TEST_ASSERT_FLOAT_IS_NAN(0.0f / f_zero); 02935 #endif 02936 } 02937 02938 void testFloatIsNan2(void) 02939 { 02940 #ifdef UNITY_EXCLUDE_FLOAT 02941 TEST_IGNORE(); 02942 #else 02943 EXPECT_ABORT_BEGIN 02944 TEST_ASSERT_FLOAT_IS_NOT_NAN(0.0f / f_zero); 02945 VERIFY_FAILS_END 02946 #endif 02947 } 02948 02949 void testFloatIsNotNan1(void) 02950 { 02951 #ifdef UNITY_EXCLUDE_FLOAT 02952 TEST_IGNORE(); 02953 #else 02954 EXPECT_ABORT_BEGIN 02955 TEST_ASSERT_FLOAT_IS_NAN(234.9f); 02956 VERIFY_FAILS_END 02957 #endif 02958 } 02959 02960 void testFloatIsNotNan2(void) 02961 { 02962 #ifdef UNITY_EXCLUDE_FLOAT 02963 TEST_IGNORE(); 02964 #else 02965 TEST_ASSERT_FLOAT_IS_NOT_NAN(234.9f); 02966 #endif 02967 } 02968 02969 void testFloatInfIsNotNan(void) 02970 { 02971 #ifdef UNITY_EXCLUDE_FLOAT 02972 TEST_IGNORE(); 02973 #else 02974 EXPECT_ABORT_BEGIN 02975 TEST_ASSERT_FLOAT_IS_NAN(1.0f / f_zero); 02976 VERIFY_FAILS_END 02977 #endif 02978 } 02979 02980 void testFloatNanIsNotInf(void) 02981 { 02982 #ifdef UNITY_EXCLUDE_FLOAT 02983 TEST_IGNORE(); 02984 #else 02985 EXPECT_ABORT_BEGIN 02986 TEST_ASSERT_FLOAT_IS_INF(0.0f / f_zero); 02987 VERIFY_FAILS_END 02988 #endif 02989 } 02990 02991 void testFloatIsDeterminate1(void) 02992 { 02993 #ifdef UNITY_EXCLUDE_FLOAT 02994 TEST_IGNORE(); 02995 #else 02996 TEST_ASSERT_FLOAT_IS_DETERMINATE(0.0f); 02997 TEST_ASSERT_FLOAT_IS_DETERMINATE(123.3f); 02998 TEST_ASSERT_FLOAT_IS_DETERMINATE(-88.3f); 02999 #endif 03000 } 03001 03002 void testFloatIsDeterminate2(void) 03003 { 03004 #ifdef UNITY_EXCLUDE_FLOAT 03005 TEST_IGNORE(); 03006 #else 03007 EXPECT_ABORT_BEGIN 03008 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-88.3f); 03009 VERIFY_FAILS_END 03010 #endif 03011 } 03012 03013 void testFloatIsNotDeterminate1(void) 03014 { 03015 #ifdef UNITY_EXCLUDE_FLOAT 03016 TEST_IGNORE(); 03017 #else 03018 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(1.0f / f_zero); 03019 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-1.0f / f_zero); 03020 TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(0.0f / f_zero); 03021 #endif 03022 } 03023 03024 void testFloatIsNotDeterminate2(void) 03025 { 03026 #ifdef UNITY_EXCLUDE_FLOAT 03027 TEST_IGNORE(); 03028 #else 03029 EXPECT_ABORT_BEGIN 03030 TEST_ASSERT_FLOAT_IS_DETERMINATE(-1.0f / f_zero); 03031 VERIFY_FAILS_END 03032 #endif 03033 } 03034 03035 void testFloatTraitFailsOnInvalidTrait(void) 03036 { 03037 #ifdef UNITY_EXCLUDE_FLOAT 03038 TEST_IGNORE(); 03039 #else 03040 EXPECT_ABORT_BEGIN 03041 UnityAssertFloatSpecial(1.0f, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT); 03042 VERIFY_FAILS_END 03043 #endif 03044 } 03045 03046 03047 void testEqualFloatArrays(void) 03048 { 03049 #ifdef UNITY_EXCLUDE_FLOAT 03050 TEST_IGNORE(); 03051 #else 03052 float p0[] = {1.0f, -8.0f, 25.4f, -0.123f}; 03053 float p1[] = {1.0f, -8.0f, 25.4f, -0.123f}; 03054 float p2[] = {1.0f, -8.0f, 25.4f, -0.2f}; 03055 float p3[] = {1.0f, -23.0f, 25.0f, -0.26f}; 03056 03057 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 1); 03058 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p0, 4); 03059 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03060 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p2, 3); 03061 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p3, 1); 03062 TEST_ASSERT_EQUAL_FLOAT_ARRAY(NULL, NULL, 1); 03063 #endif 03064 } 03065 03066 void testNotEqualFloatArraysExpectedNull(void) 03067 { 03068 #ifdef UNITY_EXCLUDE_FLOAT 03069 TEST_IGNORE(); 03070 #else 03071 float* p0 = NULL; 03072 float p1[] = {1.0f, 8.0f, 25.4f, 0.252f}; 03073 03074 EXPECT_ABORT_BEGIN 03075 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03076 VERIFY_FAILS_END 03077 #endif 03078 } 03079 03080 void testNotEqualFloatArraysActualNull(void) 03081 { 03082 #ifdef UNITY_EXCLUDE_FLOAT 03083 TEST_IGNORE(); 03084 #else 03085 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; 03086 float* p1 = NULL; 03087 03088 EXPECT_ABORT_BEGIN 03089 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03090 VERIFY_FAILS_END 03091 #endif 03092 } 03093 03094 void testNotEqualFloatArrays1(void) 03095 { 03096 #ifdef UNITY_EXCLUDE_FLOAT 03097 TEST_IGNORE(); 03098 #else 03099 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; 03100 float p1[] = {1.0f, 8.0f, 25.4f, 0.252f}; 03101 03102 EXPECT_ABORT_BEGIN 03103 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03104 VERIFY_FAILS_END 03105 #endif 03106 } 03107 03108 void testNotEqualFloatArrays2(void) 03109 { 03110 #ifdef UNITY_EXCLUDE_FLOAT 03111 TEST_IGNORE(); 03112 #else 03113 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; 03114 float p1[] = {2.0f, 8.0f, 25.4f, 0.253f}; 03115 03116 EXPECT_ABORT_BEGIN 03117 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03118 VERIFY_FAILS_END 03119 #endif 03120 } 03121 03122 void testNotEqualFloatArrays3(void) 03123 { 03124 #ifdef UNITY_EXCLUDE_FLOAT 03125 TEST_IGNORE(); 03126 #else 03127 float p0[] = {1.0f, 8.0f, 25.4f, 0.253f}; 03128 float p1[] = {1.0f, 8.0f, 25.5f, 0.253f}; 03129 03130 EXPECT_ABORT_BEGIN 03131 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03132 VERIFY_FAILS_END 03133 #endif 03134 } 03135 03136 void testNotEqualFloatArraysNegative1(void) 03137 { 03138 #ifdef UNITY_EXCLUDE_FLOAT 03139 TEST_IGNORE(); 03140 #else 03141 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; 03142 float p1[] = {-1.0f, -8.0f, -25.4f, -0.252f}; 03143 03144 EXPECT_ABORT_BEGIN 03145 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03146 VERIFY_FAILS_END 03147 #endif 03148 } 03149 03150 void testNotEqualFloatArraysNegative2(void) 03151 { 03152 #ifdef UNITY_EXCLUDE_FLOAT 03153 TEST_IGNORE(); 03154 #else 03155 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; 03156 float p1[] = {-2.0f, -8.0f, -25.4f, -0.253f}; 03157 03158 EXPECT_ABORT_BEGIN 03159 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03160 VERIFY_FAILS_END 03161 #endif 03162 } 03163 03164 void testNotEqualFloatArraysNegative3(void) 03165 { 03166 #ifdef UNITY_EXCLUDE_FLOAT 03167 TEST_IGNORE(); 03168 #else 03169 float p0[] = {-1.0f, -8.0f, -25.4f, -0.253f}; 03170 float p1[] = {-1.0f, -8.0f, -25.5f, -0.253f}; 03171 03172 EXPECT_ABORT_BEGIN 03173 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03174 VERIFY_FAILS_END 03175 #endif 03176 } 03177 03178 void testNotEqualFloatArraysNaN(void) 03179 { 03180 #ifdef UNITY_EXCLUDE_FLOAT 03181 TEST_IGNORE(); 03182 #else 03183 float p0[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f}; 03184 float p1[] = {1.0f, 0.0f / f_zero, 25.4f, 0.253f}; 03185 03186 EXPECT_ABORT_BEGIN 03187 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03188 VERIFY_FAILS_END 03189 #endif 03190 } 03191 03192 void testNotEqualFloatArraysInf(void) 03193 { 03194 #ifdef UNITY_EXCLUDE_FLOAT 03195 TEST_IGNORE(); 03196 #else 03197 float p0[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f}; 03198 float p1[] = {1.0f, 1.0f / f_zero, 25.4f, 0.253f}; 03199 03200 EXPECT_ABORT_BEGIN 03201 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 4); 03202 VERIFY_FAILS_END 03203 #endif 03204 } 03205 03206 void testNotEqualFloatArraysLengthZero(void) 03207 { 03208 #ifdef UNITY_EXCLUDE_FLOAT 03209 TEST_IGNORE(); 03210 #else 03211 float p0[1] = {0.0f}; 03212 float p1[1] = {0.0f}; 03213 03214 EXPECT_ABORT_BEGIN 03215 TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 0); 03216 VERIFY_FAILS_END 03217 #endif 03218 } 03219 03220 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DOUBLE SUPPORT ================== 03221 03222 void testDoublesWithinDelta(void) 03223 { 03224 #ifdef UNITY_EXCLUDE_DOUBLE 03225 TEST_IGNORE(); 03226 #else 03227 TEST_ASSERT_DOUBLE_WITHIN(0.00003, 187245.03485, 187245.03488); 03228 TEST_ASSERT_DOUBLE_WITHIN(1.0, 187245.0, 187246.0); 03229 TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2549, 9273.2049); 03230 TEST_ASSERT_DOUBLE_WITHIN(0.007, -726.93725, -726.94424); 03231 #endif 03232 } 03233 03234 void testDoublesNotWithinDelta(void) 03235 { 03236 #ifdef UNITY_EXCLUDE_DOUBLE 03237 TEST_IGNORE(); 03238 #else 03239 EXPECT_ABORT_BEGIN 03240 TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2649, 9273.2049); 03241 VERIFY_FAILS_END 03242 #endif 03243 } 03244 03245 03246 void testDoublesEqual(void) 03247 { 03248 #ifdef UNITY_EXCLUDE_DOUBLE 03249 TEST_IGNORE(); 03250 #else 03251 TEST_ASSERT_EQUAL_DOUBLE(187245123456.0, 187245123456.0); 03252 TEST_ASSERT_EQUAL_DOUBLE(187241234567.5, 187241234567.6); 03253 TEST_ASSERT_EQUAL_DOUBLE(9273.2512345649, 9273.25123455699); 03254 TEST_ASSERT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374); 03255 #endif 03256 } 03257 03258 void testDoublesNotEqual(void) 03259 { 03260 #ifdef UNITY_EXCLUDE_DOUBLE 03261 TEST_IGNORE(); 03262 #else 03263 EXPECT_ABORT_BEGIN 03264 TEST_ASSERT_EQUAL_DOUBLE(9273.9649, 9273.0049); 03265 VERIFY_FAILS_END 03266 #endif 03267 } 03268 03269 void testDoublesNotEqualNegative1(void) 03270 { 03271 #ifdef UNITY_EXCLUDE_DOUBLE 03272 TEST_IGNORE(); 03273 #else 03274 EXPECT_ABORT_BEGIN 03275 TEST_ASSERT_EQUAL_DOUBLE(-9273.9649, -9273.0049); 03276 VERIFY_FAILS_END 03277 #endif 03278 } 03279 03280 void testDoublesNotEqualNegative2(void) 03281 { 03282 #ifdef UNITY_EXCLUDE_DOUBLE 03283 TEST_IGNORE(); 03284 #else 03285 EXPECT_ABORT_BEGIN 03286 TEST_ASSERT_EQUAL_DOUBLE(-9273.0049, -9273.9649); 03287 VERIFY_FAILS_END 03288 #endif 03289 } 03290 03291 void testDoublesNotEqualActualNaN(void) 03292 { 03293 #ifdef UNITY_EXCLUDE_DOUBLE 03294 TEST_IGNORE(); 03295 #else 03296 EXPECT_ABORT_BEGIN 03297 TEST_ASSERT_EQUAL_DOUBLE(85.963, 0.0 / d_zero); 03298 VERIFY_FAILS_END 03299 #endif 03300 } 03301 03302 void testDoublesNotEqualExpectedNaN(void) 03303 { 03304 #ifdef UNITY_EXCLUDE_DOUBLE 03305 TEST_IGNORE(); 03306 #else 03307 EXPECT_ABORT_BEGIN 03308 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 85.963); 03309 VERIFY_FAILS_END 03310 #endif 03311 } 03312 03313 void testDoublesNotEqualBothNaN(void) 03314 { 03315 #ifdef UNITY_EXCLUDE_DOUBLE 03316 TEST_IGNORE(); 03317 #else 03318 EXPECT_ABORT_BEGIN 03319 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero); 03320 VERIFY_FAILS_END 03321 #endif 03322 } 03323 03324 void testDoublesNotEqualInfNaN(void) 03325 { 03326 #ifdef UNITY_EXCLUDE_DOUBLE 03327 TEST_IGNORE(); 03328 #else 03329 EXPECT_ABORT_BEGIN 03330 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero); 03331 VERIFY_FAILS_END 03332 #endif 03333 } 03334 03335 void testDoublesNotEqualNaNInf(void) 03336 { 03337 #ifdef UNITY_EXCLUDE_DOUBLE 03338 TEST_IGNORE(); 03339 #else 03340 EXPECT_ABORT_BEGIN 03341 TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero); 03342 VERIFY_FAILS_END 03343 #endif 03344 } 03345 03346 void testDoublesNotEqualActualInf(void) 03347 { 03348 #ifdef UNITY_EXCLUDE_DOUBLE 03349 TEST_IGNORE(); 03350 #else 03351 EXPECT_ABORT_BEGIN 03352 TEST_ASSERT_EQUAL_DOUBLE(321.642, 1.0 / d_zero); 03353 VERIFY_FAILS_END 03354 #endif 03355 } 03356 03357 void testDoublesNotEqualExpectedInf(void) 03358 { 03359 #ifdef UNITY_EXCLUDE_DOUBLE 03360 TEST_IGNORE(); 03361 #else 03362 EXPECT_ABORT_BEGIN 03363 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 321.642); 03364 VERIFY_FAILS_END 03365 #endif 03366 } 03367 03368 void testDoublesNotEqualBothInf(void) 03369 { 03370 #ifdef UNITY_EXCLUDE_DOUBLE 03371 TEST_IGNORE(); 03372 #else 03373 EXPECT_ABORT_BEGIN 03374 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero); 03375 VERIFY_FAILS_END 03376 #endif 03377 } 03378 03379 void testDoublesNotEqualPlusMinusInf(void) 03380 { 03381 #ifdef UNITY_EXCLUDE_DOUBLE 03382 TEST_IGNORE(); 03383 #else 03384 EXPECT_ABORT_BEGIN 03385 TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero); 03386 VERIFY_FAILS_END 03387 #endif 03388 } 03389 03390 void testDoubleIsPosInf1(void) 03391 { 03392 #ifdef UNITY_EXCLUDE_DOUBLE 03393 TEST_IGNORE(); 03394 #else 03395 TEST_ASSERT_DOUBLE_IS_INF(2.0 / d_zero); 03396 #endif 03397 } 03398 03399 void testDoubleIsPosInf2(void) 03400 { 03401 #ifdef UNITY_EXCLUDE_DOUBLE 03402 TEST_IGNORE(); 03403 #else 03404 EXPECT_ABORT_BEGIN 03405 TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0 / d_zero); 03406 VERIFY_FAILS_END 03407 #endif 03408 } 03409 03410 void testDoubleIsNegInf1(void) 03411 { 03412 #ifdef UNITY_EXCLUDE_DOUBLE 03413 TEST_IGNORE(); 03414 #else 03415 TEST_ASSERT_DOUBLE_IS_NEG_INF(-3.0 / d_zero); 03416 #endif 03417 } 03418 03419 void testDoubleIsNegInf2(void) 03420 { 03421 #ifdef UNITY_EXCLUDE_DOUBLE 03422 TEST_IGNORE(); 03423 #else 03424 EXPECT_ABORT_BEGIN 03425 TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(-3.0 / d_zero); 03426 VERIFY_FAILS_END 03427 #endif 03428 } 03429 03430 void testDoubleIsNotPosInf1(void) 03431 { 03432 #ifdef UNITY_EXCLUDE_DOUBLE 03433 TEST_IGNORE(); 03434 #else 03435 EXPECT_ABORT_BEGIN 03436 TEST_ASSERT_DOUBLE_IS_INF(2.0); 03437 VERIFY_FAILS_END 03438 #endif 03439 } 03440 03441 void testDoubleIsNotPosInf2(void) 03442 { 03443 #ifdef UNITY_EXCLUDE_DOUBLE 03444 TEST_IGNORE(); 03445 #else 03446 TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0); 03447 #endif 03448 } 03449 03450 void testDoubleIsNotNegInf(void) 03451 { 03452 #ifdef UNITY_EXCLUDE_DOUBLE 03453 TEST_IGNORE(); 03454 #else 03455 EXPECT_ABORT_BEGIN 03456 TEST_ASSERT_DOUBLE_IS_NEG_INF(-999.876); 03457 VERIFY_FAILS_END 03458 #endif 03459 } 03460 03461 void testDoubleIsNan1(void) 03462 { 03463 #ifdef UNITY_EXCLUDE_DOUBLE 03464 TEST_IGNORE(); 03465 #else 03466 TEST_ASSERT_DOUBLE_IS_NAN(0.0 / d_zero); 03467 #endif 03468 } 03469 03470 void testDoubleIsNan2(void) 03471 { 03472 #ifdef UNITY_EXCLUDE_DOUBLE 03473 TEST_IGNORE(); 03474 #else 03475 EXPECT_ABORT_BEGIN 03476 TEST_ASSERT_DOUBLE_IS_NOT_NAN(0.0 / d_zero); 03477 VERIFY_FAILS_END 03478 #endif 03479 } 03480 03481 void testDoubleIsNotNan1(void) 03482 { 03483 #ifdef UNITY_EXCLUDE_DOUBLE 03484 TEST_IGNORE(); 03485 #else 03486 EXPECT_ABORT_BEGIN 03487 TEST_ASSERT_DOUBLE_IS_NAN(234.9); 03488 VERIFY_FAILS_END 03489 #endif 03490 } 03491 03492 void testDoubleIsNotNan2(void) 03493 { 03494 #ifdef UNITY_EXCLUDE_DOUBLE 03495 TEST_IGNORE(); 03496 #else 03497 TEST_ASSERT_DOUBLE_IS_NOT_NAN(234.9); 03498 #endif 03499 } 03500 03501 void testDoubleInfIsNotNan(void) 03502 { 03503 #ifdef UNITY_EXCLUDE_DOUBLE 03504 TEST_IGNORE(); 03505 #else 03506 EXPECT_ABORT_BEGIN 03507 TEST_ASSERT_DOUBLE_IS_NAN(1.0 / d_zero); 03508 VERIFY_FAILS_END 03509 #endif 03510 } 03511 03512 void testDoubleNanIsNotInf(void) 03513 { 03514 #ifdef UNITY_EXCLUDE_DOUBLE 03515 TEST_IGNORE(); 03516 #else 03517 EXPECT_ABORT_BEGIN 03518 TEST_ASSERT_DOUBLE_IS_INF(0.0 / d_zero); 03519 VERIFY_FAILS_END 03520 #endif 03521 } 03522 03523 void testDoubleIsDeterminate1(void) 03524 { 03525 #ifdef UNITY_EXCLUDE_DOUBLE 03526 TEST_IGNORE(); 03527 #else 03528 TEST_ASSERT_DOUBLE_IS_DETERMINATE(0.0); 03529 TEST_ASSERT_DOUBLE_IS_DETERMINATE(123.3); 03530 TEST_ASSERT_DOUBLE_IS_DETERMINATE(-88.3); 03531 #endif 03532 } 03533 03534 void testDoubleIsDeterminate2(void) 03535 { 03536 #ifdef UNITY_EXCLUDE_DOUBLE 03537 TEST_IGNORE(); 03538 #else 03539 EXPECT_ABORT_BEGIN 03540 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-88.3); 03541 VERIFY_FAILS_END 03542 #endif 03543 } 03544 03545 void testDoubleIsNotDeterminate1(void) 03546 { 03547 #ifdef UNITY_EXCLUDE_DOUBLE 03548 TEST_IGNORE(); 03549 #else 03550 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(1.0 / d_zero); 03551 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-1.0 / d_zero); 03552 TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(0.0 / d_zero); 03553 #endif 03554 } 03555 03556 void testDoubleIsNotDeterminate2(void) 03557 { 03558 #ifdef UNITY_EXCLUDE_DOUBLE 03559 TEST_IGNORE(); 03560 #else 03561 EXPECT_ABORT_BEGIN 03562 TEST_ASSERT_DOUBLE_IS_DETERMINATE(-1.0 / d_zero); 03563 VERIFY_FAILS_END 03564 #endif 03565 } 03566 03567 void testDoubleTraitFailsOnInvalidTrait(void) 03568 { 03569 #ifdef UNITY_EXCLUDE_DOUBLE 03570 TEST_IGNORE(); 03571 #else 03572 EXPECT_ABORT_BEGIN 03573 UnityAssertDoubleSpecial(1.0, NULL, __LINE__, UNITY_FLOAT_INVALID_TRAIT); 03574 VERIFY_FAILS_END 03575 #endif 03576 } 03577 03578 void testEqualDoubleArrays(void) 03579 { 03580 #ifdef UNITY_EXCLUDE_DOUBLE 03581 TEST_IGNORE(); 03582 #else 03583 double p0[] = {1.0, -8.0, 25.4, -0.123}; 03584 double p1[] = {1.0, -8.0, 25.4, -0.123}; 03585 double p2[] = {1.0, -8.0, 25.4, -0.2}; 03586 double p3[] = {1.0, -23.0, 25.0, -0.26}; 03587 03588 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 1); 03589 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p0, 4); 03590 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03591 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p2, 3); 03592 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p3, 1); 03593 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(NULL, NULL, 1); 03594 #endif 03595 } 03596 03597 void testNotEqualDoubleArraysExpectedNull(void) 03598 { 03599 #ifdef UNITY_EXCLUDE_DOUBLE 03600 TEST_IGNORE(); 03601 #else 03602 double* p0 = NULL; 03603 double p1[] = {1.0, 8.0, 25.4, 0.252}; 03604 03605 EXPECT_ABORT_BEGIN 03606 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03607 VERIFY_FAILS_END 03608 #endif 03609 } 03610 03611 void testNotEqualDoubleArraysActualNull(void) 03612 { 03613 #ifdef UNITY_EXCLUDE_DOUBLE 03614 TEST_IGNORE(); 03615 #else 03616 double p0[] = {1.0, 8.0, 25.4, 0.253}; 03617 double* p1 = NULL; 03618 03619 EXPECT_ABORT_BEGIN 03620 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03621 VERIFY_FAILS_END 03622 #endif 03623 } 03624 03625 void testNotEqualDoubleArrays1(void) 03626 { 03627 #ifdef UNITY_EXCLUDE_DOUBLE 03628 TEST_IGNORE(); 03629 #else 03630 double p0[] = {1.0, 8.0, 25.4, 0.25666666667}; 03631 double p1[] = {1.0, 8.0, 25.4, 0.25666666666}; 03632 03633 EXPECT_ABORT_BEGIN 03634 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03635 VERIFY_FAILS_END 03636 #endif 03637 } 03638 03639 void testNotEqualDoubleArrays2(void) 03640 { 03641 #ifdef UNITY_EXCLUDE_DOUBLE 03642 TEST_IGNORE(); 03643 #else 03644 double p0[] = {1.0, 8.0, 25.4, 0.253}; 03645 double p1[] = {2.0, 8.0, 25.4, 0.253}; 03646 03647 EXPECT_ABORT_BEGIN 03648 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03649 VERIFY_FAILS_END 03650 #endif 03651 } 03652 03653 void testNotEqualDoubleArrays3(void) 03654 { 03655 #ifdef UNITY_EXCLUDE_DOUBLE 03656 TEST_IGNORE(); 03657 #else 03658 double p0[] = {1.0, 8.0, 25.4, 0.253}; 03659 double p1[] = {1.0, 8.0, 25.5, 0.253}; 03660 03661 EXPECT_ABORT_BEGIN 03662 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03663 VERIFY_FAILS_END 03664 #endif 03665 } 03666 03667 void testNotEqualDoubleArraysNegative1(void) 03668 { 03669 #ifdef UNITY_EXCLUDE_DOUBLE 03670 TEST_IGNORE(); 03671 #else 03672 double p0[] = {-1.0, -8.0, -25.4, -0.2566666667}; 03673 double p1[] = {-1.0, -8.0, -25.4, -0.2566666666}; 03674 03675 EXPECT_ABORT_BEGIN 03676 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03677 VERIFY_FAILS_END 03678 #endif 03679 } 03680 03681 void testNotEqualDoubleArraysNegative2(void) 03682 { 03683 #ifdef UNITY_EXCLUDE_DOUBLE 03684 TEST_IGNORE(); 03685 #else 03686 double p0[] = {-1.0, -8.0, -25.4, -0.253}; 03687 double p1[] = {-2.0, -8.0, -25.4, -0.253}; 03688 03689 EXPECT_ABORT_BEGIN 03690 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03691 VERIFY_FAILS_END 03692 #endif 03693 } 03694 03695 void testNotEqualDoubleArraysNegative3(void) 03696 { 03697 #ifdef UNITY_EXCLUDE_DOUBLE 03698 TEST_IGNORE(); 03699 #else 03700 double p0[] = {-1.0, -8.0, -25.4, -0.253}; 03701 double p1[] = {-1.0, -8.0, -25.5, -0.253}; 03702 03703 EXPECT_ABORT_BEGIN 03704 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03705 VERIFY_FAILS_END 03706 #endif 03707 } 03708 03709 void testNotEqualDoubleArraysNaN(void) 03710 { 03711 #ifdef UNITY_EXCLUDE_DOUBLE 03712 TEST_IGNORE(); 03713 #else 03714 double p0[] = {1.0, 0.0 / d_zero, 25.4, 0.253}; 03715 double p1[] = {1.0, 0.0 / d_zero, 25.4, 0.253}; 03716 03717 EXPECT_ABORT_BEGIN 03718 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03719 VERIFY_FAILS_END 03720 #endif 03721 } 03722 03723 void testNotEqualDoubleArraysInf(void) 03724 { 03725 #ifdef UNITY_EXCLUDE_DOUBLE 03726 TEST_IGNORE(); 03727 #else 03728 double p0[] = {1.0, 1.0 / d_zero, 25.4, 0.253}; 03729 double p1[] = {1.0, 1.0 / d_zero, 25.4, 0.253}; 03730 03731 EXPECT_ABORT_BEGIN 03732 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4); 03733 VERIFY_FAILS_END 03734 #endif 03735 } 03736 03737 void testNotEqualDoubleArraysLengthZero(void) 03738 { 03739 #ifdef UNITY_EXCLUDE_DOUBLE 03740 TEST_IGNORE(); 03741 #else 03742 double p0[1] = {0.0}; 03743 double p1[1] = {0.0}; 03744 03745 EXPECT_ABORT_BEGIN 03746 TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 0); 03747 VERIFY_FAILS_END 03748 #endif 03749 } 03750 03751 // ===================== THESE TEST WILL RUN IF YOUR CONFIG INCLUDES DETAIL SUPPORT ================== 03752 03753 void testThatDetailsCanBeHandleOneDetail(void) 03754 { 03755 #ifdef UNITY_EXCLUDE_DETAILS 03756 TEST_IGNORE(); 03757 #else 03758 UNITY_SET_DETAIL("Detail1"); 03759 03760 EXPECT_ABORT_BEGIN 03761 TEST_ASSERT_EQUAL_INT_MESSAGE(5, 6, "Should Fail And Say Detail1"); 03762 VERIFY_FAILS_END 03763 #endif 03764 } 03765 03766 void testThatDetailsCanHandleTestFail(void) 03767 { 03768 #ifdef UNITY_EXCLUDE_DETAILS 03769 TEST_IGNORE(); 03770 #else 03771 UNITY_SET_DETAILS("Detail1","Detail2"); 03772 03773 EXPECT_ABORT_BEGIN 03774 TEST_FAIL_MESSAGE("Should Fail And Say Detail1 and Detail2"); 03775 VERIFY_FAILS_END 03776 #endif 03777 } 03778 03779 void testThatDetailsCanBeHandleTwoDetails(void) 03780 { 03781 #ifdef UNITY_EXCLUDE_DETAILS 03782 TEST_IGNORE(); 03783 #else 03784 UNITY_SET_DETAILS("Detail1","Detail2"); 03785 03786 EXPECT_ABORT_BEGIN 03787 TEST_ASSERT_EQUAL_HEX8_MESSAGE(7, 8, "Should Fail And Say Detail1 and Detail2"); 03788 VERIFY_FAILS_END 03789 #endif 03790 } 03791 03792 void testThatDetailsCanBeHandleSingleDetailClearingTwoDetails(void) 03793 { 03794 #ifdef UNITY_EXCLUDE_DETAILS 03795 TEST_IGNORE(); 03796 #else 03797 UNITY_SET_DETAILS("Detail1","Detail2"); 03798 UNITY_SET_DETAIL("DetailNew"); 03799 03800 EXPECT_ABORT_BEGIN 03801 TEST_ASSERT_EQUAL_STRING_MESSAGE("MEH", "GUH", "Should Fail And Say DetailNew"); 03802 VERIFY_FAILS_END 03803 #endif 03804 }
Generated on Tue Jul 12 2022 16:24:22 by
1.7.2