vendor/cmock/vendor/unity/test/tests/test_unity_floats.c in ceedling-0.31.1 vs vendor/cmock/vendor/unity/test/tests/test_unity_floats.c in ceedling-1.0.0

- old
+ new

@@ -1,10 +1,11 @@ -/* ========================================== - Unity Project - A Test Framework for C - Copyright (c) 2007 Mike Karlesky, Mark VanderVoord, Greg Williams - [Released under MIT License. Please refer to license.txt for details] -========================================== */ +/* ========================================================================= + Unity - A Test Framework for C + ThrowTheSwitch.org + Copyright (c) 2007-25 Mike Karlesky, Mark VanderVoord, & Greg Williams + SPDX-License-Identifier: MIT +========================================================================= */ #include "unity.h" #define TEST_INSTANCES #include "self_assessment_utils.h" @@ -40,18 +41,24 @@ #else TEST_ASSERT_FLOAT_WITHIN(0.00003f, 187245.03485f, 187245.03488f); TEST_ASSERT_FLOAT_WITHIN(1.0f, 187245.0f, 187246.0f); TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2549f, 9273.2049f); TEST_ASSERT_FLOAT_WITHIN(0.007f, -726.93724f, -726.94424f); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_FLOAT_NOT_WITHIN(0.05f, 9273.2549f, 9273.2049f); + VERIFY_FAILS_END #endif } void testFloatsNotWithinDelta(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_FLOAT_NOT_WITHIN(0.05f, 9273.2649f, 9273.2049f); + EXPECT_ABORT_BEGIN TEST_ASSERT_FLOAT_WITHIN(0.05f, 9273.2649f, 9273.2049f); VERIFY_FAILS_END #endif } @@ -63,18 +70,24 @@ #else TEST_ASSERT_EQUAL_FLOAT(187245.0f, 187246.0f); TEST_ASSERT_EQUAL_FLOAT(18724.5f, 18724.6f); TEST_ASSERT_EQUAL_FLOAT(9273.2549f, 9273.2599f); TEST_ASSERT_EQUAL_FLOAT(-726.93724f, -726.9374f); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_FLOAT(-726.93724f, -726.9374f); + VERIFY_FAILS_END #endif } void testFloatsNotEqual(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_NOT_EQUAL_FLOAT(9273.9649f, 9273.0049f); + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT(9273.9649f, 9273.0049f); VERIFY_FAILS_END #endif } @@ -82,10 +95,12 @@ void testFloatsNotEqualNegative1(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_NOT_EQUAL_FLOAT(-9273.9649f, -9273.0049f); + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT(-9273.9649f, -9273.0049f); VERIFY_FAILS_END #endif } @@ -93,10 +108,12 @@ void testFloatsNotEqualNegative2(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_NOT_EQUAL_FLOAT(-9273.0049f, -9273.9649f); + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT(-9273.0049f, -9273.9649f); VERIFY_FAILS_END #endif } @@ -104,10 +121,12 @@ void testFloatsNotEqualActualNaN(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_NOT_EQUAL_FLOAT(85.963f, 0.0f / f_zero); + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT(85.963f, 0.0f / f_zero); VERIFY_FAILS_END #endif } @@ -115,10 +134,12 @@ void testFloatsNotEqualExpectedNaN(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_NOT_EQUAL_FLOAT(0.0f / f_zero, 85.963f); + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 85.963f); VERIFY_FAILS_END #endif } @@ -127,18 +148,24 @@ { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); + VERIFY_FAILS_END #endif } void testFloatsNotEqualInfNaN(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero); + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 0.0f / f_zero); VERIFY_FAILS_END #endif } @@ -146,10 +173,12 @@ void testFloatsNotEqualNaNInf(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_NOT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero); + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT(0.0f / f_zero, 1.0f / f_zero); VERIFY_FAILS_END #endif } @@ -157,10 +186,12 @@ void testFloatsNotEqualActualInf(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_NOT_EQUAL_FLOAT(321.642f, 1.0f / f_zero); + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT(321.642f, 1.0f / f_zero); VERIFY_FAILS_END #endif } @@ -168,10 +199,12 @@ void testFloatsNotEqualExpectedInf(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, 321.642f); + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 321.642f); VERIFY_FAILS_END #endif } @@ -180,24 +213,461 @@ { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); + + EXPECT_ABORT_BEGIN + TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); + VERIFY_FAILS_END #endif } void testFloatsNotEqualPlusMinusInf(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else + TEST_ASSERT_NOT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero); + EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero); VERIFY_FAILS_END #endif } +void testFloatsGreaterThan(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, 2.0f); + TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f, 1.0f); + TEST_ASSERT_GREATER_THAN_FLOAT(-2.0f, -1.0f); +#endif +} + +void testFloatsGreaterThanInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, 1.0f / f_zero); + TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f / f_zero, 1.0f / f_zero); + TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f / f_zero, 1.0f); +#endif +} + +void testFloatsNotGreaterThan(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_FLOAT(2.0f, 1.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotGreaterThanNanActual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, 0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotGreaterThanNanThreshold(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_FLOAT(0.0f / f_zero, 1.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotGreaterThanNanBoth(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_FLOAT(0.0f / f_zero, 0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotGreaterThanInfActual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_FLOAT(1.0f / f_zero, 1.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotGreaterThanNegInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_FLOAT(1.0f, -1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotGreaterThanBothInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_FLOAT(1.0f / f_zero, 1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotGreaterThanBothNegInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_THAN_FLOAT(-1.0f / f_zero, -1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsGreaterOrEqual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, 2.0f); + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(2.0f, 2.0f); + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f, 1.0f); + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-2.0f, -1.0f); + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-2.0f, -2.0f); +#endif +} + +void testFloatsGreaterOrEqualInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, 1.0f / f_zero); + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f / f_zero, 1.0f / f_zero); + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f / f_zero, 1.0f); +#endif +} + +void testFloatsNotGreaterOrEqual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(2.0f, 1.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotGreaterOrEqualNanActual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, 0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotGreaterOrEqualNanThreshold(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(0.0f / f_zero, 1.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsGreaterOrEqualNanBoth(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); +#endif +} + +void testFloatsNotGreaterOrEqualInfActual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotGreaterOrEqualNegInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f, -1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsGreaterOrEqualBothInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); +#endif +} + +void testFloatsGreaterOrEqualBothNegInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_GREATER_OR_EQUAL_FLOAT(-1.0f / f_zero, -1.0f / f_zero); +#endif +} + +void testFloatsLessThan(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_LESS_THAN_FLOAT(2.0f, 1.0f); + TEST_ASSERT_LESS_THAN_FLOAT(1.0f, -1.0f); + TEST_ASSERT_LESS_THAN_FLOAT(-1.0f, -2.0f); +#endif +} + +void testFloatsLessThanInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_LESS_THAN_FLOAT(1.0f / f_zero, 1.0f); + TEST_ASSERT_LESS_THAN_FLOAT(1.0f / f_zero, -1.0f / f_zero); + TEST_ASSERT_LESS_THAN_FLOAT(1.0f, -1.0f / f_zero); +#endif +} + +void testFloatsNotLessThan(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_FLOAT(1.0f, 2.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotLessThanNanActual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_FLOAT(1.0f, 0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotLessThanNanThreshold(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_FLOAT(0.0f / f_zero, 1.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotLessThanNanBoth(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_FLOAT(0.0f / f_zero, 0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotLessThanInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_FLOAT(1.0f, 1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotLessThanNegInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_FLOAT(-1.0f / f_zero, 1.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotLessThanBothInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_FLOAT(1.0f / f_zero, 1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotLessThanBothNegInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_THAN_FLOAT(-1.0f / f_zero, -1.0f / f_zero); + VERIFY_FAILS_END +#endif +} +void testFloatsLessOrEqual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(2.0f, 1.0f); + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(2.0f, 2.0f); + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, -1.0f); + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-1.0f, -2.0f); + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-2.0f, -2.0f); +#endif +} + +void testFloatsLessOrEqualInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f); + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f / f_zero, -1.0f / f_zero); + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, -1.0f / f_zero); +#endif +} + +void testFloatsNotLessOrEqual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, 2.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotLessOrEqualNanActual(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, 0.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotLessOrEqualNanThreshold(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(0.0f / f_zero, 1.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsLessOrEqualNanBoth(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(0.0f / f_zero, 0.0f / f_zero); +#endif +} + +void testFloatsNotLessOrEqualInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f, 1.0f / f_zero); + VERIFY_FAILS_END +#endif +} + +void testFloatsNotLessOrEqualNegInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + EXPECT_ABORT_BEGIN + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-1.0f / f_zero, 1.0f); + VERIFY_FAILS_END +#endif +} + +void testFloatsLessOrEqualBothInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(1.0f / f_zero, 1.0f / f_zero); +#endif +} + +void testFloatsLessOrEqualBothNegInf(void) +{ +#ifdef UNITY_EXCLUDE_FLOAT + TEST_IGNORE(); +#else + TEST_ASSERT_LESS_OR_EQUAL_FLOAT(-1.0f / f_zero, -1.0f / f_zero); +#endif +} + void testFloatIsPosInf1(void) { #ifdef UNITY_EXCLUDE_FLOAT TEST_IGNORE(); #else @@ -547,9 +1017,50 @@ float p0[1] = {0.0f}; float p1[1] = {0.0f}; EXPECT_ABORT_BEGIN TEST_ASSERT_EQUAL_FLOAT_ARRAY(p0, p1, 0); + VERIFY_FAILS_END +#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 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)