ceedling 1.0.1 → 1.1.0

data/vendor/unity/src/unity.c

@@ -1,7 +1,7 @@
 /* =========================================================================
     Unity - A Test Framework for C
     ThrowTheSwitch.org
-    Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams
+    Copyright (c) 2007-26 Mike Karlesky, Mark VanderVoord, & Greg Williams
     SPDX-License-Identifier: MIT
 ========================================================================= */
 
@@ -35,7 +35,7 @@ const char UNITY_PROGMEM UnityStrFail[]                          = "FAIL";
 const char UNITY_PROGMEM UnityStrIgnore[]                        = "IGNORE";
 #endif
 static const char UNITY_PROGMEM UnityStrNull[]                   = "NULL";
-static const char UNITY_PROGMEM UnityStrSpacer[]                 = ". ";
+static const char UNITY_PROGMEM UnityStrSpacer[]                 = UNITY_FAILURE_DETAIL_SEPARATOR;
 static const char UNITY_PROGMEM UnityStrExpected[]               = " Expected ";
 static const char UNITY_PROGMEM UnityStrWas[]                    = " Was ";
 static const char UNITY_PROGMEM UnityStrGt[]                     = " to be greater than ";
@@ -44,6 +44,7 @@ static const char UNITY_PROGMEM UnityStrOrEqual[]                = "or equal to
 static const char UNITY_PROGMEM UnityStrNotEqual[]               = " to be not equal to ";
 static const char UNITY_PROGMEM UnityStrElement[]                = " Element ";
 static const char UNITY_PROGMEM UnityStrByte[]                   = " Byte ";
+static const char UNITY_PROGMEM UnityStrCharacter[]              = " Character ";
 static const char UNITY_PROGMEM UnityStrMemory[]                 = " Memory Mismatch.";
 static const char UNITY_PROGMEM UnityStrDelta[]                  = " Values Not Within Delta ";
 static const char UNITY_PROGMEM UnityStrPointless[]              = " You Asked Me To Compare Nothing, Which Was Pointless.";
@@ -61,14 +62,24 @@ const char UNITY_PROGMEM UnityStrErrShorthand[]                  = "Unity Shorth
 const char UNITY_PROGMEM UnityStrErrFloat[]                      = "Unity Floating Point Disabled";
 const char UNITY_PROGMEM UnityStrErrDouble[]                     = "Unity Double Precision Disabled";
 const char UNITY_PROGMEM UnityStrErr64[]                         = "Unity 64-bit Support Disabled";
+const char UNITY_PROGMEM UnityStrErrDetailStack[]                = "Unity Detail Stack Support Disabled";
 static const char UNITY_PROGMEM UnityStrBreaker[]                = "-----------------------";
 static const char UNITY_PROGMEM UnityStrResultsTests[]           = " Tests ";
 static const char UNITY_PROGMEM UnityStrResultsFailures[]        = " Failures ";
 static const char UNITY_PROGMEM UnityStrResultsIgnored[]         = " Ignored ";
 #ifndef UNITY_EXCLUDE_DETAILS
+#ifdef UNITY_DETAIL_STACK_SIZE
+static const char* UNITY_PROGMEM UnityStrDetailLabels[] = UNITY_DETAIL_LABEL_NAMES;
+static const UNITY_COUNTER_TYPE UNITY_PROGMEM UnityStrDetailLabelsCount = sizeof(UnityStrDetailLabels) / sizeof(const char*);
+static const char UNITY_PROGMEM UnityStrErrDetailStackEmpty[]           = " Detail Stack Empty";
+static const char UNITY_PROGMEM UnityStrErrDetailStackFull[]            = " Detail Stack Full";
+static const char UNITY_PROGMEM UnityStrErrDetailStackLabel[]           = " Detail Label Outside Of UNITY_DETAIL_LABEL_NAMES: ";
+static const char UNITY_PROGMEM UnityStrErrDetailStackPop[]             = " Detail Pop With Unexpected Arguments";
+#else
 static const char UNITY_PROGMEM UnityStrDetail1Name[]            = UNITY_DETAIL1_NAME " ";
 static const char UNITY_PROGMEM UnityStrDetail2Name[]            = " " UNITY_DETAIL2_NAME " ";
 #endif
+#endif
 /*-----------------------------------------------
  * Pretty Printers & Test Result Output Handlers
  *-----------------------------------------------*/
@@ -185,43 +196,40 @@ void UnityPrintLen(const char* string, const UNITY_UINT32 length)
 }
 
 /*-----------------------------------------------*/
-void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style)
+void UnityPrintIntNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style)
 {
-    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
+    if (style == UNITY_DISPLAY_STYLE_CHAR)
     {
-        if (style == UNITY_DISPLAY_STYLE_CHAR)
+        /* printable characters plus CR & LF are printed */
+        UNITY_OUTPUT_CHAR('\'');
+        if ((number <= 126) && (number >= 32))
         {
-            /* printable characters plus CR & LF are printed */
-            UNITY_OUTPUT_CHAR('\'');
-            if ((number <= 126) && (number >= 32))
-            {
-                UNITY_OUTPUT_CHAR((int)number);
-            }
-            /* write escaped carriage returns */
-            else if (number == 13)
-            {
-                UNITY_OUTPUT_CHAR('\\');
-                UNITY_OUTPUT_CHAR('r');
-            }
-            /* write escaped line feeds */
-            else if (number == 10)
-            {
-                UNITY_OUTPUT_CHAR('\\');
-                UNITY_OUTPUT_CHAR('n');
-            }
-            /* unprintable characters are shown as codes */
-            else
-            {
-                UNITY_OUTPUT_CHAR('\\');
-                UNITY_OUTPUT_CHAR('x');
-                UnityPrintNumberHex((UNITY_UINT)number, 2);
-            }
-            UNITY_OUTPUT_CHAR('\'');
+            UNITY_OUTPUT_CHAR((int)number);
+        }
+        /* write escaped carriage returns */
+        else if (number == 13)
+        {
+            UNITY_OUTPUT_CHAR('\\');
+            UNITY_OUTPUT_CHAR('r');
+        }
+        /* write escaped line feeds */
+        else if (number == 10)
+        {
+            UNITY_OUTPUT_CHAR('\\');
+            UNITY_OUTPUT_CHAR('n');
         }
+        /* unprintable characters are shown as codes */
         else
         {
-            UnityPrintNumber(number);
+            UNITY_OUTPUT_CHAR('\\');
+            UNITY_OUTPUT_CHAR('x');
+            UnityPrintNumberHex((UNITY_UINT)number, 2);
         }
+        UNITY_OUTPUT_CHAR('\'');
+    }
+    else if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
+    {
+        UnityPrintNumber(number);
     }
     else if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
     {
@@ -235,6 +243,20 @@ void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T
     }
 }
 
+void UnityPrintUintNumberByStyle(const UNITY_UINT number, const UNITY_DISPLAY_STYLE_T style)
+{
+    if ((style & UNITY_DISPLAY_RANGE_UINT) == UNITY_DISPLAY_RANGE_UINT)
+    {
+        UnityPrintNumberUnsigned(number);
+    }
+    else
+    {
+        UNITY_OUTPUT_CHAR('0');
+        UNITY_OUTPUT_CHAR('x');
+        UnityPrintNumberHex((UNITY_UINT)number, (char)((style & 0xF) * 2));
+    }
+}
+
 /*-----------------------------------------------*/
 void UnityPrintNumber(const UNITY_INT number_to_print)
 {
@@ -337,33 +359,35 @@ void UnityPrintFloat(const UNITY_DOUBLE input_number)
     static const int sig_digits = 9;
     static const UNITY_INT32 min_scaled = 100000000;
     static const UNITY_INT32 max_scaled = 1000000000;
+    static const UNITY_DOUBLE epsilon = UNITY_DOUBLE_PRECISION;
 #else
     static const int sig_digits = 7;
     static const UNITY_INT32 min_scaled = 1000000;
     static const UNITY_INT32 max_scaled = 10000000;
+    static const UNITY_DOUBLE epsilon = UNITY_FLOAT_PRECISION;
 #endif
 
     UNITY_DOUBLE number = input_number;
 
-    /* print minus sign (does not handle negative zero) */
-    if (number < 0.0f)
-    {
-        UNITY_OUTPUT_CHAR('-');
-        number = -number;
-    }
-
     /* handle zero, NaN, and +/- infinity */
-    if (number == 0.0f)
+    if (UNITY_ABS(number) < epsilon)
     {
         UnityPrint("0");
     }
     else if (UNITY_IS_NAN(number))
     {
-        UnityPrint("nan");
+        UnityPrint(UnityStrNaN);
     }
     else if (UNITY_IS_INF(number))
     {
-        UnityPrint("inf");
+        if (number < 0.0f) 
+        {
+            UnityPrint(UnityStrNegInf);
+        }
+        else
+        {
+            UnityPrint(UnityStrInf);
+        }
     }
     else
     {
@@ -374,6 +398,11 @@ void UnityPrintFloat(const UNITY_DOUBLE input_number)
         int         digits;
         char        buf[16] = {0};
 
+        if (number < 0.0f)
+        {
+            UNITY_OUTPUT_CHAR('-');
+            number = -number;
+        }
         /*
          * Scale up or down by powers of 10.  To minimize rounding error,
          * start with a factor/divisor of 10^10, which is the largest
@@ -416,13 +445,17 @@ void UnityPrintFloat(const UNITY_DOUBLE input_number)
         }
 
         /* round to nearest integer */
-        n = ((UNITY_INT32)(number + number) + 1) / 2;
+        {
+            UNITY_DOUBLE two_number = number + number;
+            UNITY_INT32  two_n_trunc = (UNITY_INT32)two_number;
+            n = (two_n_trunc + 1) / 2;
 
 #ifndef UNITY_ROUND_TIES_AWAY_FROM_ZERO
-        /* round to even if exactly between two integers */
-        if ((n & 1) && (((UNITY_DOUBLE)n - number) == 0.5f))
-            n--;
+            /* round to even if exactly between two integers */
+            if ((n & 1) && (two_n_trunc & 1) && !((UNITY_DOUBLE)two_n_trunc < two_number))
+                n--;
 #endif
+        }
 
         n += n_int;
 
@@ -574,6 +607,32 @@ static void UnityAddMsgIfSpecified(const char* msg)
     UNITY_PRINT_TEST_CONTEXT();
 #endif
 #ifndef UNITY_EXCLUDE_DETAILS
+#ifdef UNITY_DETAIL_STACK_SIZE
+    {
+        UNITY_COUNTER_TYPE c;
+        for (c = 0; (c < Unity.CurrentDetailStackSize) && (c < UNITY_DETAIL_STACK_SIZE); c++) {
+            const char* label;
+            if ((Unity.CurrentDetailStackLabels[c] == UNITY_DETAIL_NONE) || (Unity.CurrentDetailStackLabels[c] > UnityStrDetailLabelsCount)) {
+                break;
+            }
+            label = UnityStrDetailLabels[Unity.CurrentDetailStackLabels[c]];
+            UnityPrint(UnityStrSpacer);
+            if ((label[0] == '#') && (label[1] != 0)) {
+                UnityPrint(label + 2);
+                UNITY_OUTPUT_CHAR(' ');
+                if ((label[1] & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT) {
+                    UnityPrintIntNumberByStyle((UNITY_INT)Unity.CurrentDetailStackValues[c], label[1]);
+                } else {
+                    UnityPrintUintNumberByStyle((UNITY_UINT)Unity.CurrentDetailStackValues[c], label[1]);
+                }
+            } else if (Unity.CurrentDetailStackValues[c] != 0){
+                UnityPrint(label);
+                UNITY_OUTPUT_CHAR(' ');
+                UnityPrint((const char*)Unity.CurrentDetailStackValues[c]);
+            }
+        }
+    }
+#else
     if (Unity.CurrentDetail1)
     {
         UnityPrint(UnityStrSpacer);
@@ -585,6 +644,7 @@ static void UnityAddMsgIfSpecified(const char* msg)
             UnityPrint(Unity.CurrentDetail2);
         }
     }
+#endif
 #endif
     if (msg)
     {
@@ -594,7 +654,21 @@ static void UnityAddMsgIfSpecified(const char* msg)
 }
 
 /*-----------------------------------------------*/
-static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual)
+static void UnityPrintFirstStringDifference(const char *expected, const char *actual, UNITY_UINT32 i_diff)
+{
+    if ((expected != NULL) && (actual != NULL))
+    {
+        UnityPrint(UnityStrCharacter);
+        UnityPrintNumberUnsigned(i_diff);
+        UnityPrint(UnityStrExpected);
+        UnityPrintIntNumberByStyle(expected[i_diff], UNITY_DISPLAY_STYLE_CHAR);
+        UnityPrint(UnityStrWas);
+        UnityPrintIntNumberByStyle(actual[i_diff], UNITY_DISPLAY_STYLE_CHAR);
+    }
+}
+
+/*-----------------------------------------------*/
+static void UnityPrintExpectedAndActualStrings(const char* expected, const char* actual, UNITY_UINT32 i_diff)
 {
     UnityPrint(UnityStrExpected);
     if (expected != NULL)
@@ -618,12 +692,14 @@ static void UnityPrintExpectedAndActualStrings(const char* expected, const char*
     {
         UnityPrint(UnityStrNull);
     }
+    UnityPrintFirstStringDifference(expected, actual, i_diff);
 }
 
 /*-----------------------------------------------*/
 static void UnityPrintExpectedAndActualStringsLen(const char* expected,
                                                   const char* actual,
-                                                  const UNITY_UINT32 length)
+                                                  UNITY_UINT32 length,
+                                                  UNITY_UINT32 i_diff)
 {
     UnityPrint(UnityStrExpected);
     if (expected != NULL)
@@ -647,6 +723,7 @@ static void UnityPrintExpectedAndActualStringsLen(const char* expected,
     {
         UnityPrint(UnityStrNull);
     }
+    UnityPrintFirstStringDifference(expected, actual, i_diff);
 }
 
 /*-----------------------------------------------
@@ -709,11 +786,11 @@ void UnityAssertBits(const UNITY_INT mask,
 }
 
 /*-----------------------------------------------*/
-void UnityAssertEqualNumber(const UNITY_INT expected,
-                            const UNITY_INT actual,
-                            const char* msg,
-                            const UNITY_LINE_TYPE lineNumber,
-                            const UNITY_DISPLAY_STYLE_T style)
+void UnityAssertEqualIntNumber(const UNITY_INT expected,
+                               const UNITY_INT actual,
+                               const char* msg,
+                               const UNITY_LINE_TYPE lineNumber,
+                               const UNITY_DISPLAY_STYLE_T style)
 {
     RETURN_IF_FAIL_OR_IGNORE;
 
@@ -721,49 +798,90 @@ void UnityAssertEqualNumber(const UNITY_INT expected,
     {
         UnityTestResultsFailBegin(lineNumber);
         UnityPrint(UnityStrExpected);
-        UnityPrintNumberByStyle(expected, style);
+        UnityPrintIntNumberByStyle(expected, style);
         UnityPrint(UnityStrWas);
-        UnityPrintNumberByStyle(actual, style);
+        UnityPrintIntNumberByStyle(actual, style);
         UnityAddMsgIfSpecified(msg);
         UNITY_FAIL_AND_BAIL;
     }
 }
 
+void UnityAssertEqualUintNumber(const UNITY_UINT expected,
+                                const UNITY_UINT actual,
+                                const char* msg,
+                                const UNITY_LINE_TYPE lineNumber,
+                                const UNITY_DISPLAY_STYLE_T style)
+{
+    RETURN_IF_FAIL_OR_IGNORE;
+
+    if (expected != actual)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+        UnityPrint(UnityStrExpected);
+        UnityPrintUintNumberByStyle(expected, style);
+        UnityPrint(UnityStrWas);
+        UnityPrintUintNumberByStyle(actual, style);
+        UnityAddMsgIfSpecified(msg);
+        UNITY_FAIL_AND_BAIL;
+    }
+}
 /*-----------------------------------------------*/
-void UnityAssertGreaterOrLessOrEqualNumber(const UNITY_INT threshold,
-                                           const UNITY_INT actual,
-                                           const UNITY_COMPARISON_T compare,
-                                           const char *msg,
-                                           const UNITY_LINE_TYPE lineNumber,
-                                           const UNITY_DISPLAY_STYLE_T style)
+void UnityAssertIntGreaterOrLessOrEqualNumber(const UNITY_INT threshold,
+                                              const UNITY_INT actual,
+                                              const UNITY_COMPARISON_T compare,
+                                              const char *msg,
+                                              const UNITY_LINE_TYPE lineNumber,
+                                              const UNITY_DISPLAY_STYLE_T style)
 {
     int failed = 0;
     RETURN_IF_FAIL_OR_IGNORE;
 
-    if ((threshold == actual) && (compare & UNITY_EQUAL_TO)) { return; }
-    if ((threshold == actual))                               { failed = 1; }
+    if ((threshold == actual) && !(compare & UNITY_EQUAL_TO)) { failed = 1; }
 
-    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
-    {
-        if ((actual > threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; }
-        if ((actual < threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; }
-    }
-    else /* UINT or HEX */
+    if ((actual > threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; }
+    if ((actual < threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; }
+
+    if (failed)
     {
-        if (((UNITY_UINT)actual > (UNITY_UINT)threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; }
-        if (((UNITY_UINT)actual < (UNITY_UINT)threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; }
+        UnityTestResultsFailBegin(lineNumber);
+        UnityPrint(UnityStrExpected);
+        UnityPrintIntNumberByStyle(actual, style);
+        if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt);       }
+        if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt);       }
+        if (compare & UNITY_EQUAL_TO)     { UnityPrint(UnityStrOrEqual);  }
+        if (compare == UNITY_NOT_EQUAL)   { UnityPrint(UnityStrNotEqual); }
+        UnityPrintIntNumberByStyle(threshold, style);
+        UnityAddMsgIfSpecified(msg);
+        UNITY_FAIL_AND_BAIL;
     }
+}
+
+void UnityAssertUintGreaterOrLessOrEqualNumber(const UNITY_UINT threshold,
+                                               const UNITY_UINT actual,
+                                               const UNITY_COMPARISON_T compare,
+                                               const char *msg,
+                                               const UNITY_LINE_TYPE lineNumber,
+                                               const UNITY_DISPLAY_STYLE_T style)
+{
+    int failed = 0;
+    RETURN_IF_FAIL_OR_IGNORE;
+
+    if ((threshold == actual) && !(compare & UNITY_EQUAL_TO)) { failed = 1; }
+
+    /* UINT or HEX */
+    if ((actual > threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; }
+    if ((actual < threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; }
 
     if (failed)
     {
         UnityTestResultsFailBegin(lineNumber);
         UnityPrint(UnityStrExpected);
-        UnityPrintNumberByStyle(actual, style);
+        UnityPrintUintNumberByStyle(actual, style);
         if (compare & UNITY_GREATER_THAN) { UnityPrint(UnityStrGt);       }
         if (compare & UNITY_SMALLER_THAN) { UnityPrint(UnityStrLt);       }
         if (compare & UNITY_EQUAL_TO)     { UnityPrint(UnityStrOrEqual);  }
         if (compare == UNITY_NOT_EQUAL)   { UnityPrint(UnityStrNotEqual); }
-        UnityPrintNumberByStyle(threshold, style);
+        UnityPrintUintNumberByStyle(threshold, style);
         UnityAddMsgIfSpecified(msg);
         UNITY_FAIL_AND_BAIL;
     }
@@ -786,6 +904,8 @@ void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
                               const UNITY_DISPLAY_STYLE_T style,
                               const UNITY_FLAGS_T flags)
 {
+    UNITY_INT expect_val   = 0;
+    UNITY_INT actual_val   = 0;
     UNITY_UINT32 elements  = num_elements;
     unsigned int length    = style & 0xF;
     unsigned int increment = 0;
@@ -813,9 +933,6 @@ void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
 
     while ((elements > 0) && (elements--))
     {
-        UNITY_INT expect_val;
-        UNITY_INT actual_val;
-
         switch (length)
         {
             case 1:
@@ -877,9 +994,9 @@ void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected,
             UnityPrint(UnityStrElement);
             UnityPrintNumberUnsigned(num_elements - elements - 1);
             UnityPrint(UnityStrExpected);
-            UnityPrintNumberByStyle(expect_val, style);
+            UnityPrintIntNumberByStyle(expect_val, style);
             UnityPrint(UnityStrWas);
-            UnityPrintNumberByStyle(actual_val, style);
+            UnityPrintIntNumberByStyle(actual_val, style);
             UnityAddMsgIfSpecified(msg);
             UNITY_FAIL_AND_BAIL;
         }
@@ -1028,6 +1145,7 @@ void UnityAssertFloatsWithin(const UNITY_FLOAT delta,
     }
 }
 
+#ifndef   UNITY_EXCLUDE_FLOAT_PRINT
 /*-----------------------------------------------*/
 void UnityAssertFloatsNotWithin(const UNITY_FLOAT delta,
                                 const UNITY_FLOAT expected,
@@ -1081,6 +1199,7 @@ void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold,
         UNITY_FAIL_AND_BAIL;
     }
 }
+#endif /* ! UNITY_EXCLUDE_FLOAT_PRINT */
 
 /*-----------------------------------------------*/
 void UnityAssertFloatSpecial(const UNITY_FLOAT actual,
@@ -1255,6 +1374,7 @@ void UnityAssertDoublesWithin(const UNITY_DOUBLE delta,
     }
 }
 
+#ifndef    UNITY_EXCLUDE_FLOAT_PRINT
 /*-----------------------------------------------*/
 void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta,
                                  const UNITY_DOUBLE expected,
@@ -1308,6 +1428,7 @@ void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold,
         UNITY_FAIL_AND_BAIL;
     }
 }
+#endif /* ! UNITY_EXCLUDE_FLOAT_PRINT */
 
 /*-----------------------------------------------*/
 void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual,
@@ -1377,47 +1498,65 @@ void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual,
 #endif /* not UNITY_EXCLUDE_DOUBLE */
 
 /*-----------------------------------------------*/
-void UnityAssertNumbersWithin(const UNITY_UINT delta,
-                              const UNITY_INT expected,
-                              const UNITY_INT actual,
-                              const char* msg,
-                              const UNITY_LINE_TYPE lineNumber,
-                              const UNITY_DISPLAY_STYLE_T style)
+void UnityAssertIntNumbersWithin(const UNITY_UINT delta,
+                                 const UNITY_INT expected,
+                                 const UNITY_INT actual,
+                                 const char* msg,
+                                 const UNITY_LINE_TYPE lineNumber,
+                                 const UNITY_DISPLAY_STYLE_T style)
 {
     RETURN_IF_FAIL_OR_IGNORE;
 
-    if ((style & UNITY_DISPLAY_RANGE_INT) == UNITY_DISPLAY_RANGE_INT)
+    if (actual > expected)
     {
-        if (actual > expected)
-        {
-            Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta);
-        }
-        else
-        {
-            Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta);
-        }
+        Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta);
     }
     else
     {
-        if ((UNITY_UINT)actual > (UNITY_UINT)expected)
-        {
-            Unity.CurrentTestFailed = (((UNITY_UINT)actual - (UNITY_UINT)expected) > delta);
-        }
-        else
-        {
-            Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta);
-        }
+        Unity.CurrentTestFailed = (((UNITY_UINT)expected - (UNITY_UINT)actual) > delta);
     }
 
     if (Unity.CurrentTestFailed)
     {
         UnityTestResultsFailBegin(lineNumber);
         UnityPrint(UnityStrDelta);
-        UnityPrintNumberByStyle((UNITY_INT)delta, style);
+        UnityPrintIntNumberByStyle((UNITY_INT)delta, style);
         UnityPrint(UnityStrExpected);
-        UnityPrintNumberByStyle(expected, style);
+        UnityPrintIntNumberByStyle(expected, style);
         UnityPrint(UnityStrWas);
-        UnityPrintNumberByStyle(actual, style);
+        UnityPrintIntNumberByStyle(actual, style);
+        UnityAddMsgIfSpecified(msg);
+        UNITY_FAIL_AND_BAIL;
+    }
+}
+
+void UnityAssertUintNumbersWithin(const UNITY_UINT delta,
+                                  const UNITY_UINT expected,
+                                  const UNITY_UINT actual,
+                                  const char* msg,
+                                  const UNITY_LINE_TYPE lineNumber,
+                                  const UNITY_DISPLAY_STYLE_T style)
+{
+    RETURN_IF_FAIL_OR_IGNORE;
+
+    if (actual > expected)
+    {
+        Unity.CurrentTestFailed = ((actual - expected) > delta);
+    }
+    else
+    {
+        Unity.CurrentTestFailed = ((expected - actual) > delta);
+    }
+
+    if (Unity.CurrentTestFailed)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+        UnityPrint(UnityStrDelta);
+        UnityPrintUintNumberByStyle(delta, style);
+        UnityPrint(UnityStrExpected);
+        UnityPrintUintNumberByStyle(expected, style);
+        UnityPrint(UnityStrWas);
+        UnityPrintUintNumberByStyle(actual, style);
         UnityAddMsgIfSpecified(msg);
         UNITY_FAIL_AND_BAIL;
     }
@@ -1568,13 +1707,13 @@ void UnityAssertNumbersArrayWithin(const UNITY_UINT delta,
             }
             UnityTestResultsFailBegin(lineNumber);
             UnityPrint(UnityStrDelta);
-            UnityPrintNumberByStyle((UNITY_INT)delta, style);
+            UnityPrintIntNumberByStyle((UNITY_INT)delta, style);
             UnityPrint(UnityStrElement);
             UnityPrintNumberUnsigned(num_elements - elements - 1);
             UnityPrint(UnityStrExpected);
-            UnityPrintNumberByStyle(expect_val, style);
+            UnityPrintIntNumberByStyle(expect_val, style);
             UnityPrint(UnityStrWas);
-            UnityPrintNumberByStyle(actual_val, style);
+            UnityPrintIntNumberByStyle(actual_val, style);
             UnityAddMsgIfSpecified(msg);
             UNITY_FAIL_AND_BAIL;
         }
@@ -1594,6 +1733,7 @@ void UnityAssertEqualString(const char* expected,
                             const UNITY_LINE_TYPE lineNumber)
 {
     UNITY_UINT32 i;
+    UNITY_UINT32 i_diff = 0;
 
     RETURN_IF_FAIL_OR_IGNORE;
 
@@ -1605,6 +1745,7 @@ void UnityAssertEqualString(const char* expected,
             if (expected[i] != actual[i])
             {
                 Unity.CurrentTestFailed = 1;
+                i_diff = i;
                 break;
             }
         }
@@ -1620,7 +1761,7 @@ void UnityAssertEqualString(const char* expected,
     if (Unity.CurrentTestFailed)
     {
         UnityTestResultsFailBegin(lineNumber);
-        UnityPrintExpectedAndActualStrings(expected, actual);
+        UnityPrintExpectedAndActualStrings(expected, actual, i_diff);
         UnityAddMsgIfSpecified(msg);
         UNITY_FAIL_AND_BAIL;
     }
@@ -1634,6 +1775,7 @@ void UnityAssertEqualStringLen(const char* expected,
                                const UNITY_LINE_TYPE lineNumber)
 {
     UNITY_UINT32 i;
+    UNITY_UINT32 i_diff = 0;
 
     RETURN_IF_FAIL_OR_IGNORE;
 
@@ -1645,6 +1787,7 @@ void UnityAssertEqualStringLen(const char* expected,
             if (expected[i] != actual[i])
             {
                 Unity.CurrentTestFailed = 1;
+                i_diff = i;
                 break;
             }
         }
@@ -1660,7 +1803,7 @@ void UnityAssertEqualStringLen(const char* expected,
     if (Unity.CurrentTestFailed)
     {
         UnityTestResultsFailBegin(lineNumber);
-        UnityPrintExpectedAndActualStringsLen(expected, actual, length);
+        UnityPrintExpectedAndActualStringsLen(expected, actual, length, i_diff);
         UnityAddMsgIfSpecified(msg);
         UNITY_FAIL_AND_BAIL;
     }
@@ -1675,6 +1818,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
                                  const UNITY_FLAGS_T flags)
 {
     UNITY_UINT32 i = 0;
+    UNITY_UINT32 i_diff = 0;
     UNITY_UINT32 j = 0;
     const char* expd = NULL;
     const char* act = NULL;
@@ -1722,6 +1866,7 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
                 if (expd[i] != act[i])
                 {
                     Unity.CurrentTestFailed = 1;
+                    i_diff = i;
                     break;
                 }
             }
@@ -1742,13 +1887,186 @@ void UnityAssertEqualStringArray(UNITY_INTERNAL_PTR expected,
                 UnityPrint(UnityStrElement);
                 UnityPrintNumberUnsigned(j);
             }
-            UnityPrintExpectedAndActualStrings(expd, act);
+            UnityPrintExpectedAndActualStrings(expd, act, i_diff);
             UnityAddMsgIfSpecified(msg);
             UNITY_FAIL_AND_BAIL;
         }
     } while (++j < num_elements);
 }
 
+/*-----------------------------------------------*/
+void UnityAssertNotEqualString(const char* expected,
+                               const char* actual,
+                               const char* msg,
+                               const UNITY_LINE_TYPE lineNumber)
+{
+    UNITY_UINT32 i;
+    
+    RETURN_IF_FAIL_OR_IGNORE;
+
+    /* If both pointers are null or same pointer, they are equal (FAIL) */
+    if (expected == actual)
+    {
+        Unity.CurrentTestFailed = 1;
+    }
+    /* If only one is null, they are not equal (PASS) */
+    else if ((expected == NULL) || (actual == NULL))
+    {
+        return;
+    }
+    else
+    {
+        for (i = 0; expected[i] || actual[i]; i++)
+        {
+            if (expected[i] != actual[i])
+            {
+                return; /* Strings are different (PASS) */
+            }
+        }
+
+        /* Strings are equal (FAIL) */
+        Unity.CurrentTestFailed = 1;
+    }
+
+    if (Unity.CurrentTestFailed)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+        UnityPrint(UnityStrExpected);
+
+        if (msg)
+        {
+            UnityAddMsgIfSpecified(msg);
+        }
+        else
+        {
+            UnityPrint(" Expected strings to be different");
+        }
+
+        UNITY_FAIL_AND_BAIL;
+    }
+}
+
+/*-----------------------------------------------*/
+void UnityAssertNotEqualStringLen(const char* expected,
+                                  const char* actual,
+                                  const UNITY_UINT32 length,
+                                  const char* msg,
+                                  const UNITY_LINE_TYPE lineNumber)
+{
+    UNITY_UINT32 i;
+
+    RETURN_IF_FAIL_OR_IGNORE;
+
+    if (length == 0)
+    {
+        UnityPrintPointlessAndBail();
+    }
+
+    /* If both pointers are same (including both NULL), they are equal (FAIL) */
+    if (expected == actual)
+    {
+        Unity.CurrentTestFailed = 1;
+    }
+    /* If only one is null, they are not equal (PASS) */
+    else if ((expected == NULL) || (actual == NULL))
+    {
+        return;
+    }
+    else
+    {
+        for (i = 0; (i < length) && (expected[i] || actual[i]); i++)
+        {
+            if (expected[i] != actual[i])
+            {
+                return; /* Strings are different (PASS) */
+            }
+        }
+
+        /* Strings are equal within length (FAIL) */
+        Unity.CurrentTestFailed = 1;
+    }
+
+    if (Unity.CurrentTestFailed)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+        UnityPrintExpectedAndActualStringsLen(expected, actual, length, length);
+
+        if (msg)
+        {
+            UnityAddMsgIfSpecified(msg);
+        }
+        else
+        {
+            UnityPrint(" Expected strings to be different");
+        }
+        
+        UNITY_FAIL_AND_BAIL;
+    }
+}
+
+/*-----------------------------------------------*/
+void UnityAssertNotEqualMemory(UNITY_INTERNAL_PTR expected,
+                               UNITY_INTERNAL_PTR actual,
+                               const UNITY_UINT32 length,
+                               const char* msg,
+                               const UNITY_LINE_TYPE lineNumber)
+{
+    UNITY_PTR_ATTRIBUTE const unsigned char* ptr_exp = (UNITY_PTR_ATTRIBUTE const unsigned char*)expected;
+    UNITY_PTR_ATTRIBUTE const unsigned char* ptr_act = (UNITY_PTR_ATTRIBUTE const unsigned char*)actual;
+    UNITY_UINT32 bytes;
+
+    RETURN_IF_FAIL_OR_IGNORE;
+
+    if (length == 0)
+    {
+        UnityPrintPointlessAndBail();
+    }
+
+    if (expected == actual)
+    {
+        /* Both are NULL or same pointer (FAIL) */
+        Unity.CurrentTestFailed = 1;
+    }
+    else if (expected == NULL || actual == NULL)
+    {
+        /* One is NULL and other is not (PASS) */
+        return;
+    }
+    else
+    {
+        bytes = length;
+        while (bytes--)
+        {
+            if (*ptr_exp != *ptr_act)
+            {
+                return; /* Memory is different (PASS) */
+            }
+            ptr_exp++;
+            ptr_act++;
+        }
+
+        /* Memory is equal (PASS) */
+        Unity.CurrentTestFailed = 1;
+    }
+
+    if (Unity.CurrentTestFailed)
+    {
+        UnityTestResultsFailBegin(lineNumber);
+        UnityPrint(UnityStrMemory);
+
+        if (msg)
+        {
+            UnityAddMsgIfSpecified(msg);
+        }
+        else
+        {
+            UnityPrint(" Expected memory to be different");
+        }
+
+        UNITY_FAIL_AND_BAIL;
+    }
+}
+
 /*-----------------------------------------------*/
 void UnityAssertEqualMemory(UNITY_INTERNAL_PTR expected,
                             UNITY_INTERNAL_PTR actual,
@@ -1805,9 +2123,9 @@ void UnityAssertEqualMemory(UNITY_INTERNAL_PTR expected,
                 UnityPrint(UnityStrByte);
                 UnityPrintNumberUnsigned(length - bytes - 1);
                 UnityPrint(UnityStrExpected);
-                UnityPrintNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8);
+                UnityPrintIntNumberByStyle(*ptr_exp, UNITY_DISPLAY_STYLE_HEX8);
                 UnityPrint(UnityStrWas);
-                UnityPrintNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8);
+                UnityPrintIntNumberByStyle(*ptr_act, UNITY_DISPLAY_STYLE_HEX8);
                 UnityAddMsgIfSpecified(msg);
                 UNITY_FAIL_AND_BAIL;
             }
@@ -1937,7 +2255,7 @@ static enum UnityLengthModifier UnityLengthModifierGet(const char *pch, int *len
             }
         case 'h':
             {
-                // short and char are converted to int
+                /* short and char are converted to int */
                 length_mod = UNITY_LENGTH_MODIFIER_NONE;
                 if (pch[1] == 'h')
                 {
@@ -1954,7 +2272,7 @@ static enum UnityLengthModifier UnityLengthModifierGet(const char *pch, int *len
         case 't':
         case 'L':
             {
-                // Not supported, but should gobble up the length specifier anyway
+                /* Not supported, but should gobble up the length specifier anyway */
                 length_mod = UNITY_LENGTH_MODIFIER_NONE;
                 *length = 1;
                 break;
@@ -2127,32 +2445,7 @@ void UnityFail(const char* msg, const UNITY_LINE_TYPE line)
 
     UnityTestResultsBegin(Unity.TestFile, line);
     UnityPrint(UnityStrFail);
-    if (msg != NULL)
-    {
-        UNITY_OUTPUT_CHAR(':');
-
-#ifdef UNITY_PRINT_TEST_CONTEXT
-        UNITY_PRINT_TEST_CONTEXT();
-#endif
-#ifndef UNITY_EXCLUDE_DETAILS
-        if (Unity.CurrentDetail1)
-        {
-            UnityPrint(UnityStrDetail1Name);
-            UnityPrint(Unity.CurrentDetail1);
-            if (Unity.CurrentDetail2)
-            {
-                UnityPrint(UnityStrDetail2Name);
-                UnityPrint(Unity.CurrentDetail2);
-            }
-            UnityPrint(UnityStrSpacer);
-        }
-#endif
-        if (msg[0] != ' ')
-        {
-            UNITY_OUTPUT_CHAR(' ');
-        }
-        UnityPrint(msg);
-    }
+    UnityAddMsgIfSpecified(msg);
 
     UNITY_FAIL_AND_BAIL;
 }
@@ -2195,7 +2488,13 @@ void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int
     Unity.CurrentTestName = FuncName;
     Unity.CurrentTestLineNumber = (UNITY_LINE_TYPE)FuncLineNum;
     Unity.NumberOfTests++;
+    #ifndef UNITY_EXCLUDE_DETAILS
+    #ifdef UNITY_DETAIL_STACK_SIZE
+    Unity.CurrentDetailStackSize = 0;
+    #else
     UNITY_CLR_DETAILS();
+    #endif
+    #endif
     UNITY_EXEC_TIME_START();
     if (TEST_PROTECT())
     {
@@ -2263,6 +2562,46 @@ int UnityEnd(void)
     return (int)(Unity.TestFailures);
 }
 
+/*-----------------------------------------------
+ * Details Stack
+ *-----------------------------------------------*/
+#ifndef UNITY_EXCLUDE_DETAILS
+#ifdef UNITY_DETAIL_STACK_SIZE
+void UnityPushDetail(UNITY_DETAIL_LABEL_TYPE label, UNITY_DETAIL_VALUE_TYPE value, const UNITY_LINE_TYPE line) {
+    if (Unity.CurrentDetailStackSize >= UNITY_DETAIL_STACK_SIZE) {
+        UnityTestResultsFailBegin(line);
+        UnityPrint(UnityStrErrDetailStackFull);
+        UnityAddMsgIfSpecified(NULL);
+        UNITY_FAIL_AND_BAIL;
+    }
+    if (label >= UnityStrDetailLabelsCount) {
+        UnityTestResultsFailBegin(line);
+        UnityPrint(UnityStrErrDetailStackLabel);
+        UnityPrintNumberUnsigned(label);
+        UnityAddMsgIfSpecified(NULL);
+        UNITY_FAIL_AND_BAIL;
+    }
+    Unity.CurrentDetailStackLabels[Unity.CurrentDetailStackSize] = label;
+    Unity.CurrentDetailStackValues[Unity.CurrentDetailStackSize++] = value;
+}
+void UnityPopDetail(UNITY_DETAIL_LABEL_TYPE label, UNITY_DETAIL_VALUE_TYPE value, const UNITY_LINE_TYPE line) {
+    if (Unity.CurrentDetailStackSize == 0) {
+        UnityTestResultsFailBegin(line);
+        UnityPrint(UnityStrErrDetailStackEmpty);
+        UnityAddMsgIfSpecified(NULL);
+        UNITY_FAIL_AND_BAIL;
+    }
+    if ((Unity.CurrentDetailStackLabels[Unity.CurrentDetailStackSize-1] != label) || (Unity.CurrentDetailStackValues[Unity.CurrentDetailStackSize-1] != value)) {
+        UnityTestResultsFailBegin(line);
+        UnityPrint(UnityStrErrDetailStackPop);
+        UnityAddMsgIfSpecified(NULL);
+        UNITY_FAIL_AND_BAIL;
+    }   
+    Unity.CurrentDetailStackSize--;
+}
+#endif
+#endif
+
 /*-----------------------------------------------
  * Command Line Argument Support
  *-----------------------------------------------*/
@@ -2394,7 +2733,7 @@ static int IsStringInBiggerString(const char* longstring, const char* shortstrin
             }
         }
 
-        // If we didn't match and we're on strict matching, we already know we failed
+        /* If we didn't match and we're on strict matching, we already know we failed */
         if (UnityStrictMatch)
         {
             return 0;