ceedling 0.21.0 → 0.22.0

data/vendor/cmock/vendor/c_exception/vendor/unity/extras/fixture/test/unity_fixture_TestRunner.c

@@ -1,9 +1,9 @@
-//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
-/* ==========================================
-    Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
+/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
+ * ==========================================
+ *  Unity Project - A Test Framework for C
+ *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+ *  [Released under MIT License. Please refer to license.txt for details]
+ * ========================================== */
 
 #include "unity_fixture.h"
 

data/vendor/cmock/vendor/c_exception/vendor/unity/extras/fixture/test/unity_output_Spy.c

@@ -1,9 +1,9 @@
-//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
-/* ==========================================
-    Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
+/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
+ * ==========================================
+ *  Unity Project - A Test Framework for C
+ *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+ *  [Released under MIT License. Please refer to license.txt for details]
+ * ========================================== */
 
 
 #include "unity_output_Spy.h"

data/vendor/cmock/vendor/c_exception/vendor/unity/extras/fixture/test/unity_output_Spy.h

@@ -1,9 +1,9 @@
-//- Copyright (c) 2010 James Grenning and Contributed to Unity Project
-/* ==========================================
-    Unity Project - A Test Framework for C
-    Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
-    [Released under MIT License. Please refer to license.txt for details]
-========================================== */
+/* Copyright (c) 2010 James Grenning and Contributed to Unity Project
+ * ==========================================
+ *  Unity Project - A Test Framework for C
+ *  Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams
+ *  [Released under MIT License. Please refer to license.txt for details]
+ * ========================================== */
 
 #ifndef D_unity_output_Spy_H
 #define D_unity_output_Spy_H

data/vendor/cmock/vendor/c_exception/vendor/unity/release/build.info

@@ -1,2 +1,2 @@
-119
+120
 

data/vendor/cmock/vendor/c_exception/vendor/unity/release/version.info

@@ -1,2 +1,2 @@
-2.3.2
+2.4.0
 

data/vendor/cmock/vendor/c_exception/vendor/unity/src/unity.c

@@ -36,12 +36,14 @@ static const char UnityStrDelta[]                  = " Values Not Within Delta "
 static const char UnityStrPointless[]              = " You Asked Me To Compare Nothing, Which Was Pointless.";
 static const char UnityStrNullPointerForExpected[] = " Expected pointer to be NULL";
 static const char UnityStrNullPointerForActual[]   = " Actual pointer was NULL";
+#ifndef UNITY_EXCLUDE_FLOAT
 static const char UnityStrNot[]                    = "Not ";
 static const char UnityStrInf[]                    = "Infinity";
 static const char UnityStrNegInf[]                 = "Negative Infinity";
 static const char UnityStrNaN[]                    = "NaN";
 static const char UnityStrDet[]                    = "Determinate";
 static const char UnityStrInvalidFloatTrait[]      = "Invalid Float Trait";
+#endif
 const char UnityStrErrFloat[]                      = "Unity Floating Point Disabled";
 const char UnityStrErrDouble[]                     = "Unity Double Precision Disabled";
 const char UnityStrErr64[]                         = "Unity 64-bit Support Disabled";
@@ -52,12 +54,6 @@ static const char UnityStrResultsIgnored[]         = " Ignored ";
 static const char UnityStrDetail1Name[]            = UNITY_DETAIL1_NAME " ";
 static const char UnityStrDetail2Name[]            = " " UNITY_DETAIL2_NAME " ";
 
-#ifdef UNITY_FLOAT_NEEDS_ZERO
-/* Dividing by these constants produces +/- infinity.
- * The rationale is given in UnityAssertFloatIsInf's body. */
-static const _UF f_zero = 0.0f;
-#endif
-
 /* compiler-generic print formatting masks */
 static const _U_UINT UnitySizeMask[] =
 {
@@ -106,6 +102,7 @@ void UnityPrint(const char* string)
             else
             {
                 UNITY_OUTPUT_CHAR('\\');
+                UNITY_OUTPUT_CHAR('x');
                 UnityPrintNumberHex((_U_UINT)*pch, 2);
             }
             pch++;
@@ -143,6 +140,7 @@ void UnityPrintLen(const char* string, const _UU32 length)
             else
             {
                 UNITY_OUTPUT_CHAR('\\');
+                UNITY_OUTPUT_CHAR('x');
                 UnityPrintNumberHex((_U_UINT)*pch, 2);
             }
             pch++;
@@ -163,6 +161,8 @@ void UnityPrintNumberByStyle(const _U_SINT number, const UNITY_DISPLAY_STYLE_T s
     }
     else
     {
+        UNITY_OUTPUT_CHAR('0');
+        UNITY_OUTPUT_CHAR('x');
         UnityPrintNumberHex((_U_UINT)number, (char)((style & 0x000F) << 1));
     }
 }
@@ -207,8 +207,6 @@ void UnityPrintNumberHex(const _U_UINT number, const char nibbles_to_print)
 {
     _U_UINT nibble;
     char nibbles = nibbles_to_print;
-    UNITY_OUTPUT_CHAR('0');
-    UNITY_OUTPUT_CHAR('x');
 
     while (nibbles > 0)
     {
@@ -263,7 +261,7 @@ void UnityPrintMask(const _U_UINT mask, const _U_UINT number)
 # endif
 #endif
 
-void UnityPrintFloat(_UF number)
+void UnityPrintFloat(_UD number)
 {
     char TempBuffer[UNITY_VERBOSE_NUMBER_MAX_LENGTH + 1];
     snprintf(TempBuffer, sizeof(TempBuffer), "%.6f", number);
@@ -618,7 +616,28 @@ void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
 }
 
 /*-----------------------------------------------*/
+/* Wrap this define in a function with variable types as float or double */
+#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff)                       \
+    if (isinf(expected) && isinf(actual) && (isneg(expected) == isneg(actual))) return 1; \
+    if (UNITY_NAN_CHECK) return 1;                                                        \
+    diff = actual - expected;                                                             \
+    if (diff < 0.0f) diff = 0.0f - diff;                                                  \
+    if (delta < 0.0f) delta = 0.0f - delta;                                               \
+    return !(isnan(diff) || isinf(diff) || (diff > delta))
+    /* This first part of this condition will catch any NaN or Infinite values */
+#ifndef UNITY_NAN_NOT_EQUAL_NAN
+  #define UNITY_NAN_CHECK isnan(expected) && isnan(actual)
+#else
+  #define UNITY_NAN_CHECK 0
+#endif
+
 #ifndef UNITY_EXCLUDE_FLOAT
+static int UnityFloatsWithin(_UF delta, _UF expected, _UF actual)
+{
+    _UF diff;
+    UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff);
+}
+
 void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const _UF* expected,
                                 UNITY_PTR_ATTRIBUTE const _UF* actual,
                                 const _UU32 num_elements,
@@ -628,7 +647,6 @@ void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const _UF* expected,
     _UU32 elements = num_elements;
     UNITY_PTR_ATTRIBUTE const _UF* ptr_expected = expected;
     UNITY_PTR_ATTRIBUTE const _UF* ptr_actual = actual;
-    _UF diff, tol;
 
     UNITY_SKIP_EXECUTION;
 
@@ -642,15 +660,7 @@ void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const _UF* expected,
 
     while (elements--)
     {
-        diff = *ptr_expected - *ptr_actual;
-        if (diff < 0.0f)
-            diff = 0.0f - diff;
-        tol = UNITY_FLOAT_PRECISION * *ptr_expected;
-        if (tol < 0.0f)
-            tol = 0.0f - tol;
-
-        /* This first part of this condition will catch any NaN or Infinite values */
-        if (isnan(diff) || isinf(diff) || (diff > tol))
+        if (!UnityFloatsWithin(*ptr_expected * UNITY_FLOAT_PRECISION, *ptr_expected, *ptr_actual))
         {
             UnityTestResultsFailBegin(lineNumber);
             UnityPrint(UnityStrElement);
@@ -678,22 +688,10 @@ void UnityAssertFloatsWithin(const _UF delta,
                              const char* msg,
                              const UNITY_LINE_TYPE lineNumber)
 {
-    _UF diff = actual - expected;
-    _UF pos_delta = delta;
-
     UNITY_SKIP_EXECUTION;
 
-    if (diff < 0.0f)
-    {
-        diff = 0.0f - diff;
-    }
-    if (pos_delta < 0.0f)
-    {
-        pos_delta = 0.0f - pos_delta;
-    }
 
-    /* This first part of this condition will catch any NaN or Infinite values */
-    if (isnan(diff) || isinf(diff) || (pos_delta < diff))
+    if (!UnityFloatsWithin(delta, expected, actual))
     {
         UnityTestResultsFailBegin(lineNumber);
 #ifdef UNITY_FLOAT_VERBOSE
@@ -724,8 +722,6 @@ void UnityAssertFloatSpecial(const _UF actual,
 
     switch(style)
     {
-        /* To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly
-         * We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise */
         case UNITY_FLOAT_IS_INF:
         case UNITY_FLOAT_IS_NOT_INF:
             is_trait = isinf(actual) & ispos(actual);
@@ -735,7 +731,6 @@ void UnityAssertFloatSpecial(const _UF actual,
             is_trait = isinf(actual) & isneg(actual);
             break;
 
-        /* NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN. */
         case UNITY_FLOAT_IS_NAN:
         case UNITY_FLOAT_IS_NOT_NAN:
             is_trait = isnan(actual);
@@ -780,6 +775,12 @@ void UnityAssertFloatSpecial(const _UF actual,
 
 /*-----------------------------------------------*/
 #ifndef UNITY_EXCLUDE_DOUBLE
+static int UnityDoublesWithin(_UD delta, _UD expected, _UD actual)
+{
+    _UD diff;
+    UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff);
+}
+
 void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const _UD* expected,
                                  UNITY_PTR_ATTRIBUTE const _UD* actual,
                                  const _UU32 num_elements,
@@ -789,7 +790,6 @@ void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const _UD* expected,
     _UU32 elements = num_elements;
     UNITY_PTR_ATTRIBUTE const _UD* ptr_expected = expected;
     UNITY_PTR_ATTRIBUTE const _UD* ptr_actual = actual;
-    _UD diff, tol;
 
     UNITY_SKIP_EXECUTION;
 
@@ -803,15 +803,7 @@ void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const _UD* expected,
 
     while (elements--)
     {
-        diff = *ptr_expected - *ptr_actual;
-        if (diff < 0.0)
-          diff = 0.0 - diff;
-        tol = UNITY_DOUBLE_PRECISION * *ptr_expected;
-        if (tol < 0.0)
-            tol = 0.0 - tol;
-
-        /* This first part of this condition will catch any NaN or Infinite values */
-        if (isnan(diff) || isinf(diff) || (diff > tol))
+        if (!UnityDoublesWithin(*ptr_expected * UNITY_DOUBLE_PRECISION, *ptr_expected, *ptr_actual))
         {
             UnityTestResultsFailBegin(lineNumber);
             UnityPrint(UnityStrElement);
@@ -839,22 +831,9 @@ void UnityAssertDoublesWithin(const _UD delta,
                               const char* msg,
                               const UNITY_LINE_TYPE lineNumber)
 {
-    _UD diff = actual - expected;
-    _UD pos_delta = delta;
-
     UNITY_SKIP_EXECUTION;
 
-    if (diff < 0.0)
-    {
-        diff = 0.0 - diff;
-    }
-    if (pos_delta < 0.0)
-    {
-        pos_delta = 0.0 - pos_delta;
-    }
-
-    /* This first part of this condition will catch any NaN or Infinite values */
-    if (isnan(diff) || isinf(diff) || (pos_delta < diff))
+    if (!UnityDoublesWithin(delta, expected, actual))
     {
         UnityTestResultsFailBegin(lineNumber);
 #ifdef UNITY_DOUBLE_VERBOSE
@@ -886,8 +865,6 @@ void UnityAssertDoubleSpecial(const _UD actual,
 
      switch(style)
     {
-        /* To determine Inf / Neg Inf, we compare to an Inf / Neg Inf value we create on the fly
-         * We are using a variable to hold the zero value because some compilers complain about dividing by zero otherwise */
         case UNITY_FLOAT_IS_INF:
         case UNITY_FLOAT_IS_NOT_INF:
             is_trait = isinf(actual) & ispos(actual);
@@ -897,7 +874,6 @@ void UnityAssertDoubleSpecial(const _UD actual,
             is_trait = isinf(actual) & isneg(actual);
             break;
 
-        /* NaN is the only floating point value that does NOT equal itself. Therefore if Actual == Actual, then it is NOT NaN. */
         case UNITY_FLOAT_IS_NAN:
         case UNITY_FLOAT_IS_NOT_NAN:
             is_trait = isnan(actual);
@@ -1033,7 +1009,7 @@ void UnityAssertEqualStringLen(const char* expected,
     /* if both pointers not null compare the strings */
     if (expected && actual)
     {
-        for (i = 0; (expected[i] || actual[i]) && i < length; i++)
+        for (i = 0; (i < length) && (expected[i] || actual[i]); i++)
         {
             if (expected[i] != actual[i])
             {
@@ -1142,7 +1118,6 @@ void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected,
 
     while (elements--)
     {
-        /* /////////////////////////////////// */
         bytes = length;
         while (bytes--)
         {
@@ -1167,8 +1142,6 @@ void UnityAssertEqualMemory( UNITY_INTERNAL_PTR expected,
             ptr_exp = (UNITY_INTERNAL_PTR)((_UP)ptr_exp + 1);
             ptr_act = (UNITY_INTERNAL_PTR)((_UP)ptr_act + 1);
         }
-        /* /////////////////////////////////// */
-
     }
 }
 
@@ -1413,14 +1386,14 @@ int UnityStringArgumentMatches(const char* str)
     const char* ptr2;
     const char* ptrf;
 
-    //Go through the options and get the substrings for matching one at a time
+    /* Go through the options and get the substrings for matching one at a time */
     ptr1 = str;
     while (ptr1[0] != 0)
     {
         if ((ptr1[0] == '"') || (ptr1[0] == '\''))
             ptr1++;
 
-        //look for the start of the next partial
+        /* look for the start of the next partial */
         ptr2 = ptr1;
         ptrf = 0;
         do {
@@ -1431,26 +1404,26 @@ int UnityStringArgumentMatches(const char* str)
         while ((ptr2[0] != 0) && ((ptr2[0] == ':') || (ptr2[0] == '\'') || (ptr2[0] == '"') || (ptr2[0] == ',')))
             ptr2++;
 
-        //done if complete filename match
+        /* done if complete filename match */
         retval = IsStringInBiggerString(Unity.TestFile, ptr1);
         if (retval == 1)
             return retval;
 
-        //done if testname match after filename partial match
+        /* done if testname match after filename partial match */
         if ((retval == 2) && (ptrf != 0))
         {
             if (IsStringInBiggerString(Unity.CurrentTestName, ptrf))
                 return 1;
         }
 
-        //done if complete testname match
+        /* done if complete testname match */
         if (IsStringInBiggerString(Unity.CurrentTestName, ptr1) == 1)
             return 1;
 
         ptr1 = ptr2;
     }
 
-    //we couldn't find a match for any substrings
+    /* we couldn't find a match for any substrings */
     return 0;
 }
 

data/vendor/cmock/vendor/c_exception/vendor/unity/src/unity.h

@@ -27,12 +27,11 @@ void tearDown(void);
  *     - Unity attempts to automatically discover your integer sizes
  *       - define UNITY_EXCLUDE_STDINT_H to stop attempting to look in <stdint.h>
  *       - define UNITY_EXCLUDE_LIMITS_H to stop attempting to look in <limits.h>
- *       - define UNITY_EXCLUDE_SIZEOF to stop attempting to use sizeof in macros
  *     - If you cannot use the automatic methods above, you can force Unity by using these options:
  *       - define UNITY_SUPPORT_64
- *       - define UNITY_INT_WIDTH
- *       - UNITY_LONG_WIDTH
- *       - UNITY_POINTER_WIDTH
+ *       - set UNITY_INT_WIDTH
+ *       - set UNITY_LONG_WIDTH
+ *       - set UNITY_POINTER_WIDTH
 
  * Floats
  *     - define UNITY_EXCLUDE_FLOAT to disallow floating point comparisons

data/vendor/cmock/vendor/c_exception/vendor/unity/src/unity_internals.h

@@ -13,10 +13,15 @@
 
 #include <setjmp.h>
 
+#ifndef UNITY_EXCLUDE_MATH_H
+#include <math.h>
+#endif
+
 /* Unity Attempts to Auto-Detect Integer Types
- * Attempt 1: UINT_MAX, ULONG_MAX, etc in <stdint.h>
- * Attempt 2: UINT_MAX, ULONG_MAX, etc in <limits.h>
- * Attempt 3: Deduced from sizeof() macros */
+ * Attempt 1: UINT_MAX, ULONG_MAX in <limits.h>, or default to 32 bits
+ * Attempt 2: UINTPTR_MAX in <stdint.h>, or default to same size as long
+ * The user may override any of these derived constants:
+ * UNITY_INT_WIDTH, UNITY_LONG_WIDTH, UNITY_POINTER_WIDTH */
 #ifndef UNITY_EXCLUDE_STDINT_H
 #include <stdint.h>
 #endif
@@ -25,29 +30,13 @@
 #include <limits.h>
 #endif
 
-#ifndef UNITY_EXCLUDE_SIZEOF
-#ifndef UINT_MAX
-#define UINT_MAX     (sizeof(unsigned int) * 256 - 1)
-#endif
-#ifndef ULONG_MAX
-#define ULONG_MAX    (sizeof(unsigned long) * 256 - 1)
-#endif
-#ifndef UINTPTR_MAX
-/* apparently this is not a constant expression: (sizeof(unsigned int *) * 256 - 1) so we have to just let this fall through */
-#endif
-#endif
-
-#ifndef UNITY_EXCLUDE_MATH_H
-#include <math.h>
-#endif
-
 /*-------------------------------------------------------
  * Guess Widths If Not Specified
  *-------------------------------------------------------*/
 
-/* Determine the size of an int, if not already specificied.
+/* Determine the size of an int, if not already specified.
  * We cannot use sizeof(int), because it is not yet defined
- * at this stage in the trnslation of the C program.
+ * at this stage in the translation of the C program.
  * Therefore, infer it from UINT_MAX if possible. */
 #ifndef UNITY_INT_WIDTH
   #ifdef UINT_MAX
@@ -58,15 +47,12 @@
     #elif (UINT_MAX == 0xFFFFFFFFFFFFFFFF)
       #define UNITY_INT_WIDTH (64)
     #endif
-  #endif
-#endif
-#ifndef UNITY_INT_WIDTH
-  #define UNITY_INT_WIDTH (32)
+  #else /* Set to default */
+    #define UNITY_INT_WIDTH (32)
+  #endif /* UINT_MAX */
 #endif
 
-/* Determine the size of a long, if not already specified,
- * by following the process used above to define
- * UNITY_INT_WIDTH. */
+/* Determine the size of a long, if not already specified. */
 #ifndef UNITY_LONG_WIDTH
   #ifdef ULONG_MAX
     #if (ULONG_MAX == 0xFFFF)
@@ -76,39 +62,24 @@
     #elif (ULONG_MAX == 0xFFFFFFFFFFFFFFFF)
       #define UNITY_LONG_WIDTH (64)
     #endif
-  #endif
-#endif
-#ifndef UNITY_LONG_WIDTH
-  #define UNITY_LONG_WIDTH (32)
+  #else /* Set to default */
+    #define UNITY_LONG_WIDTH (32)
+  #endif /* ULONG_MAX */
 #endif
 
-/* Determine the size of a pointer, if not already specified,
- * by following the process used above to define
- * UNITY_INT_WIDTH. */
+/* Determine the size of a pointer, if not already specified. */
 #ifndef UNITY_POINTER_WIDTH
   #ifdef UINTPTR_MAX
-    #if (UINTPTR_MAX+0 <= 0xFFFF)
-      #define UNITY_POINTER_WIDTH (16)
-    #elif (UINTPTR_MAX+0 <= 0xFFFFFFFF)
-      #define UNITY_POINTER_WIDTH (32)
-    #elif (UINTPTR_MAX+0 <= 0xFFFFFFFFFFFFFFFF)
-      #define UNITY_POINTER_WIDTH (64)
-    #endif
-  #endif
-#endif
-#ifndef UNITY_POINTER_WIDTH
-  #ifdef INTPTR_MAX
-    #if (INTPTR_MAX+0 <= 0x7FFF)
+    #if (UINTPTR_MAX <= 0xFFFF)
       #define UNITY_POINTER_WIDTH (16)
-    #elif (INTPTR_MAX+0 <= 0x7FFFFFFF)
+    #elif (UINTPTR_MAX <= 0xFFFFFFFF)
       #define UNITY_POINTER_WIDTH (32)
-    #elif (INTPTR_MAX+0 <= 0x7FFFFFFFFFFFFFFF)
+    #elif (UINTPTR_MAX <= 0xFFFFFFFFFFFFFFFF)
       #define UNITY_POINTER_WIDTH (64)
     #endif
-  #endif
-#endif
-#ifndef UNITY_POINTER_WIDTH
-  #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH
+  #else /* Set to default */
+    #define UNITY_POINTER_WIDTH UNITY_LONG_WIDTH
+  #endif /* UINTPTR_MAX */
 #endif
 
 /*-------------------------------------------------------
@@ -138,36 +109,29 @@
  *-------------------------------------------------------*/
 
 #ifndef UNITY_SUPPORT_64
-#if UNITY_LONG_WIDTH > 32
-#define UNITY_SUPPORT_64
-#endif
-#endif
-#ifndef UNITY_SUPPORT_64
-#if UNITY_POINTER_WIDTH > 32
-#define UNITY_SUPPORT_64
-#endif
+  #if UNITY_LONG_WIDTH == 64 || UNITY_POINTER_WIDTH == 64
+    #define UNITY_SUPPORT_64
+  #endif
 #endif
 
 #ifndef UNITY_SUPPORT_64
-
-/* No 64-bit Support */
-typedef _UU32 _U_UINT;
-typedef _US32 _U_SINT;
-
+    /* No 64-bit Support */
+    typedef _UU32 _U_UINT;
+    typedef _US32 _U_SINT;
 #else
 
-/* 64-bit Support */
-#if (UNITY_LONG_WIDTH == 32)
+    /* 64-bit Support */
+  #if (UNITY_LONG_WIDTH == 32)
     typedef unsigned long long _UU64;
     typedef signed long long   _US64;
-#elif (UNITY_LONG_WIDTH == 64)
+  #elif (UNITY_LONG_WIDTH == 64)
     typedef unsigned long      _UU64;
     typedef signed long        _US64;
-#else
+  #else
     #error Invalid UNITY_LONG_WIDTH specified! (32 or 64 are supported)
-#endif
-typedef _UU64 _U_UINT;
-typedef _US64 _U_SINT;
+  #endif
+    typedef _UU64 _U_UINT;
+    typedef _US64 _U_SINT;
 
 #endif
 
@@ -225,11 +189,13 @@ typedef _US64 _U_SINT;
 typedef UNITY_FLOAT_TYPE _UF;
 
 #ifndef isinf
-#define isinf(n) (((1.0f / f_zero) == n) ? 1 : 0) || (((-1.0f / f_zero) == n) ? 1 : 0)
-#define UNITY_FLOAT_NEEDS_ZERO
+/* The value of Inf - Inf is NaN */
+#define isinf(n) (isnan((n) - (n)) && !isnan(n))
 #endif
 
 #ifndef isnan
+/* NaN is the only floating point value that does NOT equal itself.
+ * Therefore if n != n, then it is NaN. */
 #define isnan(n) ((n != n) ? 1 : 0)
 #endif
 
@@ -249,32 +215,38 @@ typedef UNITY_FLOAT_TYPE _UF;
 
 /* unlike FLOAT, we DON'T include by default */
 #ifndef UNITY_EXCLUDE_DOUBLE
-#ifndef UNITY_INCLUDE_DOUBLE
-#define UNITY_EXCLUDE_DOUBLE
-#endif
+  #ifndef UNITY_INCLUDE_DOUBLE
+  #define UNITY_EXCLUDE_DOUBLE
+  #endif
 #endif
 
 #ifdef UNITY_EXCLUDE_DOUBLE
 
-/* No Floating Point Support */
-#undef UNITY_DOUBLE_PRECISION
-#undef UNITY_DOUBLE_TYPE
-#undef UNITY_DOUBLE_VERBOSE
+  /* No Floating Point Support */
+  #undef UNITY_DOUBLE_PRECISION
+  #undef UNITY_DOUBLE_TYPE
+  #undef UNITY_DOUBLE_VERBOSE
 
-#ifdef UNITY_INCLUDE_DOUBLE
-#undef UNITY_INCLUDE_DOUBLE
-#endif
+  #ifdef UNITY_INCLUDE_DOUBLE
+    #undef UNITY_INCLUDE_DOUBLE
+  #endif
+
+  #ifdef UNITY_FLOAT_VERBOSE
+    typedef _UF _UD;
+    /* For parameter in UnityPrintFloat, double promotion required */
+  #endif
 
 #else
 
-/* Double Floating Point Support */
-#ifndef UNITY_DOUBLE_PRECISION
-#define UNITY_DOUBLE_PRECISION (1e-12f)
-#endif
-#ifndef UNITY_DOUBLE_TYPE
-#define UNITY_DOUBLE_TYPE double
-#endif
-typedef UNITY_DOUBLE_TYPE _UD;
+  /* Double Floating Point Support */
+  #ifndef UNITY_DOUBLE_PRECISION
+  #define UNITY_DOUBLE_PRECISION (1e-12f)
+  #endif
+
+  #ifndef UNITY_DOUBLE_TYPE
+  #define UNITY_DOUBLE_TYPE double
+  #endif
+  typedef UNITY_DOUBLE_TYPE _UD;
 
 #endif
 
@@ -369,13 +341,7 @@ typedef void (*UnityTestFunction)(void);
 
 typedef enum
 {
-#if (UNITY_INT_WIDTH == 16)
-    UNITY_DISPLAY_STYLE_INT      = 2 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH  == 32)
-    UNITY_DISPLAY_STYLE_INT      = 4 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH  == 64)
-    UNITY_DISPLAY_STYLE_INT      = 8 + UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
-#endif
+UNITY_DISPLAY_STYLE_INT = sizeof(int)+ UNITY_DISPLAY_RANGE_INT + UNITY_DISPLAY_RANGE_AUTO,
     UNITY_DISPLAY_STYLE_INT8     = 1 + UNITY_DISPLAY_RANGE_INT,
     UNITY_DISPLAY_STYLE_INT16    = 2 + UNITY_DISPLAY_RANGE_INT,
     UNITY_DISPLAY_STYLE_INT32    = 4 + UNITY_DISPLAY_RANGE_INT,
@@ -383,25 +349,21 @@ typedef enum
     UNITY_DISPLAY_STYLE_INT64    = 8 + UNITY_DISPLAY_RANGE_INT,
 #endif
 
-#if (UNITY_INT_WIDTH == 16)
-    UNITY_DISPLAY_STYLE_UINT     = 2 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH  == 32)
-    UNITY_DISPLAY_STYLE_UINT     = 4 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#elif (UNITY_INT_WIDTH  == 64)
-    UNITY_DISPLAY_STYLE_UINT     = 8 + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
-#endif
+UNITY_DISPLAY_STYLE_UINT = sizeof(unsigned) + UNITY_DISPLAY_RANGE_UINT + UNITY_DISPLAY_RANGE_AUTO,
     UNITY_DISPLAY_STYLE_UINT8    = 1 + UNITY_DISPLAY_RANGE_UINT,
     UNITY_DISPLAY_STYLE_UINT16   = 2 + UNITY_DISPLAY_RANGE_UINT,
     UNITY_DISPLAY_STYLE_UINT32   = 4 + UNITY_DISPLAY_RANGE_UINT,
 #ifdef UNITY_SUPPORT_64
     UNITY_DISPLAY_STYLE_UINT64   = 8 + UNITY_DISPLAY_RANGE_UINT,
 #endif
+
     UNITY_DISPLAY_STYLE_HEX8     = 1 + UNITY_DISPLAY_RANGE_HEX,
     UNITY_DISPLAY_STYLE_HEX16    = 2 + UNITY_DISPLAY_RANGE_HEX,
     UNITY_DISPLAY_STYLE_HEX32    = 4 + UNITY_DISPLAY_RANGE_HEX,
 #ifdef UNITY_SUPPORT_64
     UNITY_DISPLAY_STYLE_HEX64    = 8 + UNITY_DISPLAY_RANGE_HEX,
 #endif
+
     UNITY_DISPLAY_STYLE_UNKNOWN
 } UNITY_DISPLAY_STYLE_T;
 
@@ -482,11 +444,11 @@ void UnityPrintNumberUnsigned(const _U_UINT number);
 void UnityPrintNumberHex(const _U_UINT number, const char nibbles);
 
 #ifdef UNITY_FLOAT_VERBOSE
-void UnityPrintFloat(const _UF number);
+void UnityPrintFloat(const _UD number);
 #endif
 
 /*-------------------------------------------------------
- * Test Assertion Fuctions
+ * Test Assertion Functions
  *-------------------------------------------------------
  *  Use the macros below this section instead of calling
  *  these directly. The macros have a consistent naming