ceedling 0.15.1 → 0.15.2

data/vendor/unity/test/testunity.c

@@ -9,7 +9,10 @@
 
 // Dividing by these constants produces +/- infinity.
 // The rationale is given in UnityAssertFloatIsInf's body.
+#ifndef UNITY_EXCLUDE_FLOAT
 static const _UF f_zero = 0.0f;
+#endif
+
 #ifndef UNITY_EXCLUDE_DOUBLE
 static const _UD d_zero = 0.0;
 #endif
@@ -17,7 +20,7 @@ static const _UD d_zero = 0.0;
 #define EXPECT_ABORT_BEGIN \
     if (TEST_PROTECT())    \
     {
-    
+
 #define VERIFY_FAILS_END                                                       \
     }                                                                          \
     Unity.CurrentTestFailed = (Unity.CurrentTestFailed == 1) ? 0 : 1;          \
@@ -26,7 +29,7 @@ static const _UD d_zero = 0.0;
       UnityPrint("[[[[ Previous Test Should Have Failed But Did Not ]]]]");    \
       UNITY_OUTPUT_CHAR('\n');                                                 \
     }
-    
+
 #define VERIFY_IGNORES_END                                                     \
     }                                                                          \
     Unity.CurrentTestFailed = (Unity.CurrentTestIgnored == 1) ? 0 : 1;         \
@@ -62,7 +65,7 @@ void testUnitySizeInitializationReminder(void)
     /* This test ensures that sizeof(struct _Unity) doesn't change. If this
      * test breaks, go look at the initialization of the Unity global variable
      * in unity.c and make sure we're filling in the proper fields. */
-    char * message = "Unexpected size for _Unity struct. Please check that "
+    const char* message = "Unexpected size for _Unity struct. Please check that "
                      "the initialization of the Unity symbol in unity.c is "
                      "still correct.";
 
@@ -151,16 +154,16 @@ void testFail(void)
 void testIsNull(void)
 {
     char* ptr1 = NULL;
-    char* ptr2 = "hello";
-    
+    const char* ptr2 = "hello";
+
     TEST_ASSERT_NULL(ptr1);
     TEST_ASSERT_NOT_NULL(ptr2);
 }
 
 void testIsNullShouldFailIfNot(void)
 {
-    char* ptr1 = "hello";
-    
+    const char* ptr1 = "hello";
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_NULL(ptr1);
     VERIFY_FAILS_END
@@ -169,7 +172,7 @@ void testIsNullShouldFailIfNot(void)
 void testNotNullShouldFailIfNULL(void)
 {
     char* ptr1 = NULL;
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_NOT_NULL(ptr1);
     VERIFY_FAILS_END
@@ -229,7 +232,7 @@ void testNotEqualBits(void)
 void testNotEqualUInts(void)
 {
     _UU16 v0, v1;
-    
+
     v0 = 9000;
     v1 = 9001;
 
@@ -241,7 +244,7 @@ void testNotEqualUInts(void)
 void testNotEqualUInt8s(void)
 {
     _UU8 v0, v1;
-    
+
     v0 = 254;
     v1 = 255;
 
@@ -253,7 +256,7 @@ void testNotEqualUInt8s(void)
 void testNotEqualUInt16s(void)
 {
     _UU16 v0, v1;
-    
+
     v0 = 65535;
     v1 = 65534;
 
@@ -265,7 +268,7 @@ void testNotEqualUInt16s(void)
 void testNotEqualUInt32s(void)
 {
     _UU32 v0, v1;
-    
+
     v0 = 4294967295;
     v1 = 4294967294;
 
@@ -277,7 +280,7 @@ void testNotEqualUInt32s(void)
 void testNotEqualHex8s(void)
 {
     _UU8 v0, v1;
-    
+
     v0 = 0x23;
     v1 = 0x22;
 
@@ -289,7 +292,7 @@ void testNotEqualHex8s(void)
 void testNotEqualHex8sIfSigned(void)
 {
     _US8 v0, v1;
-    
+
     v0 = -2;
     v1 = 2;
 
@@ -301,7 +304,7 @@ void testNotEqualHex8sIfSigned(void)
 void testNotEqualHex16s(void)
 {
     _UU16 v0, v1;
-    
+
     v0 = 0x1234;
     v1 = 0x1235;
 
@@ -313,7 +316,7 @@ void testNotEqualHex16s(void)
 void testNotEqualHex16sIfSigned(void)
 {
     _US16 v0, v1;
-    
+
     v0 = -1024;
     v1 = -1028;
 
@@ -325,7 +328,7 @@ void testNotEqualHex16sIfSigned(void)
 void testNotEqualHex32s(void)
 {
     _UU32 v0, v1;
-    
+
     v0 = 900000;
     v1 = 900001;
 
@@ -337,7 +340,7 @@ void testNotEqualHex32s(void)
 void testNotEqualHex32sIfSigned(void)
 {
     _US32 v0, v1;
-    
+
     v0 = -900000;
     v1 = 900001;
 
@@ -350,7 +353,7 @@ void testEqualInts(void)
 {
     int v0, v1;
     int *p0, *p1;
-    
+
     v0 = 19467;
     v1 = 19467;
     p0 = &v0;
@@ -370,7 +373,7 @@ void testEqualInt8s(void)
 {
     _US8 v0, v1;
     _US8 *p0, *p1;
-    
+
     v0 = 0x22;
     v1 = 0x22;
     p0 = &v0;
@@ -395,7 +398,7 @@ void testEqualInt16s(void)
 {
     _US16 v0, v1;
     _US16 *p0, *p1;
-    
+
     v0 = 0x7876;
     v1 = 0x7876;
     p0 = &v0;
@@ -414,7 +417,7 @@ void testEqualInt16sNegatives(void)
 {
     _US16 v0, v1;
     _US16 *p0, *p1;
-    
+
     v0 = -7876;
     v1 = -7876;
     p0 = &v0;
@@ -439,12 +442,12 @@ void testEqualInt32s(void)
 {
     _US32 v0, v1;
     _US32 *p0, *p1;
-    
+
     v0 = 0x78760000;
     v1 = 0x78760000;
     p0 = &v0;
     p1 = &v1;
-    
+
     TEST_ASSERT_EQUAL_INT32(0x78760000, 0x78760000);
     TEST_ASSERT_EQUAL_INT32(v0, v1);
     TEST_ASSERT_EQUAL_INT32(0x78760000, v1);
@@ -458,12 +461,12 @@ void testEqualInt32sNegatives(void)
 {
     _US32 v0, v1;
     _US32 *p0, *p1;
-    
+
     v0 = -123456789;
     v1 = -123456789;
     p0 = &v0;
     p1 = &v1;
-    
+
     TEST_ASSERT_EQUAL_INT32(-123456789, -123456789);
     TEST_ASSERT_EQUAL_INT32(v0, v1);
     TEST_ASSERT_EQUAL_INT32(-123456789, v1);
@@ -478,7 +481,7 @@ void testEqualUints(void)
 {
     unsigned int v0, v1;
     unsigned int *p0, *p1;
-    
+
     v0 = 19467;
     v1 = 19467;
     p0 = &v0;
@@ -499,7 +502,7 @@ void testEqualUint8s(void)
 {
     _UU8 v0, v1;
     _UU8 *p0, *p1;
-    
+
     v0 = 0x22;
     v1 = 0x22;
     p0 = &v0;
@@ -524,7 +527,7 @@ void testEqualUint16s(void)
 {
     _UU16 v0, v1;
     _UU16 *p0, *p1;
-    
+
     v0 = 0x9876;
     v1 = 0x9876;
     p0 = &v0;
@@ -549,12 +552,12 @@ void testEqualUint32s(void)
 {
     _UU32 v0, v1;
     _UU32 *p0, *p1;
-    
+
     v0 = 0x98760000;
     v1 = 0x98760000;
     p0 = &v0;
     p1 = &v1;
-    
+
     TEST_ASSERT_EQUAL_UINT32(0x98760000, 0x98760000);
     TEST_ASSERT_EQUAL_UINT32(v0, v1);
     TEST_ASSERT_EQUAL_UINT32(0x98760000, v1);
@@ -579,7 +582,7 @@ void testEqualHex8s(void)
 {
     _UU8 v0, v1;
     _UU8 *p0, *p1;
-    
+
     v0 = 0x22;
     v1 = 0x22;
     p0 = &v0;
@@ -604,7 +607,7 @@ void testEqualHex8sNegatives(void)
 {
     _UU8 v0, v1;
     _UU8 *p0, *p1;
-    
+
     v0 = 0xDD;
     v1 = 0xDD;
     p0 = &v0;
@@ -623,7 +626,7 @@ void testEqualHex16s(void)
 {
     _UU16 v0, v1;
     _UU16 *p0, *p1;
-    
+
     v0 = 0x9876;
     v1 = 0x9876;
     p0 = &v0;
@@ -648,7 +651,7 @@ void testEqualHex32s(void)
 {
     _UU32 v0, v1;
     _UU32 *p0, *p1;
-    
+
     v0 = 0x98765432ul;
     v1 = 0x98765432ul;
     p0 = &v0;
@@ -682,7 +685,7 @@ void testEqualBits(void)
 void testNotEqualBitHigh(void)
 {
     _UU32 v0 = 0x7F55AA00;
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_BIT_HIGH(31, v0);
     VERIFY_FAILS_END
@@ -691,7 +694,7 @@ void testNotEqualBitHigh(void)
 void testNotEqualBitLow(void)
 {
     _UU32 v0 = 0xFF55AA00;
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_BIT_LOW(30, v0);
     VERIFY_FAILS_END
@@ -701,18 +704,18 @@ void testNotEqualBitsHigh(void)
 {
     _UU32 v0 = 0xFF55AA00;
     _UU32 v1 = 0x55550000;
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_BITS_HIGH(v0, v1);
     VERIFY_FAILS_END
-    
+
 }
 
 void testNotEqualBitsLow(void)
 {
     _UU32 v0 = 0xFF55AA00;
     _UU32 v1 = 0x55550000;
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_BITS_LOW(v0, v1);
     VERIFY_FAILS_END
@@ -722,7 +725,7 @@ void testEqualShorts(void)
 {
     short v0, v1;
     short *p0, *p1;
-    
+
     v0 = 19467;
     v1 = 19467;
     p0 = &v0;
@@ -742,7 +745,7 @@ void testEqualUShorts(void)
 {
     unsigned short v0, v1;
     unsigned short *p0, *p1;
-    
+
     v0 = 19467;
     v1 = 19467;
     p0 = &v0;
@@ -762,7 +765,7 @@ void testEqualChars(void)
 {
     signed char v0, v1;
     signed char *p0, *p1;
-    
+
     v0 = 109;
     v1 = 109;
     p0 = &v0;
@@ -782,7 +785,7 @@ void testEqualUChars(void)
 {
     unsigned char v0, v1;
     unsigned char *p0, *p1;
-    
+
     v0 = 251;
     v1 = 251;
     p0 = &v0;
@@ -801,7 +804,7 @@ void testEqualPointers(void)
 {
     int v0, v1;
     int *p0, *p1, *p2;
-    
+
     v0 = 19467;
     v1 = 18271;
     p0 = &v0;
@@ -827,7 +830,7 @@ void testIntsWithinDelta(void)
     TEST_ASSERT_INT_WITHIN(5, 5000, 4996);
     TEST_ASSERT_INT_WITHIN(5, 5000, 5005);
     TEST_ASSERT_INT_WITHIN(500, 50, -440);
-    
+
     TEST_ASSERT_INT_WITHIN(2, -1, -1);
     TEST_ASSERT_INT_WITHIN(5, 1, -1);
     TEST_ASSERT_INT_WITHIN(5, -1, 1);
@@ -839,7 +842,7 @@ void testIntsWithinDeltaAndCustomMessage(void)
     TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
     TEST_ASSERT_INT_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
     TEST_ASSERT_INT_WITHIN_MESSAGE(500, 50, -440, "Custom Message.");
-    
+
     TEST_ASSERT_INT_WITHIN_MESSAGE(2, -1, -1, "Custom Message.");
     TEST_ASSERT_INT_WITHIN_MESSAGE(5, 1, -1, "Custom Message.");
     TEST_ASSERT_INT_WITHIN_MESSAGE(5, -1, 1, "Custom Message.");
@@ -973,12 +976,12 @@ void testHEX16sWithinDeltaAndCustomMessage(void)
 
 void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)
 {
-    TEST_ASSERT_HEX16_WITHIN(5, 0x54321, 0x44321); 
+    TEST_ASSERT_HEX16_WITHIN(5, 0x54321, 0x44321);
 }
 
 void testHEX16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)
 {
-    TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message."); 
+    TEST_ASSERT_HEX16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message.");
 }
 
 void testHEX16sNotWithinDelta(void)
@@ -1011,12 +1014,12 @@ void testHEX8sWithinDeltaAndCustomMessage(void)
 
 void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)
 {
-    TEST_ASSERT_HEX8_WITHIN(5, 0x123, 0xF23); 
+    TEST_ASSERT_HEX8_WITHIN(5, 0x123, 0xF23);
 }
 
 void testHEX8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)
 {
-    TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message."); 
+    TEST_ASSERT_HEX8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message.");
 }
 
 void testHEX8sNotWithinDelta(void)
@@ -1033,6 +1036,224 @@ void testHEX8sNotWithinDeltaAndCustomMessage(void)
     VERIFY_FAILS_END
 }
 
+//-----------------
+
+void testUINT32sWithinDelta(void)
+{
+    TEST_ASSERT_UINT32_WITHIN(1, 5000, 5001);
+    TEST_ASSERT_UINT32_WITHIN(5, 5000, 4996);
+    TEST_ASSERT_UINT32_WITHIN(5, 5000, 5005);
+}
+
+void testUINT32sWithinDeltaAndCustomMessage(void)
+{
+    TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
+    TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
+    TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
+}
+
+void testUINT32sNotWithinDelta(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_UINT32_WITHIN(1, 2147483647u, 2147483649u);
+    VERIFY_FAILS_END
+}
+
+void testUINT32sNotWithinDeltaAndCustomMessage(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_UINT32_WITHIN_MESSAGE(1, 2147483647u, 2147483649u, "Custom Message.");
+    VERIFY_FAILS_END
+}
+
+void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_UINT32_WITHIN(5, 1, -1);
+    VERIFY_FAILS_END
+}
+
+void testUINT32sNotWithinDeltaEvenThoughASignedIntWouldPassAndCustomMessage(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_UINT32_WITHIN_MESSAGE(5, 1, -1, "Custom Message.");
+    VERIFY_FAILS_END
+}
+
+void testUINT16sWithinDelta(void)
+{
+    TEST_ASSERT_UINT16_WITHIN(1, 5000, 5001);
+    TEST_ASSERT_UINT16_WITHIN(5, 5000, 4996);
+    TEST_ASSERT_UINT16_WITHIN(5, 5000, 5005);
+}
+
+void testUINT16sWithinDeltaAndCustomMessage(void)
+{
+    TEST_ASSERT_UINT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
+    TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 4996, "Custom Message.");
+    TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 5000, 5005, "Custom Message.");
+}
+
+void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)
+{
+    TEST_ASSERT_UINT16_WITHIN(5, 0x54321, 0x44321);
+}
+
+void testUINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)
+{
+    TEST_ASSERT_UINT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message.");
+}
+
+void testUINT16sNotWithinDelta(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_UINT16_WITHIN(2, 65535, 0);
+    VERIFY_FAILS_END
+}
+
+void testUINT16sNotWithinDeltaAndCustomMessage(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_UINT16_WITHIN_MESSAGE(2, 65535, 0, "Custom Message.");
+    VERIFY_FAILS_END
+}
+
+void testUINT8sWithinDelta(void)
+{
+    TEST_ASSERT_UINT8_WITHIN(1, 254, 255);
+    TEST_ASSERT_UINT8_WITHIN(5, 251, 255);
+    TEST_ASSERT_UINT8_WITHIN(5, 1, 4);
+}
+
+void testUINT8sWithinDeltaAndCustomMessage(void)
+{
+    TEST_ASSERT_UINT8_WITHIN_MESSAGE(1, 254, 255, "Custom Message.");
+    TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 251, 255, "Custom Message.");
+    TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message.");
+}
+
+void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)
+{
+    TEST_ASSERT_UINT8_WITHIN(5, 0x123, 0xF23);
+}
+
+void testUINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)
+{
+    TEST_ASSERT_UINT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message.");
+}
+
+void testUINT8sNotWithinDelta(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_UINT8_WITHIN(2, 255, 0);
+    VERIFY_FAILS_END
+}
+
+void testUINT8sNotWithinDeltaAndCustomMessage(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_UINT8_WITHIN_MESSAGE(2, 255, 0, "Custom Message.");
+    VERIFY_FAILS_END
+}
+
+void testINT32sWithinDelta(void)
+{
+    TEST_ASSERT_INT32_WITHIN(1, 5000, 5001);
+    TEST_ASSERT_INT32_WITHIN(5, 1, -2);
+    TEST_ASSERT_INT32_WITHIN(5, -2, 1);
+}
+
+void testINT32sWithinDeltaAndCustomMessage(void)
+{
+    TEST_ASSERT_INT32_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
+}
+
+void testINT32sNotWithinDelta(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_INT32_WITHIN(1, -3, 1);
+    VERIFY_FAILS_END
+}
+
+void testINT32sNotWithinDeltaAndCustomMessage(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_INT32_WITHIN_MESSAGE(1, -2, 1, "Custom Message.");
+    VERIFY_FAILS_END
+}
+
+void testINT16sWithinDelta(void)
+{
+    TEST_ASSERT_INT16_WITHIN(1, 5000, 5001);
+    TEST_ASSERT_INT16_WITHIN(5, 2, -2);
+    TEST_ASSERT_INT16_WITHIN(5, -2, 2);
+}
+
+void testINT16sWithinDeltaAndCustomMessage(void)
+{
+    TEST_ASSERT_INT16_WITHIN_MESSAGE(1, 5000, 5001, "Custom Message.");
+}
+
+void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16Bits(void)
+{
+    TEST_ASSERT_INT16_WITHIN(5, 0x54321, 0x44321);
+}
+
+void testINT16sWithinDeltaWhenThereAreDifferenceOutsideOf16BitsAndCustomMessage(void)
+{
+    TEST_ASSERT_INT16_WITHIN_MESSAGE(5, 0x54321, 0x44321, "Custom Message.");
+}
+
+void testINT16sNotWithinDelta(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_INT16_WITHIN(2, 4, -2);
+    VERIFY_FAILS_END
+}
+
+void testINT16sNotWithinDeltaAndCustomMessage(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_INT16_WITHIN_MESSAGE(2, 3, 0, "Custom Message.");
+    VERIFY_FAILS_END
+}
+
+void testINT8sWithinDelta(void)
+{
+    TEST_ASSERT_INT8_WITHIN(1, 127, 126);
+    TEST_ASSERT_INT8_WITHIN(5, -2, 2);
+    TEST_ASSERT_INT8_WITHIN(5, 2, -2);
+}
+
+void testINT8sWithinDeltaAndCustomMessage(void)
+{
+    TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 1, 4, "Custom Message.");
+}
+
+void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8Bits(void)
+{
+    TEST_ASSERT_INT8_WITHIN(5, 0x123, 0xF23);
+}
+
+void testINT8sWithinDeltaWhenThereAreDifferenceOutsideOf8BitsAndCustomMessage(void)
+{
+    TEST_ASSERT_INT8_WITHIN_MESSAGE(5, 0x123, 0xF23, "Custom Message.");
+}
+
+void testINT8sNotWithinDelta(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_INT8_WITHIN(2, -3, 0);
+    VERIFY_FAILS_END
+}
+
+void testINT8sNotWithinDeltaAndCustomMessage(void)
+{
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_INT8_WITHIN_MESSAGE(2, -4, 0, "Custom Message.");
+    VERIFY_FAILS_END
+}
+
 void testEqualStrings(void)
 {
     const char *testString = "foo";
@@ -1188,7 +1409,7 @@ void testEqualStringArrayIfBothNulls(void)
 void testEqualMemory(void)
 {
     const char *testString = "whatever";
-    
+
     TEST_ASSERT_EQUAL_MEMORY(testString, testString, 8);
     TEST_ASSERT_EQUAL_MEMORY("whatever", "whatever", 8);
     TEST_ASSERT_EQUAL_MEMORY("whatever", testString, 8);
@@ -1467,7 +1688,7 @@ void testEqualInt32Arrays(void)
     _US32 p1[] = {1, 8, 117, 3};
     _US32 p2[] = {1, 8, 117, 2};
     _US32 p3[] = {1, 50, 60, 70};
-    
+
     TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 1);
     TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p0, 4);
     TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4);
@@ -1479,7 +1700,7 @@ void testNotEqualInt32Arrays(void)
 {
     _US32 p0[] = {1, 8, 127, 3};
     _US32 p1[] = {1, 8, 127, 2};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_INT32_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1491,7 +1712,7 @@ void testEqualUINT8Arrays(void)
     _UU8 p1[] = {1, 8, 100, 127};
     _UU8 p2[] = {1, 8, 100, 2};
     _UU8 p3[] = {1, 50, 60, 70};
-    
+
     TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 1);
     TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p0, 4);
     TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
@@ -1503,7 +1724,7 @@ void testNotEqualUINT8Arrays1(void)
 {
     unsigned char p0[] = {1, 8, 100, 127u};
     unsigned char p1[] = {1, 8, 100, 255u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1513,7 +1734,7 @@ void testNotEqualUINT8Arrays2(void)
 {
     unsigned char p0[] = {1, 8, 100, 127u};
     unsigned char p1[] = {1, 8, 100, 255u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1523,7 +1744,7 @@ void testNotEqualUINT8Arrays3(void)
 {
     unsigned char p0[] = {1, 8, 100, 127u};
     unsigned char p1[] = {1, 8, 100, 255u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT8_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1536,7 +1757,7 @@ void testEqualUINT16Arrays(void)
     unsigned short p1[] = {1, 8, 987, 65132u};
     unsigned short p2[] = {1, 8, 987, 2};
     unsigned short p3[] = {1, 500, 600, 700};
-    
+
     TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 1);
     TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p0, 4);
     TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
@@ -1548,7 +1769,7 @@ void testNotEqualUINT16Arrays1(void)
 {
     unsigned short p0[] = {1, 8, 987, 65132u};
     unsigned short p1[] = {1, 8, 987, 65131u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1558,7 +1779,7 @@ void testNotEqualUINT16Arrays2(void)
 {
     unsigned short p0[] = {1, 8, 987, 65132u};
     unsigned short p1[] = {2, 8, 987, 65132u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1568,21 +1789,19 @@ void testNotEqualUINT16Arrays3(void)
 {
     unsigned short p0[] = {1, 8, 987, 65132u};
     unsigned short p1[] = {1, 8, 986, 65132u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT16_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
 }
 
-
-
 void testEqualUINT32Arrays(void)
 {
     _UU32 p0[] = {1, 8, 987, 65132u};
     _UU32 p1[] = {1, 8, 987, 65132u};
     _UU32 p2[] = {1, 8, 987, 2};
     _UU32 p3[] = {1, 500, 600, 700};
-    
+
     TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 1);
     TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p0, 4);
     TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
@@ -1594,7 +1813,7 @@ void testNotEqualUINT32Arrays1(void)
 {
     _UU32 p0[] = {1, 8, 987, 65132u};
     _UU32 p1[] = {1, 8, 987, 65131u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1604,7 +1823,7 @@ void testNotEqualUINT32Arrays2(void)
 {
     _UU32 p0[] = {1, 8, 987, 65132u};
     _UU32 p1[] = {2, 8, 987, 65132u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1614,7 +1833,7 @@ void testNotEqualUINT32Arrays3(void)
 {
     _UU32 p0[] = {1, 8, 987, 65132u};
     _UU32 p1[] = {1, 8, 986, 65132u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT32_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1622,10 +1841,10 @@ void testNotEqualUINT32Arrays3(void)
 
 void testEqualHEXArrays(void)
 {
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {1, 8, 987, 65132u};
-    unsigned int p2[] = {1, 8, 987, 2};
-    unsigned int p3[] = {1, 500, 600, 700};
+    _UU32 p0[] = {1, 8, 987, 65132u};
+    _UU32 p1[] = {1, 8, 987, 65132u};
+    _UU32 p2[] = {1, 8, 987, 2};
+    _UU32 p3[] = {1, 500, 600, 700};
 
     TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 1);
     TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p0, 4);
@@ -1636,8 +1855,8 @@ void testEqualHEXArrays(void)
 
 void testNotEqualHEXArrays1(void)
 {
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {1, 8, 987, 65131u};
+    _UU32 p0[] = {1, 8, 987, 65132u};
+    _UU32 p1[] = {1, 8, 987, 65131u};
 
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
@@ -1646,8 +1865,8 @@ void testNotEqualHEXArrays1(void)
 
 void testNotEqualHEXArrays2(void)
 {
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {2, 8, 987, 65132u};
+    _UU32 p0[] = {1, 8, 987, 65132u};
+    _UU32 p1[] = {2, 8, 987, 65132u};
 
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
@@ -1656,8 +1875,8 @@ void testNotEqualHEXArrays2(void)
 
 void testNotEqualHEXArrays3(void)
 {
-    unsigned int p0[] = {1, 8, 987, 65132u};
-    unsigned int p1[] = {1, 8, 986, 65132u};
+    _UU32 p0[] = {1, 8, 987, 65132u};
+    _UU32 p1[] = {1, 8, 986, 65132u};
 
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_HEX_ARRAY(p0, p1, 4);
@@ -1670,7 +1889,7 @@ void testEqualHEX32Arrays(void)
     _UU32 p1[] = {1, 8, 987, 65132u};
     _UU32 p2[] = {1, 8, 987, 2};
     _UU32 p3[] = {1, 500, 600, 700};
-    
+
     TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 1);
     TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p0, 4);
     TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
@@ -1682,7 +1901,7 @@ void testNotEqualHEX32Arrays1(void)
 {
     _UU32 p0[] = {1, 8, 987, 65132u};
     _UU32 p1[] = {1, 8, 987, 65131u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1692,7 +1911,7 @@ void testNotEqualHEX32Arrays2(void)
 {
     _UU32 p0[] = {1, 8, 987, 65132u};
     _UU32 p1[] = {2, 8, 987, 65132u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1702,7 +1921,7 @@ void testNotEqualHEX32Arrays3(void)
 {
     _UU32 p0[] = {1, 8, 987, 65132u};
     _UU32 p1[] = {1, 8, 986, 65132u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_HEX32_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -1893,7 +2112,7 @@ void testEqualHex64s(void)
 #else
     _UU64 v0, v1;
     _UU64 *p0, *p1;
-    
+
     v0 = 0x9876543201234567;
     v1 = 0x9876543201234567;
     p0 = &v0;
@@ -1916,12 +2135,12 @@ void testEqualUint64s(void)
 #else
     _UU64 v0, v1;
     _UU64 *p0, *p1;
-    
+
     v0 = 0x9876543201234567;
     v1 = 0x9876543201234567;
     p0 = &v0;
     p1 = &v1;
-    
+
     TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, 0x9876543201234567);
     TEST_ASSERT_EQUAL_UINT64(v0, v1);
     TEST_ASSERT_EQUAL_UINT64(0x9876543201234567, v1);
@@ -1939,12 +2158,12 @@ void testEqualInt64s(void)
 #else
     _US64 v0, v1;
     _US64 *p0, *p1;
-    
-    v0 = 0x9876543201234567;
-    v1 = 0x9876543201234567;
+
+    v0 = (_US64)0x9876543201234567;
+    v1 = (_US64)0x9876543201234567;
     p0 = &v0;
     p1 = &v1;
-    
+
     TEST_ASSERT_EQUAL_INT64(0x9876543201234567, 0x9876543201234567);
     TEST_ASSERT_EQUAL_INT64(v0, v1);
     TEST_ASSERT_EQUAL_INT64(0x9876543201234567, v1);
@@ -1962,7 +2181,7 @@ void testNotEqualHex64s(void)
     TEST_IGNORE();
 #else
     _UU64 v0, v1;
-    
+
     v0 = 9000000000;
     v1 = 9100000000;
 
@@ -1978,10 +2197,10 @@ void testNotEqualUint64s(void)
     TEST_IGNORE();
 #else
     _UU64 v0, v1;
-    
+
     v0 = 9000000000;
     v1 = 9100000000;
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT64(v0, v1);
     VERIFY_FAILS_END
@@ -1994,10 +2213,10 @@ void testNotEqualInt64s(void)
     TEST_IGNORE();
 #else
     _US64 v0, v1;
-    
+
     v0 = -9000000000;
     v1 = 9100000000;
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_INT64(v0, v1);
     VERIFY_FAILS_END
@@ -2010,7 +2229,7 @@ void testNotEqualHex64sIfSigned(void)
     TEST_IGNORE();
 #else
     _US64 v0, v1;
-    
+
     v0 = -9000000000;
     v1 = 9000000000;
 
@@ -2053,6 +2272,61 @@ void testHEX64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
 #endif
 }
 
+void testUINT64sWithinDelta(void)
+{
+#ifndef UNITY_SUPPORT_64
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
+    TEST_ASSERT_UINT64_WITHIN(5, 5000, 4996);
+    TEST_ASSERT_UINT64_WITHIN(5, 5000, 5005);
+#endif
+}
+
+void testUINT64sNotWithinDelta(void)
+{
+#ifndef UNITY_SUPPORT_64
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_UINT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
+    VERIFY_FAILS_END
+#endif
+}
+
+void testUINT64sNotWithinDeltaEvenThoughASignedIntWouldPass(void)
+{
+#ifndef UNITY_SUPPORT_64
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_UINT64_WITHIN(5, 1, -1);
+    VERIFY_FAILS_END
+#endif
+}
+
+void testINT64sWithinDelta(void)
+{
+#ifndef UNITY_SUPPORT_64
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF,0x7FFFFFFFFFFFFFFE);
+    TEST_ASSERT_INT64_WITHIN(5, 5000, 4996);
+    TEST_ASSERT_INT64_WITHIN(5, 5000, 5005);
+#endif
+}
+
+void testINT64sNotWithinDelta(void)
+{
+#ifndef UNITY_SUPPORT_64
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_INT64_WITHIN(1, 0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFC);
+    VERIFY_FAILS_END
+#endif
+}
+
 void testEqualHEX64Arrays(void)
 {
 #ifndef UNITY_SUPPORT_64
@@ -2080,7 +2354,7 @@ void testEqualUint64Arrays(void)
     _UU64 p1[] = {1, 8, 987, 65132u};
     _UU64 p2[] = {1, 8, 987, 2};
     _UU64 p3[] = {1, 500, 600, 700};
-    
+
     TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 1);
     TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p0, 4);
     TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4);
@@ -2098,7 +2372,7 @@ void testEqualInt64Arrays(void)
     _US64 p1[] = {1, 8, 987, -65132};
     _US64 p2[] = {1, 8, 987, -2};
     _US64 p3[] = {1, 500, 600, 700};
-    
+
     TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 1);
     TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p0, 4);
     TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4);
@@ -2143,7 +2417,7 @@ void testNotEqualUint64Arrays(void)
 #else
     _UU64 p0[] = {1, 8, 987, 65132u};
     _UU64 p1[] = {1, 8, 987, 65131u};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_UINT64_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -2157,7 +2431,7 @@ void testNotEqualInt64Arrays(void)
 #else
     _US64 p0[] = {1, 8, 987, -65132};
     _US64 p1[] = {1, 8, 987, -65131};
-    
+
     EXPECT_ABORT_BEGIN
     TEST_ASSERT_EQUAL_INT64_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
@@ -2332,17 +2606,47 @@ void testFloatsNotEqualPlusMinusInf(void)
 #endif
 }
 
-void testFloatIsInf(void)
+void testFloatIsPosInf1(void)
 {
 #ifdef UNITY_EXCLUDE_FLOAT
     TEST_IGNORE();
 #else
     TEST_ASSERT_FLOAT_IS_INF(2.0f / f_zero);
+#endif
+}
+
+void testFloatIsPosInf2(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f / f_zero);
+    VERIFY_FAILS_END
+#endif
+}
+
+void testFloatIsNegInf1(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
     TEST_ASSERT_FLOAT_IS_NEG_INF(-3.0f / f_zero);
 #endif
 }
 
-void testFloatIsNotInf(void)
+void testFloatIsNegInf2(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_FLOAT_IS_NOT_NEG_INF(-3.0f / f_zero);
+    VERIFY_FAILS_END
+#endif
+}
+
+void testFloatIsNotPosInf1(void)
 {
 #ifdef UNITY_EXCLUDE_FLOAT
     TEST_IGNORE();
@@ -2353,6 +2657,15 @@ void testFloatIsNotInf(void)
 #endif
 }
 
+void testFloatIsNotPosInf2(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_FLOAT_IS_NOT_INF(2.0f);
+#endif
+}
+
 void testFloatIsNotNegInf(void)
 {
 #ifdef UNITY_EXCLUDE_FLOAT
@@ -2364,16 +2677,27 @@ void testFloatIsNotNegInf(void)
 #endif
 }
 
-void testFloatIsNan(void)
+void testFloatIsNan1(void)
 {
 #ifdef UNITY_EXCLUDE_FLOAT
     TEST_IGNORE();
 #else
-    TEST_ASSERT_FLOAT_IS_NAN(0.0f / f_zero);    
+    TEST_ASSERT_FLOAT_IS_NAN(0.0f / f_zero);
 #endif
 }
 
-void testFloatIsNotNan(void)
+void testFloatIsNan2(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_FLOAT_IS_NOT_NAN(0.0f / f_zero);
+    VERIFY_FAILS_END
+#endif
+}
+
+void testFloatIsNotNan1(void)
 {
 #ifdef UNITY_EXCLUDE_FLOAT
     TEST_IGNORE();
@@ -2384,6 +2708,15 @@ void testFloatIsNotNan(void)
 #endif
 }
 
+void testFloatIsNotNan2(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_FLOAT_IS_NOT_NAN(234.9f);
+#endif
+}
+
 void testFloatInfIsNotNan(void)
 {
 #ifdef UNITY_EXCLUDE_FLOAT
@@ -2406,6 +2739,50 @@ void testFloatNanIsNotInf(void)
 #endif
 }
 
+void testFloatIsDeterminate1(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_FLOAT_IS_DETERMINATE(0.0f);
+    TEST_ASSERT_FLOAT_IS_DETERMINATE(123.3f);
+    TEST_ASSERT_FLOAT_IS_DETERMINATE(-88.3f);
+#endif
+}
+
+void testFloatIsDeterminate2(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-88.3f);
+    VERIFY_FAILS_END
+#endif
+}
+
+void testFloatIsNotDeterminate1(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(1.0f / f_zero);
+    TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(-1.0f / f_zero);
+    TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(0.0f / f_zero);
+#endif
+}
+
+void testFloatIsNotDeterminate2(void)
+{
+#ifdef UNITY_EXCLUDE_FLOAT
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_FLOAT_IS_DETERMINATE(-1.0f / f_zero);
+    VERIFY_FAILS_END
+#endif
+}
+
 void testEqualFloatArrays(void)
 {
 #ifdef UNITY_EXCLUDE_FLOAT
@@ -2734,17 +3111,47 @@ void testDoublesNotEqualPlusMinusInf(void)
 #endif
 }
 
-void testDoubleIsInf(void)
+void testDoubleIsPosInf1(void)
 {
 #ifdef UNITY_EXCLUDE_DOUBLE
     TEST_IGNORE();
 #else
     TEST_ASSERT_DOUBLE_IS_INF(2.0 / d_zero);
+#endif
+}
+
+void testDoubleIsPosInf2(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0 / d_zero);
+    VERIFY_FAILS_END
+#endif
+}
+
+void testDoubleIsNegInf1(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
     TEST_ASSERT_DOUBLE_IS_NEG_INF(-3.0 / d_zero);
 #endif
 }
 
-void testDoubleIsNotInf(void)
+void testDoubleIsNegInf2(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_DOUBLE_IS_NOT_NEG_INF(-3.0 / d_zero);
+    VERIFY_FAILS_END
+#endif
+}
+
+void testDoubleIsNotPosInf1(void)
 {
 #ifdef UNITY_EXCLUDE_DOUBLE
     TEST_IGNORE();
@@ -2755,6 +3162,15 @@ void testDoubleIsNotInf(void)
 #endif
 }
 
+void testDoubleIsNotPosInf2(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_DOUBLE_IS_NOT_INF(2.0);
+#endif
+}
+
 void testDoubleIsNotNegInf(void)
 {
 #ifdef UNITY_EXCLUDE_DOUBLE
@@ -2766,16 +3182,27 @@ void testDoubleIsNotNegInf(void)
 #endif
 }
 
-void testDoubleIsNan(void)
+void testDoubleIsNan1(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_DOUBLE_IS_NAN(0.0 / d_zero);
+#endif
+}
+
+void testDoubleIsNan2(void)
 {
 #ifdef UNITY_EXCLUDE_DOUBLE
     TEST_IGNORE();
 #else
-    TEST_ASSERT_DOUBLE_IS_NAN(0.0 / d_zero);    
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_DOUBLE_IS_NOT_NAN(0.0 / d_zero);
+    VERIFY_FAILS_END
 #endif
 }
 
-void testDoubleIsNotNan(void)
+void testDoubleIsNotNan1(void)
 {
 #ifdef UNITY_EXCLUDE_DOUBLE
     TEST_IGNORE();
@@ -2786,6 +3213,15 @@ void testDoubleIsNotNan(void)
 #endif
 }
 
+void testDoubleIsNotNan2(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_DOUBLE_IS_NOT_NAN(234.9);
+#endif
+}
+
 void testDoubleInfIsNotNan(void)
 {
 #ifdef UNITY_EXCLUDE_DOUBLE
@@ -2808,6 +3244,50 @@ void testDoubleNanIsNotInf(void)
 #endif
 }
 
+void testDoubleIsDeterminate1(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_DOUBLE_IS_DETERMINATE(0.0);
+    TEST_ASSERT_DOUBLE_IS_DETERMINATE(123.3);
+    TEST_ASSERT_DOUBLE_IS_DETERMINATE(-88.3);
+#endif
+}
+
+void testDoubleIsDeterminate2(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-88.3);
+    VERIFY_FAILS_END
+#endif
+}
+
+void testDoubleIsNotDeterminate1(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
+    TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(1.0 / d_zero);
+    TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(-1.0 / d_zero);
+    TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(0.0 / d_zero);
+#endif
+}
+
+void testDoubleIsNotDeterminate2(void)
+{
+#ifdef UNITY_EXCLUDE_DOUBLE
+    TEST_IGNORE();
+#else
+    EXPECT_ABORT_BEGIN
+    TEST_ASSERT_DOUBLE_IS_DETERMINATE(-1.0 / d_zero);
+    VERIFY_FAILS_END
+#endif
+}
+
 void testEqualDoubleArrays(void)
 {
 #ifdef UNITY_EXCLUDE_DOUBLE
@@ -2937,7 +3417,7 @@ void testNotEqualDoubleArraysNegative3(void)
     VERIFY_FAILS_END
 #endif
 }
- 
+
 void testNotEqualDoubleArraysNaN(void)
 {
 #ifdef UNITY_EXCLUDE_DOUBLE
@@ -2964,4 +3444,4 @@ void testNotEqualDoubleArraysInf(void)
     TEST_ASSERT_EQUAL_DOUBLE_ARRAY(p0, p1, 4);
     VERIFY_FAILS_END
 #endif
-}
+}