Tests for Printing Floating Point numbers

src/unity.c

@@ -297,7 +297,7 @@ void UnityPrintFloat(_UD number)
         /* Double precision calculation gives best performance for six rounded decimal places */
         ROUND_TIES_TO_EVEN(fraction_part, (number - integer_part)*1000000.0);
 
-        if (fraction_part == 1000000)
+        if (fraction_part == 1000000) /* Carry across the decimal point */
         {
             fraction_part = 0;
             integer_part += 1;

test/tests/testunity.c

@@ -7,6 +7,7 @@
 #include "unity.h"
 #include <setjmp.h>
 #include <string.h>
+#include <stdint.h>
 
 // Dividing by these constants produces +/- infinity.
 // The rationale is given in UnityAssertFloatIsInf's body.
@@ -2237,7 +2238,7 @@ void testIgnoredAndThenFailInTearDown(void)
 #endif
 
 #ifdef USING_OUTPUT_SPY
-#include <stdio.h>
+int putchar(int);
 #define SPY_BUFFER_MAX 40
 static char putcharSpyBuffer[SPY_BUFFER_MAX];
 #endif
@@ -3237,16 +3238,14 @@ void testNotEqualFloatArraysLengthZero(void)
         TEST_ASSERT_EQUAL_STRING((expected), getBufferPutcharSpy());    \
         }
 
-void testFloatVerbosePrinting(void)
+void testFloatPrinting(void)
 {
-#if !defined(UNITY_EXCLUDE_FLOAT_PRINT) && defined(USING_OUTPUT_SPY)
+#if defined(UNITY_EXCLUDE_FLOAT_PRINT) || !defined(USING_OUTPUT_SPY)
+    TEST_IGNORE();
+#else
     TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0",          0.0f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("0.000000...",  0.000000499f);
-    float smallest = 0.0000005f;
-    *(int*)&smallest += 1;
-    TEST_ASSERT_EQUAL_PRINT_FLOATING("0.000001", smallest);
-    TEST_ASSERT_EQUAL_PRINT_FLOATING("0.007812",     0.0078125f); /*not if ties round away from 0*/
-    TEST_ASSERT_EQUAL_PRINT_FLOATING("0.976562",     0.9765625f); /*not if ties round away from 0*/
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("0.000001",     0.00000050000005f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469",     0.100469499f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0",          0.9999995f); /*Rounding to int place*/
     TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0",          1.0f);
@@ -3257,37 +3256,109 @@ void testFloatVerbosePrinting(void)
     TEST_ASSERT_EQUAL_PRINT_FLOATING("16.000006",    16.000006f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("4294967040.0", 4294967040.0f); /*Last full print integer*/
 
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("0.0",         -0.0f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.000000...",-0.000000499f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.000001",   -0.00000050000005f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469",   -0.100469499f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.0",        -0.9999995f); /*Rounding to int place*/
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.0",        -1.0f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.25",       -1.25f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.999999",   -7.999999f); /*Not rounding*/
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000002",  -16.000002f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000004",  -16.000004f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-16.000006",  -16.000006f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-4294967040.0",-4294967040.0f); /*Last full print integer*/
+
     TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09",  4294967296.0f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("5.0e+09",        5000000000.0f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("8.0e+09",        8.0e+09f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("8.3099991e+09",  8309999104.0f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10",        1.0e+10f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10",        10000000000.0f);
-
     TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00005499e+10", 1.000055e+10f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("1.10000006e+38", 1.10000005e+38f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("1.63529943e+10", 1.63529943e+10f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("3.40282347e+38", 3.40282346638e38f);
 
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-1.0e+10",       -1.0e+10f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-3.40282347e+38",-3.40282346638e38f);
+#endif
+}
+
+void testFloatPrintingRoundTiesToEven(void)
+{
+#if defined(UNITY_EXCLUDE_FLOAT) || !defined(USING_OUTPUT_SPY)
+    TEST_IGNORE();
+#else
+  #ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("0.007813", 0.0078125f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("0.976563", 0.9765625f);
+  #else /* Default to Round ties to even */
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("0.007182", 0.0071825f);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("0.976562", 0.9765625f);
+  #endif
+#endif
+}
+
+void testFloatPrintingInfinityAndNaN(void)
+{
+#if defined(UNITY_EXCLUDE_FLOAT) || !defined(USING_OUTPUT_SPY)
+    TEST_IGNORE();
+#else
     TEST_ASSERT_EQUAL_PRINT_FLOATING("Inf",   3.40282346638e38f*2.0f);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("Inf",   1.0f / f_zero);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("-Inf", -3.40282346638e38f*2.0f);
+
     TEST_ASSERT_EQUAL_PRINT_FLOATING("NaN",  -3.40282346638e38f*2.0f * f_zero);
+#endif
+}
 
-    //Double
+void testDoublePrinting(void)
+{
+#if defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
+    TEST_IGNORE();
+#else
     TEST_ASSERT_EQUAL_PRINT_FLOATING("0.100469",         0.10046949999999999);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("4294967295.999999", 4294967295.999999);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09",     4294967295.9999995);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("4.2949673e+09",     4294967296.0);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10",           9999999995.0);
-    TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10",           10000000050.0); /*not if ties round away from 0*/
-    TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719924e+15",    9007199245000000.0); /*not if ties round away from 0*/
     TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15",    9007199254740990.0);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("7.0e+100",          7.0e+100);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("3.0e+200",          3.0e+200);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("9.23456789e+300",   9.23456789e+300);
+
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-0.100469",         -0.10046949999999999);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-4294967295.999999", -4294967295.999999);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-4.2949673e+09",     -4294967295.9999995);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("-7.0e+100",          -7.0e+100);
+#endif
+}
+
+void testDoublePrintingRoundTiesToEven(void)
+{
+#if defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
+    TEST_IGNORE();
+#else
+  #ifdef UNITY_ROUND_TIES_AWAY_FROM_ZERO
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("1.00000001e+10", 10000000050.0);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719925e+15", 9007199245000000.0);
+  #else /* Default to Round ties to even */
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("1.0e+10",        10000000050.0);
+    TEST_ASSERT_EQUAL_PRINT_FLOATING("9.00719924e+15", 9007199245000000.0);
+  #endif
+#endif
+}
 
+void testDoublePrintingInfinityAndNaN(void)
+{
+#if defined(UNITY_EXCLUDE_DOUBLE) || !defined(USING_OUTPUT_SPY)
+    TEST_IGNORE();
+#else
     TEST_ASSERT_EQUAL_PRINT_FLOATING("Inf",   1.7976931348623157e308*10.0);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("Inf",   1.0 / d_zero);
     TEST_ASSERT_EQUAL_PRINT_FLOATING("-Inf", -1.7976931348623157e308*10.0);
+
     TEST_ASSERT_EQUAL_PRINT_FLOATING("NaN",  -1.7976931348623157e308*10.0 * d_zero);
 #endif
 }