From 9f4b1a332f28f1369f901abb373b6dfc3db10520 Mon Sep 17 00:00:00 2001 From: jsalling Date: Mon, 14 Nov 2016 23:10:18 -0600 Subject: [PATCH] Tests for Printing Floating Point numbers --- src/unity.c | 2 +- test/tests/testunity.c | 97 ++++++++++++++++++++++++++++++++++++------ 2 files changed, 85 insertions(+), 14 deletions(-) diff --git a/src/unity.c b/src/unity.c index 0dad740..48f0be3 100644 --- a/src/unity.c +++ b/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; diff --git a/test/tests/testunity.c b/test/tests/testunity.c index 08289da..9a0f714 100644 --- a/test/tests/testunity.c +++ b/test/tests/testunity.c @@ -7,6 +7,7 @@ #include "unity.h" #include #include +#include // 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 +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); - //Double + TEST_ASSERT_EQUAL_PRINT_FLOATING("NaN", -3.40282346638e38f*2.0f * f_zero); +#endif +} + +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 }