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 }