Added first working implementation.

src/unity.c

@@ -67,6 +67,57 @@ static const char UnityStrDetail2Name[]            = " " UNITY_DETAIL2_NAME " ";
  * Pretty Printers & Test Result Output Handlers
  *-----------------------------------------------*/
 
+/*-----------------------------------------------*/
+/* Local helper function to print characters. */
+static void UnityPrintChar(const char* pch)
+{
+    /* printable characters plus CR & LF are printed */
+    if ((*pch <= 126) && (*pch >= 32))
+    {
+        UNITY_OUTPUT_CHAR(*pch);
+    }
+    /* write escaped carriage returns */
+    else if (*pch == 13)
+    {
+        UNITY_OUTPUT_CHAR('\\');
+        UNITY_OUTPUT_CHAR('r');
+    }
+    /* write escaped line feeds */
+    else if (*pch == 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)*pch, 2);
+    }
+}
+
+/*-----------------------------------------------*/
+#ifdef UNITY_OUTPUT_COLOR
+static UNITY_UINT UnityPrintAnsiEscapeString(const char* string)
+{
+    const char* pch = string;
+    UNITY_UINT count = 0;
+
+    while (*pch && *pch != 'm')
+    {
+        UNITY_OUTPUT_CHAR(*pch);
+        pch++;
+        count++;
+    }
+    UNITY_OUTPUT_CHAR('m');
+    count++;
+
+    return count;
+}
+#endif
+
+/*-----------------------------------------------*/
 void UnityPrint(const char* string)
 {
     const char* pch = string;
@@ -75,47 +126,108 @@ void UnityPrint(const char* string)
     {
         while (*pch)
         {
-            /* printable characters plus CR & LF are printed */
-            if ((*pch <= 126) && (*pch >= 32))
-            {
-                UNITY_OUTPUT_CHAR(*pch);
-            }
-            /* write escaped carriage returns */
-            else if (*pch == 13)
+#ifdef UNITY_OUTPUT_COLOR
+            /* print ANSI escape code */
+            if (*pch == 27 && *(pch + 1) == '[')
             {
-                UNITY_OUTPUT_CHAR('\\');
-                UNITY_OUTPUT_CHAR('r');
+                pch += UnityPrintAnsiEscapeString(pch);
+                continue;
             }
-            /* write escaped line feeds */
-            else if (*pch == 10)
+#endif
+            UnityPrintChar(pch);
+            pch++;
+        }
+    }
+}
+
+/*-----------------------------------------------*/
+#ifndef UNITY_EXCLUDE_PRINT_FORMATTED
+void UnityPrintFormatted(const char* format, ... )
+{
+    const char* pch = format;
+    va_list va;
+    va_start(va, format);
+
+    if (pch != NULL)
+    {
+        while (*pch)
+        {
+            /* format identification character */
+            if (*pch == '%')
             {
-                UNITY_OUTPUT_CHAR('\\');
-                UNITY_OUTPUT_CHAR('n');
+                pch++;
+
+                if (pch != NULL)
+                {
+                    switch (*pch)
+                    {
+                        case 'd':
+                        case 'i':
+                            {
+                                const UNITY_INT number = va_arg(va, UNITY_INT);
+                                UnityPrintNumber(number);
+                                break;
+                            }
+                        case 'u':
+                            {
+                                const UNITY_UINT number = va_arg(va, UNITY_UINT);
+                                UnityPrintNumberUnsigned(number);
+                                break;
+                            }
+                        case 'x':
+                        case 'X':
+                        case 'p':
+                            {
+                                const UNITY_UINT number = va_arg(va, UNITY_UINT);
+                                UNITY_OUTPUT_CHAR('0');
+                                UNITY_OUTPUT_CHAR('x');
+                                UnityPrintNumberHex(number, 8);
+                                break;
+                            }
+                        case 'c':
+                            {
+                                const UNITY_INT ch = va_arg(va, UNITY_INT);
+                                UnityPrintChar((const char *)&ch);
+                                break;
+                            }
+                        case 's':
+                            {   const char * string = va_arg(va, const char *);
+                                UnityPrint(string);
+                                break;
+                            }
+                        case '%':
+                        default:
+                            UnityPrintChar(pch);
+                            break;
+                    }
+                }
             }
 #ifdef UNITY_OUTPUT_COLOR
             /* print ANSI escape code */
             else if (*pch == 27 && *(pch + 1) == '[')
             {
-                while (*pch && *pch != 'm')
-                {
-                    UNITY_OUTPUT_CHAR(*pch);
-                    pch++;
-                }
-                UNITY_OUTPUT_CHAR('m');
+                pch += UnityPrintAnsiEscapeString(pch);
+                continue;
             }
 #endif
-            /* unprintable characters are shown as codes */
+            else if (*pch == '\n')
+            {
+                UNITY_PRINT_EOL();
+            }
             else
             {
-                UNITY_OUTPUT_CHAR('\\');
-                UNITY_OUTPUT_CHAR('x');
-                UnityPrintNumberHex((UNITY_UINT)*pch, 2);
+                UnityPrintChar(pch);
             }
+
             pch++;
         }
     }
+
+    va_end(va);
 }
+#endif /* ! UNITY_EXCLUDE_PRINT_FORMATTED */
 
+/*-----------------------------------------------*/
 void UnityPrintLen(const char* string, const UNITY_UINT32 length)
 {
     const char* pch = string;

src/unity_internals.h

@@ -23,6 +23,10 @@
 #include <stddef.h>
 #endif
 
+#ifndef UNITY_EXCLUDE_PRINT_FORMATTED
+#include <stdarg.h>
+#endif
+
 /* Unity Attempts to Auto-Detect Integer Types
  * 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
@@ -489,6 +493,11 @@ void UnityDefaultTestRun(UnityTestFunction Func, const char* FuncName, const int
  *-------------------------------------------------------*/
 
 void UnityPrint(const char* string);
+
+#ifndef UNITY_EXCLUDE_PRINT_FORMATTED
+void UnityPrintFormatted(const char* format, ... );
+#endif
+
 void UnityPrintLen(const char* string, const UNITY_UINT32 length);
 void UnityPrintMask(const UNITY_UINT mask, const UNITY_UINT number);
 void UnityPrintNumberByStyle(const UNITY_INT number, const UNITY_DISPLAY_STYLE_T style);