From 6567f07f477b844a357eb24d1845c95b4caca74e Mon Sep 17 00:00:00 2001 From: AJIOB Date: Mon, 28 Nov 2022 17:47:08 +0300 Subject: [PATCH 1/8] Adding possibility for setting relative & absolute floating difference --- src/unity.c | 57 +++++++++++++++++++++++-------------------- src/unity_internals.h | 34 ++++++++++++++------------ 2 files changed, 48 insertions(+), 43 deletions(-) diff --git a/src/unity.c b/src/unity.c index 5786318..ff331d2 100644 --- a/src/unity.c +++ b/src/unity.c @@ -894,13 +894,14 @@ void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, /*-----------------------------------------------*/ #ifndef UNITY_EXCLUDE_FLOAT /* Wrap this define in a function with variable types as float or double */ -#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff) \ +#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta0, delta1, expected, actual, diff) \ if (isinf(expected) && isinf(actual) && (((expected) < 0) == ((actual) < 0))) return 1; \ if (UNITY_NAN_CHECK) return 1; \ (diff) = (actual) - (expected); \ if ((diff) < 0) (diff) = -(diff); \ - if ((delta) < 0) (delta) = -(delta); \ - return !(isnan(diff) || isinf(diff) || ((diff) > (delta))) + if ((delta0) < 0) (delta0) = -(delta0); \ + if ((delta1) < 0) (delta1) = -(delta1); \ + return !(isnan(diff) || isinf(diff) || ((diff) > ((delta0) + (delta1)))) /* 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) @@ -922,19 +923,20 @@ void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, #endif /* UNITY_EXCLUDE_FLOAT_PRINT */ /*-----------------------------------------------*/ -static int UnityFloatsWithin(UNITY_FLOAT delta, UNITY_FLOAT expected, UNITY_FLOAT actual) +static int UnityFloatsWithin(UNITY_FLOAT delta0, UNITY_FLOAT delta1, UNITY_FLOAT expected, UNITY_FLOAT actual) { UNITY_FLOAT diff; - UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); + UNITY_FLOAT_OR_DOUBLE_WITHIN(delta0, delta1, expected, actual, diff); } /*-----------------------------------------------*/ -void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, - UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags) +void UnityAssertWithinFloatArray(const UNITY_FLOAT delta, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) { UNITY_UINT32 elements = num_elements; UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_expected = expected; @@ -963,7 +965,7 @@ void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, while (elements--) { - if (!UnityFloatsWithin(*ptr_expected * UNITY_FLOAT_PRECISION, *ptr_expected, *ptr_actual)) + if (!UnityFloatsWithin(delta, *ptr_expected * UNITY_FLOAT_PRECISION, *ptr_expected, *ptr_actual)) { UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrElement); @@ -990,7 +992,7 @@ void UnityAssertFloatsWithin(const UNITY_FLOAT delta, RETURN_IF_FAIL_OR_IGNORE; - if (!UnityFloatsWithin(delta, expected, actual)) + if (!UnityFloatsWithin(delta, (UNITY_FLOAT)0, expected, actual)) { UnityTestResultsFailBegin(lineNumber); UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)expected, (UNITY_DOUBLE)actual); @@ -1008,7 +1010,7 @@ void UnityAssertFloatsNotWithin(const UNITY_FLOAT delta, { RETURN_IF_FAIL_OR_IGNORE; - if (UnityFloatsWithin(delta, expected, actual)) + if (UnityFloatsWithin(delta, (UNITY_FLOAT)0, expected, actual)) { UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrExpected); @@ -1037,7 +1039,7 @@ void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold, if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } - if ((compare & UNITY_EQUAL_TO) && UnityFloatsWithin(threshold * UNITY_FLOAT_PRECISION, threshold, actual)) { failed = 0; } + if ((compare & UNITY_EQUAL_TO) && UnityFloatsWithin((UNITY_FLOAT)0, threshold * UNITY_FLOAT_PRECISION, threshold, actual)) { failed = 0; } if (failed) { @@ -1121,19 +1123,20 @@ void UnityAssertFloatSpecial(const UNITY_FLOAT actual, /*-----------------------------------------------*/ #ifndef UNITY_EXCLUDE_DOUBLE -static int UnityDoublesWithin(UNITY_DOUBLE delta, UNITY_DOUBLE expected, UNITY_DOUBLE actual) +static int UnityDoublesWithin(UNITY_DOUBLE delta0, UNITY_DOUBLE delta1, UNITY_DOUBLE expected, UNITY_DOUBLE actual) { UNITY_DOUBLE diff; - UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); + UNITY_FLOAT_OR_DOUBLE_WITHIN(delta0, delta1, expected, actual, diff); } /*-----------------------------------------------*/ -void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, - UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags) +void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags) { UNITY_UINT32 elements = num_elements; UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_expected = expected; @@ -1162,7 +1165,7 @@ void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expecte while (elements--) { - if (!UnityDoublesWithin(*ptr_expected * UNITY_DOUBLE_PRECISION, *ptr_expected, *ptr_actual)) + if (!UnityDoublesWithin(delta, *ptr_expected * UNITY_DOUBLE_PRECISION, *ptr_expected, *ptr_actual)) { UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrElement); @@ -1188,7 +1191,7 @@ void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, { RETURN_IF_FAIL_OR_IGNORE; - if (!UnityDoublesWithin(delta, expected, actual)) + if (!UnityDoublesWithin(delta, 0, expected, actual)) { UnityTestResultsFailBegin(lineNumber); UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual); @@ -1206,7 +1209,7 @@ void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta, { RETURN_IF_FAIL_OR_IGNORE; - if (UnityDoublesWithin(delta, expected, actual)) + if (UnityDoublesWithin(delta, 0, expected, actual)) { UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrExpected); @@ -1235,7 +1238,7 @@ void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold, if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } - if ((compare & UNITY_EQUAL_TO) && UnityFloatsWithin(threshold * UNITY_DOUBLE_PRECISION, threshold, actual)) { failed = 0; } + if ((compare & UNITY_EQUAL_TO) && UnityDoublesWithin((UNITY_FLOAT)0, threshold * UNITY_DOUBLE_PRECISION, threshold, actual)) { failed = 0; } if (failed) { diff --git a/src/unity_internals.h b/src/unity_internals.h index f2c312c..c2a6f66 100644 --- a/src/unity_internals.h +++ b/src/unity_internals.h @@ -682,12 +682,13 @@ void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold, const char* msg, const UNITY_LINE_TYPE linenumber); -void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, - UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags); +void UnityAssertWithinFloatArray(const UNITY_FLOAT delta, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected, + UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); void UnityAssertFloatSpecial(const UNITY_FLOAT actual, const char* msg, @@ -714,12 +715,13 @@ void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold, const char* msg, const UNITY_LINE_TYPE linenumber); -void UnityAssertEqualDoubleArray(UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, - UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, - const UNITY_UINT32 num_elements, - const char* msg, - const UNITY_LINE_TYPE lineNumber, - const UNITY_FLAGS_T flags); +void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* expected, + UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* actual, + const UNITY_UINT32 num_elements, + const char* msg, + const UNITY_LINE_TYPE lineNumber, + const UNITY_FLAGS_T flags); void UnityAssertDoubleSpecial(const UNITY_DOUBLE actual, const char* msg, @@ -1062,8 +1064,8 @@ int UnityTestMatches(void); #define UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsNotWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line)) #define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) #define UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) -#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray((UNITY_FLOAT*)(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UnityAssertEqualFloatArray(UnityFloatToPtr(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)0, (UNITY_FLOAT*)(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)0, UnityFloatToPtr(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) #define UNITY_TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line)) #define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) #define UNITY_TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line)) @@ -1100,8 +1102,8 @@ int UnityTestMatches(void); #define UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesNotWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line)) #define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) #define UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) -#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray((UNITY_DOUBLE*)(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) -#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UnityAssertEqualDoubleArray(UnityDoubleToPtr(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) +#define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, (UNITY_DOUBLE*)(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) +#define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, UnityDoubleToPtr(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) #define UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line)) #define UNITY_TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_OR_EQUAL, (message), (UNITY_LINE_TYPE)(line)) #define UNITY_TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_SMALLER_THAN, (message), (UNITY_LINE_TYPE)(line)) From 9c45c7861b6a5c62d3dfe8a5a521407bad5a1d08 Mon Sep 17 00:00:00 2001 From: AJIOB Date: Mon, 28 Nov 2022 18:28:31 +0300 Subject: [PATCH 2/8] Adding support for floating point arrays within. Testing newly created API. --- src/unity.h | 4 ++++ src/unity_internals.h | 4 ++++ test/tests/test_unity_doubles.c | 25 +++++++++++++++++++++++++ test/tests/test_unity_floats.c | 25 +++++++++++++++++++++++++ 4 files changed, 58 insertions(+) diff --git a/src/unity.h b/src/unity.h index 868dc23..e321a1d 100644 --- a/src/unity.h +++ b/src/unity.h @@ -340,6 +340,7 @@ void verifyTest(void); #define TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN((delta), (expected), (actual), __LINE__, NULL) #define TEST_ASSERT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL) #define TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual) UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, NULL) #define TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) #define TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, NULL) #define TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_FLOAT((threshold), (actual), __LINE__, NULL) @@ -360,6 +361,7 @@ void verifyTest(void); #define TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN((delta), (expected), (actual), __LINE__, NULL) #define TEST_ASSERT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL) #define TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual) UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE((expected), (actual), __LINE__, NULL) +#define TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements) UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, NULL) #define TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, NULL) #define TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, NULL) #define TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual) UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE((threshold), (actual), __LINE__, NULL) @@ -620,6 +622,7 @@ void verifyTest(void); #define TEST_ASSERT_FLOAT_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, (message)) #define TEST_ASSERT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_FLOAT((expected), (actual), __LINE__, (message)) #define TEST_ASSERT_NOT_EQUAL_FLOAT_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_FLOAT_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, (message)) #define TEST_ASSERT_EQUAL_FLOAT_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) #define TEST_ASSERT_EACH_EQUAL_FLOAT_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT((expected), (actual), (num_elements), __LINE__, (message)) #define TEST_ASSERT_GREATER_THAN_FLOAT_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_FLOAT((threshold), (actual), __LINE__, (message)) @@ -639,6 +642,7 @@ void verifyTest(void); #define TEST_ASSERT_DOUBLE_WITHIN_MESSAGE(delta, expected, actual, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, (message)) #define TEST_ASSERT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message)) #define TEST_ASSERT_NOT_EQUAL_DOUBLE_MESSAGE(expected, actual, message) UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE((expected), (actual), __LINE__, (message)) +#define TEST_ASSERT_DOUBLE_ARRAY_WITHIN_MESSAGE(delta, expected, actual, num_elements, message) UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN((delta), (expected), (actual), (num_elements), __LINE__, (message)) #define TEST_ASSERT_EQUAL_DOUBLE_ARRAY_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY((expected), (actual), (num_elements), __LINE__, (message)) #define TEST_ASSERT_EACH_EQUAL_DOUBLE_MESSAGE(expected, actual, num_elements, message) UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE((expected), (actual), (num_elements), __LINE__, (message)) #define TEST_ASSERT_GREATER_THAN_DOUBLE_MESSAGE(threshold, actual, message) UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE((threshold), (actual), __LINE__, (message)) diff --git a/src/unity_internals.h b/src/unity_internals.h index c2a6f66..6a86ce9 100644 --- a/src/unity_internals.h +++ b/src/unity_internals.h @@ -1045,6 +1045,7 @@ int UnityTestMatches(void); #define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) #define UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) #define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) #define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) #define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) #define UNITY_TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) @@ -1064,6 +1065,7 @@ int UnityTestMatches(void); #define UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsNotWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line)) #define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) #define UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN((UNITY_FLOAT)(expected) * (UNITY_FLOAT)UNITY_FLOAT_PRECISION, (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)(delta), (UNITY_FLOAT*)(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) #define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)0, (UNITY_FLOAT*)(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) #define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UnityAssertWithinFloatArray((UNITY_FLOAT)0, UnityFloatToPtr(expected), (UNITY_FLOAT*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) #define UNITY_TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line)) @@ -1083,6 +1085,7 @@ int UnityTestMatches(void); #ifdef UNITY_EXCLUDE_DOUBLE #define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) #define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) #define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) #define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) #define UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) @@ -1102,6 +1105,7 @@ int UnityTestMatches(void); #define UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesNotWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line)) #define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) #define UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN((UNITY_DOUBLE)(expected) * (UNITY_DOUBLE)UNITY_DOUBLE_PRECISION, (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (UNITY_LINE_TYPE)(line), (message)) +#define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)(delta), (UNITY_DOUBLE*)(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) #define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, (UNITY_DOUBLE*)(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_ARRAY) #define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UnityAssertWithinDoubleArray((UNITY_DOUBLE)0, UnityDoubleToPtr(expected), (UNITY_DOUBLE*)(actual), (UNITY_UINT32)(num_elements), (message), (UNITY_LINE_TYPE)(line), UNITY_ARRAY_TO_VAL) #define UNITY_TEST_ASSERT_GREATER_THAN_DOUBLE(threshold, actual, line, message) UnityAssertGreaterOrLessDouble((UNITY_DOUBLE)(threshold), (UNITY_DOUBLE)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line)) diff --git a/test/tests/test_unity_doubles.c b/test/tests/test_unity_doubles.c index 1a54c0d..174f733 100644 --- a/test/tests/test_unity_doubles.c +++ b/test/tests/test_unity_doubles.c @@ -1024,6 +1024,31 @@ void testNotEqualDoubleArraysLengthZero(void) #endif } +void testDoubleArraysWithin(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {1.0, -8.0, 25.4, -0.123}; + double p1[] = {1.0, -8.0, 25.4, -0.123}; + double p2[] = {1.0, -8.0, 25.4, -0.2}; + double p3[] = {1.0, -23.0, 25.0, -0.26}; + double p4[] = {2.0, -9.0, 26.2, 0.26}; + double p5[] = {-1.0, -7.0, 29.0, 2.6}; + + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p0, 1); + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p0, 4); + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p1, 4); + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p2, 3); + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p3, 1); + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p4, 1); + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, p0, p4, 4); + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(2.0, p0, p5, 1); + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(2.0, p0, p5, 2); + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(1.0, NULL, NULL, 1); +#endif +} + void testEqualDoubleEachEqual(void) { #ifdef UNITY_EXCLUDE_DOUBLE diff --git a/test/tests/test_unity_floats.c b/test/tests/test_unity_floats.c index 5a746bb..b86f480 100644 --- a/test/tests/test_unity_floats.c +++ b/test/tests/test_unity_floats.c @@ -1022,6 +1022,31 @@ void testNotEqualFloatArraysLengthZero(void) #endif } +void testFloatArraysWithin(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {1.0f, -8.0f, 25.4f, -0.123f}; + float p1[] = {1.0f, -8.0f, 25.4f, -0.123f}; + float p2[] = {1.0f, -8.0f, 25.4f, -0.2f}; + float p3[] = {1.0f, -23.0f, 25.0f, -0.26f}; + float p4[] = {2.0f, -9.0f, 26.2f, 0.26f}; + float p5[] = {-1.0f, -7.0f, 29.0f, 2.6f}; + + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p0, 1); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p0, 4); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p1, 4); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p2, 3); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p3, 1); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p4, 1); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, p0, p4, 4); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(2.0f, p0, p5, 1); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(2.0f, p0, p5, 2); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1.0f, NULL, NULL, 1); +#endif +} + void testEqualFloatEachEqual(void) { #ifdef UNITY_EXCLUDE_FLOAT From aed2e62142256c33d664b4df3b9fb07f898b91c6 Mon Sep 17 00:00:00 2001 From: AJIOB Date: Mon, 28 Nov 2022 18:30:46 +0300 Subject: [PATCH 3/8] Float-double types typo was fixed --- src/unity.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/unity.c b/src/unity.c index ff331d2..9d5a6cf 100644 --- a/src/unity.c +++ b/src/unity.c @@ -1191,7 +1191,7 @@ void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, { RETURN_IF_FAIL_OR_IGNORE; - if (!UnityDoublesWithin(delta, 0, expected, actual)) + if (!UnityDoublesWithin(delta, (UNITY_DOUBLE)0, expected, actual)) { UnityTestResultsFailBegin(lineNumber); UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual); @@ -1209,7 +1209,7 @@ void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta, { RETURN_IF_FAIL_OR_IGNORE; - if (UnityDoublesWithin(delta, 0, expected, actual)) + if (UnityDoublesWithin(delta, (UNITY_DOUBLE)0, expected, actual)) { UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrExpected); @@ -1238,7 +1238,7 @@ void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold, if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } - if ((compare & UNITY_EQUAL_TO) && UnityDoublesWithin((UNITY_FLOAT)0, threshold * UNITY_DOUBLE_PRECISION, threshold, actual)) { failed = 0; } + if ((compare & UNITY_EQUAL_TO) && UnityDoublesWithin((UNITY_DOUBLE)0, threshold * UNITY_DOUBLE_PRECISION, threshold, actual)) { failed = 0; } if (failed) { From 7d2a92708206cb6f65c35fb6b9ad84b9b5529ac9 Mon Sep 17 00:00:00 2001 From: AJIOB Date: Mon, 28 Nov 2022 18:45:58 +0300 Subject: [PATCH 4/8] Adding lost float & double assert entries when they were previously disabled --- src/unity_internals.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/unity_internals.h b/src/unity_internals.h index 6a86ce9..a7f72be 100644 --- a/src/unity_internals.h +++ b/src/unity_internals.h @@ -1045,6 +1045,7 @@ int UnityTestMatches(void); #define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) #define UNITY_TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) #define UNITY_TEST_ASSERT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) +#define UNITY_TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) #define UNITY_TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) #define UNITY_TEST_ASSERT_EQUAL_FLOAT_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) #define UNITY_TEST_ASSERT_EACH_EQUAL_FLOAT(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat) @@ -1084,7 +1085,9 @@ int UnityTestMatches(void); #ifdef UNITY_EXCLUDE_DOUBLE #define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) #define UNITY_TEST_ASSERT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) +#define UNITY_TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) #define UNITY_TEST_ASSERT_DOUBLE_ARRAY_WITHIN(delta, expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) #define UNITY_TEST_ASSERT_EQUAL_DOUBLE_ARRAY(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) #define UNITY_TEST_ASSERT_EACH_EQUAL_DOUBLE(expected, actual, num_elements, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble) From 0963e20d0b45b4317c05cb2c22bfc5c5f47a44d2 Mon Sep 17 00:00:00 2001 From: AJIOB Date: Mon, 28 Nov 2022 20:09:06 +0300 Subject: [PATCH 5/8] Force moving double delta logic to local function --- src/unity.c | 63 +++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 47 insertions(+), 16 deletions(-) diff --git a/src/unity.c b/src/unity.c index 9d5a6cf..432c297 100644 --- a/src/unity.c +++ b/src/unity.c @@ -894,14 +894,13 @@ void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, /*-----------------------------------------------*/ #ifndef UNITY_EXCLUDE_FLOAT /* Wrap this define in a function with variable types as float or double */ -#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta0, delta1, expected, actual, diff) \ +#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff) \ if (isinf(expected) && isinf(actual) && (((expected) < 0) == ((actual) < 0))) return 1; \ if (UNITY_NAN_CHECK) return 1; \ (diff) = (actual) - (expected); \ if ((diff) < 0) (diff) = -(diff); \ - if ((delta0) < 0) (delta0) = -(delta0); \ - if ((delta1) < 0) (delta1) = -(delta1); \ - return !(isnan(diff) || isinf(diff) || ((diff) > ((delta0) + (delta1)))) + if ((delta) < 0) (delta) = -(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) @@ -923,10 +922,10 @@ void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, #endif /* UNITY_EXCLUDE_FLOAT_PRINT */ /*-----------------------------------------------*/ -static int UnityFloatsWithin(UNITY_FLOAT delta0, UNITY_FLOAT delta1, UNITY_FLOAT expected, UNITY_FLOAT actual) +static int UnityFloatsWithin(UNITY_FLOAT delta, UNITY_FLOAT expected, UNITY_FLOAT actual) { UNITY_FLOAT diff; - UNITY_FLOAT_OR_DOUBLE_WITHIN(delta0, delta1, expected, actual, diff); + UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); } /*-----------------------------------------------*/ @@ -941,6 +940,8 @@ void UnityAssertWithinFloatArray(const UNITY_FLOAT delta, UNITY_UINT32 elements = num_elements; UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_expected = expected; UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_actual = actual; + UNITY_FLOAT in_delta = delta; + UNITY_FLOAT current_element_delta = delta; RETURN_IF_FAIL_OR_IGNORE; @@ -963,9 +964,23 @@ void UnityAssertWithinFloatArray(const UNITY_FLOAT delta, UNITY_FAIL_AND_BAIL; } + /* fix delta sign if need */ + if (in_delta < 0) + { + in_delta = -in_delta; + } + while (elements--) { - if (!UnityFloatsWithin(delta, *ptr_expected * UNITY_FLOAT_PRECISION, *ptr_expected, *ptr_actual)) + current_element_delta = *ptr_expected * UNITY_FLOAT_PRECISION; + + if (current_element_delta < 0) + { + /* fix delta sign for correct calculations */ + current_element_delta = -current_element_delta; + } + + if (!UnityFloatsWithin(in_delta + current_element_delta, *ptr_expected, *ptr_actual)) { UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrElement); @@ -992,7 +1007,7 @@ void UnityAssertFloatsWithin(const UNITY_FLOAT delta, RETURN_IF_FAIL_OR_IGNORE; - if (!UnityFloatsWithin(delta, (UNITY_FLOAT)0, expected, actual)) + if (!UnityFloatsWithin(delta, expected, actual)) { UnityTestResultsFailBegin(lineNumber); UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)expected, (UNITY_DOUBLE)actual); @@ -1010,7 +1025,7 @@ void UnityAssertFloatsNotWithin(const UNITY_FLOAT delta, { RETURN_IF_FAIL_OR_IGNORE; - if (UnityFloatsWithin(delta, (UNITY_FLOAT)0, expected, actual)) + if (UnityFloatsWithin(delta, expected, actual)) { UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrExpected); @@ -1039,7 +1054,7 @@ void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold, if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } - if ((compare & UNITY_EQUAL_TO) && UnityFloatsWithin((UNITY_FLOAT)0, threshold * UNITY_FLOAT_PRECISION, threshold, actual)) { failed = 0; } + if ((compare & UNITY_EQUAL_TO) && UnityFloatsWithin(threshold * UNITY_FLOAT_PRECISION, threshold, actual)) { failed = 0; } if (failed) { @@ -1123,10 +1138,10 @@ void UnityAssertFloatSpecial(const UNITY_FLOAT actual, /*-----------------------------------------------*/ #ifndef UNITY_EXCLUDE_DOUBLE -static int UnityDoublesWithin(UNITY_DOUBLE delta0, UNITY_DOUBLE delta1, UNITY_DOUBLE expected, UNITY_DOUBLE actual) +static int UnityDoublesWithin(UNITY_DOUBLE delta, UNITY_DOUBLE expected, UNITY_DOUBLE actual) { UNITY_DOUBLE diff; - UNITY_FLOAT_OR_DOUBLE_WITHIN(delta0, delta1, expected, actual, diff); + UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff); } /*-----------------------------------------------*/ @@ -1141,6 +1156,8 @@ void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, UNITY_UINT32 elements = num_elements; UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_expected = expected; UNITY_PTR_ATTRIBUTE const UNITY_DOUBLE* ptr_actual = actual; + UNITY_DOUBLE in_delta = delta; + UNITY_DOUBLE current_element_delta = delta; RETURN_IF_FAIL_OR_IGNORE; @@ -1163,9 +1180,23 @@ void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, UNITY_FAIL_AND_BAIL; } + /* fix delta sign if need */ + if (in_delta < 0) + { + in_delta = -in_delta; + } + while (elements--) { - if (!UnityDoublesWithin(delta, *ptr_expected * UNITY_DOUBLE_PRECISION, *ptr_expected, *ptr_actual)) + current_element_delta = *ptr_expected * UNITY_DOUBLE_PRECISION; + + if (current_element_delta < 0) + { + /* fix delta sign for correct calculations */ + current_element_delta = -current_element_delta; + } + + if (!UnityDoublesWithin(in_delta + current_element_delta, *ptr_expected, *ptr_actual)) { UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrElement); @@ -1191,7 +1222,7 @@ void UnityAssertDoublesWithin(const UNITY_DOUBLE delta, { RETURN_IF_FAIL_OR_IGNORE; - if (!UnityDoublesWithin(delta, (UNITY_DOUBLE)0, expected, actual)) + if (!UnityDoublesWithin(delta, expected, actual)) { UnityTestResultsFailBegin(lineNumber); UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT(expected, actual); @@ -1209,7 +1240,7 @@ void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta, { RETURN_IF_FAIL_OR_IGNORE; - if (UnityDoublesWithin(delta, (UNITY_DOUBLE)0, expected, actual)) + if (UnityDoublesWithin(delta, expected, actual)) { UnityTestResultsFailBegin(lineNumber); UnityPrint(UnityStrExpected); @@ -1238,7 +1269,7 @@ void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold, if (!(actual < threshold) && (compare & UNITY_SMALLER_THAN)) { failed = 1; } if (!(actual > threshold) && (compare & UNITY_GREATER_THAN)) { failed = 1; } - if ((compare & UNITY_EQUAL_TO) && UnityDoublesWithin((UNITY_DOUBLE)0, threshold * UNITY_DOUBLE_PRECISION, threshold, actual)) { failed = 0; } + if ((compare & UNITY_EQUAL_TO) && UnityDoublesWithin(threshold * UNITY_DOUBLE_PRECISION, threshold, actual)) { failed = 0; } if (failed) { From b2360fa7ca9a9e2b00bd507ed05ac12fba40a1ef Mon Sep 17 00:00:00 2001 From: AJIOB Date: Mon, 28 Nov 2022 20:23:36 +0300 Subject: [PATCH 6/8] Adding delta infinity & nan checks & tests --- src/unity.c | 22 ++++++++++++++++++++++ test/tests/test_unity_doubles.c | 16 ++++++++++++++++ test/tests/test_unity_floats.c | 16 ++++++++++++++++ 3 files changed, 54 insertions(+) diff --git a/src/unity.c b/src/unity.c index 432c297..be3daaf 100644 --- a/src/unity.c +++ b/src/unity.c @@ -954,6 +954,17 @@ void UnityAssertWithinFloatArray(const UNITY_FLOAT delta, #endif } + if (isinf(in_delta)) + { + return; /* Arrays will be force equal with infinite delta */ + } + + if (isnan(in_delta)) + { + /* Delta must be correct number */ + UnityPrintPointlessAndBail(); + } + if (expected == actual) { return; /* Both are NULL or same pointer */ @@ -1170,6 +1181,17 @@ void UnityAssertWithinDoubleArray(const UNITY_DOUBLE delta, #endif } + if (isinf(in_delta)) + { + return; /* Arrays will be force equal with infinite delta */ + } + + if (isnan(in_delta)) + { + /* Delta must be correct number */ + UnityPrintPointlessAndBail(); + } + if (expected == actual) { return; /* Both are NULL or same pointer */ diff --git a/test/tests/test_unity_doubles.c b/test/tests/test_unity_doubles.c index 174f733..0ad9494 100644 --- a/test/tests/test_unity_doubles.c +++ b/test/tests/test_unity_doubles.c @@ -1049,6 +1049,22 @@ void testDoubleArraysWithin(void) #endif } +void testDoubleArraysWithinUnusualDelta(void) +{ +#ifdef UNITY_EXCLUDE_DOUBLE + TEST_IGNORE(); +#else + double p0[] = {-INFINITY, -8.0, 25.4, -0.123}; + double p1[] = {INFINITY, 10.1}; + + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(INFINITY, p0, p1, 2); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_DOUBLE_ARRAY_WITHIN(NAN, p0, p0, 4); + VERIFY_FAILS_END +#endif +} + void testEqualDoubleEachEqual(void) { #ifdef UNITY_EXCLUDE_DOUBLE diff --git a/test/tests/test_unity_floats.c b/test/tests/test_unity_floats.c index b86f480..9e92f96 100644 --- a/test/tests/test_unity_floats.c +++ b/test/tests/test_unity_floats.c @@ -1047,6 +1047,22 @@ void testFloatArraysWithin(void) #endif } +void testFloatArraysWithinUnusualDelta(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + float p0[] = {(float)-INFINITY, -8.0f, 25.4f, -0.123f}; + float p1[] = {(float)INFINITY, 10.1f}; + + TEST_ASSERT_FLOAT_ARRAY_WITHIN(INFINITY, p0, p1, 2); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_ARRAY_WITHIN(NAN, p0, p0, 4); + VERIFY_FAILS_END +#endif +} + void testEqualFloatEachEqual(void) { #ifdef UNITY_EXCLUDE_FLOAT From a9959df958a4b4c8e2a60da155ef82d7f5f2d2ee Mon Sep 17 00:00:00 2001 From: AJIOB Date: Mon, 28 Nov 2022 20:27:56 +0300 Subject: [PATCH 7/8] Returning lost spaces --- src/unity.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/unity.c b/src/unity.c index be3daaf..3e4bc04 100644 --- a/src/unity.c +++ b/src/unity.c @@ -894,12 +894,12 @@ void UnityAssertEqualIntArray(UNITY_INTERNAL_PTR expected, /*-----------------------------------------------*/ #ifndef UNITY_EXCLUDE_FLOAT /* Wrap this define in a function with variable types as float or double */ -#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff) \ +#define UNITY_FLOAT_OR_DOUBLE_WITHIN(delta, expected, actual, diff) \ if (isinf(expected) && isinf(actual) && (((expected) < 0) == ((actual) < 0))) return 1; \ if (UNITY_NAN_CHECK) return 1; \ (diff) = (actual) - (expected); \ if ((diff) < 0) (diff) = -(diff); \ - if ((delta) < 0) (delta) = -(delta); \ + if ((delta) < 0) (delta) = -(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 From a35af14a273a36387bb6e7f7b81559b5136a1203 Mon Sep 17 00:00:00 2001 From: AJIOB Date: Tue, 29 Nov 2022 09:26:29 +0300 Subject: [PATCH 8/8] Actualizing docs --- docs/UnityAssertionsReference.md | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/docs/UnityAssertionsReference.md b/docs/UnityAssertionsReference.md index ff3b530..86e7843 100644 --- a/docs/UnityAssertionsReference.md +++ b/docs/UnityAssertionsReference.md @@ -572,10 +572,16 @@ code generation conventions for CMock. Asserts that the `actual` value is NOT "close enough to be considered equal" to the `expected` value. +#### `TEST_ASSERT_FLOAT_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +See Array assertion section for details. Note that individual array element +uses user-provided delta plus default comparison delta for checking +and is based on `TEST_ASSERT_FLOAT_WITHIN` comparison. + #### `TEST_ASSERT_EQUAL_FLOAT_ARRAY (expected, actual, num_elements)` See Array assertion section for details. Note that individual array element -float comparisons are executed using `TEST_ASSERT_EQUAL_FLOAT`.That is, user +float comparisons are executed using `TEST_ASSERT_EQUAL_FLOAT`. That is, user specified delta comparison values requires a custom-implemented floating point array assertion. @@ -667,10 +673,16 @@ code generation conventions for CMock. Asserts that the `actual` value is NOT "close enough to be considered equal" to the `expected` value. +#### `TEST_ASSERT_DOUBLE_ARRAY_WITHIN (delta, expected, actual, num_elements)` + +See Array assertion section for details. Note that individual array element +uses user-provided delta plus default comparison delta for checking +and is based on `TEST_ASSERT_DOUBLE_WITHIN` comparison. + #### `TEST_ASSERT_EQUAL_DOUBLE_ARRAY (expected, actual, num_elements)` See Array assertion section for details. Note that individual array element -double comparisons are executed using `TEST_ASSERT_EQUAL_DOUBLE`.That is, user +double comparisons are executed using `TEST_ASSERT_EQUAL_DOUBLE`. That is, user specified delta comparison values requires a custom implemented double array assertion.