espressif/Unity
1
0
Fork 0
mirror of https://github.com/ThrowTheSwitch/Unity.git synced 2025-08-06 05:32:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #560 from jonathangjertsen/more-float

Browse Source 
Add macros for testing inequalities between floats, doubles
This commit is contained in:
Mark VanderVoord
2022-05-25 11:04:56 -04:00
committed by GitHub
parent 465b659c81 b732fbf1ca
commit e54c9787b7
7 changed files with 1206 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

470
test/tests/test_unity_doubles.c
View File

@ -42,6 +42,10 @@ void testDoublesWithinDelta(void)
TEST_ASSERT_DOUBLE_WITHIN(1.0, 187245.0, 187246.0);
TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2549, 9273.2049);
TEST_ASSERT_DOUBLE_WITHIN(0.007, -726.93725, -726.94424);
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_NOT_WITHIN(0.05, 9273.2549, 9273.2049);
VERIFY_FAILS_END
#endif
}
@ -50,6 +54,8 @@ void testDoublesNotWithinDelta(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_DOUBLE_NOT_WITHIN(0.05, 9273.2649, 9273.2049);
EXPECT_ABORT_BEGIN
TEST_ASSERT_DOUBLE_WITHIN(0.05, 9273.2649, 9273.2049);
VERIFY_FAILS_END
@ -66,6 +72,10 @@ void testDoublesEqual(void)
TEST_ASSERT_EQUAL_DOUBLE(187241234567.5, 187241234567.6);
TEST_ASSERT_EQUAL_DOUBLE(9273.2512345649, 9273.25123455699);
TEST_ASSERT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374);
EXPECT_ABORT_BEGIN
TEST_ASSERT_NOT_EQUAL_DOUBLE(-726.12345693724, -726.1234569374);
VERIFY_FAILS_END
#endif
}
@ -74,6 +84,8 @@ void testDoublesNotEqual(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_NOT_EQUAL_DOUBLE(9273.9649, 9273.0049);
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(9273.9649, 9273.0049);
VERIFY_FAILS_END
@ -85,6 +97,8 @@ void testDoublesNotEqualNegative1(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_NOT_EQUAL_DOUBLE(-9273.9649, -9273.0049);
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(-9273.9649, -9273.0049);
VERIFY_FAILS_END
@ -96,6 +110,8 @@ void testDoublesNotEqualNegative2(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_NOT_EQUAL_DOUBLE(-9273.0049, -9273.9649);
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(-9273.0049, -9273.9649);
VERIFY_FAILS_END
@ -107,6 +123,8 @@ void testDoublesNotEqualActualNaN(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_NOT_EQUAL_DOUBLE(85.963, 0.0 / d_zero);
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(85.963, 0.0 / d_zero);
VERIFY_FAILS_END
@ -118,6 +136,8 @@ void testDoublesNotEqualExpectedNaN(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_NOT_EQUAL_DOUBLE(0.0 / d_zero, 85.963);
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 85.963);
VERIFY_FAILS_END
@ -130,6 +150,10 @@ void testDoublesEqualBothNaN(void)
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
EXPECT_ABORT_BEGIN
TEST_ASSERT_NOT_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
@ -138,6 +162,8 @@ void testDoublesNotEqualInfNaN(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero);
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 0.0 / d_zero);
VERIFY_FAILS_END
@ -149,6 +175,8 @@ void testDoublesNotEqualNaNInf(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_NOT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero);
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(0.0 / d_zero, 1.0 / d_zero);
VERIFY_FAILS_END
@ -160,6 +188,8 @@ void testDoublesNotEqualActualInf(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_NOT_EQUAL_DOUBLE(321.642, 1.0 / d_zero);
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(321.642, 1.0 / d_zero);
VERIFY_FAILS_END
@ -171,6 +201,8 @@ void testDoublesNotEqualExpectedInf(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, 321.642);
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 321.642);
VERIFY_FAILS_END
@ -183,6 +215,10 @@ void testDoublesEqualBothInf(void)
TEST_IGNORE();
#else
TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
EXPECT_ABORT_BEGIN
TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
@ -191,12 +227,446 @@ void testDoublesNotEqualPlusMinusInf(void)
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_NOT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
EXPECT_ABORT_BEGIN
TEST_ASSERT_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesGreaterThan(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, 2.0);
TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0, 1.0);
TEST_ASSERT_GREATER_THAN_DOUBLE(-2.0, -1.0);
#endif
}
void testDoublesGreaterThanInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, 1.0 / d_zero);
TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0 / d_zero, 1.0 / d_zero);
TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0 / d_zero, 1.0);
#endif
}
void testDoublesNotGreaterThan(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_THAN_DOUBLE(2.0, 1.0);
VERIFY_FAILS_END
#endif
}
void testDoublesNotGreaterThanNanActual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, 0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotGreaterThanNanThreshold(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_THAN_DOUBLE(0.0 / d_zero, 1.0);
VERIFY_FAILS_END
#endif
}
void testDoublesNotGreaterThanNanBoth(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_THAN_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotGreaterThanInfActual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_THAN_DOUBLE(1.0 / d_zero, 1.0);
VERIFY_FAILS_END
#endif
}
void testDoublesNotGreaterThanNegInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_THAN_DOUBLE(1.0, -1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotGreaterThanBothInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_THAN_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotGreaterThanBothNegInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_THAN_DOUBLE(-1.0 / d_zero, -1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesGreaterOrEqual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, 2.0);
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(2.0, 2.0);
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0, 1.0);
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-2.0, -1.0);
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-2.0, -2.0);
#endif
}
void testDoublesGreaterOrEqualInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, 1.0 / d_zero);
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0 / d_zero, 1.0 / d_zero);
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0 / d_zero, 1.0);
#endif
}
void testDoublesNotGreaterOrEqual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(2.0, 1.0);
VERIFY_FAILS_END
#endif
}
void testDoublesNotGreaterOrEqualNanActual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, 0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotGreaterOrEqualNanThreshold(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(0.0 / d_zero, 1.0);
VERIFY_FAILS_END
#endif
}
void testDoublesGreaterOrEqualNanBoth(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
#endif
}
void testDoublesNotGreaterOrEqualInfActual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0);
VERIFY_FAILS_END
#endif
}
void testDoublesNotGreaterOrEqualNegInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0, -1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesGreaterOrEqualBothInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
#endif
}
void testDoublesGreaterOrEqualBothNegInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_GREATER_OR_EQUAL_DOUBLE(-1.0 / d_zero, -1.0 / d_zero);
#endif
}
void testDoublesLessThan(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_LESS_THAN_DOUBLE(2.0, 1.0);
TEST_ASSERT_LESS_THAN_DOUBLE(1.0, -1.0);
TEST_ASSERT_LESS_THAN_DOUBLE(-1.0, -2.0);
#endif
}
void testDoublesLessThanInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_LESS_THAN_DOUBLE(1.0 / d_zero, 1.0);
TEST_ASSERT_LESS_THAN_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
TEST_ASSERT_LESS_THAN_DOUBLE(1.0, -1.0 / d_zero);
#endif
}
void testDoublesNotLessThan(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_THAN_DOUBLE(1.0, 2.0);
VERIFY_FAILS_END
#endif
}
void testDoublesNotLessThanNanActual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_THAN_DOUBLE(1.0, 0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotLessThanNanThreshold(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_THAN_DOUBLE(0.0 / d_zero, 1.0);
VERIFY_FAILS_END
#endif
}
void testDoublesNotLessThanNanBoth(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_THAN_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotLessThanInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_THAN_DOUBLE(1.0, 1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotLessThanNegInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_THAN_DOUBLE(-1.0 / d_zero, 1.0);
VERIFY_FAILS_END
#endif
}
void testDoublesNotLessThanBothInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_THAN_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotLessThanBothNegInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_THAN_DOUBLE(-1.0 / d_zero, -1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesLessOrEqual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(2.0, 1.0);
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(2.0, 2.0);
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, -1.0);
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-1.0, -2.0);
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-2.0, -2.0);
#endif
}
void testDoublesLessOrEqualInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0);
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0 / d_zero, -1.0 / d_zero);
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, -1.0 / d_zero);
#endif
}
void testDoublesNotLessOrEqual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, 2.0);
VERIFY_FAILS_END
#endif
}
void testDoublesNotLessOrEqualNanActual(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, 0.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotLessOrEqualNanThreshold(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(0.0 / d_zero, 1.0);
VERIFY_FAILS_END
#endif
}
void testDoublesLessOrEqualNanBoth(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(0.0 / d_zero, 0.0 / d_zero);
#endif
}
void testDoublesNotLessOrEqualInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0, 1.0 / d_zero);
VERIFY_FAILS_END
#endif
}
void testDoublesNotLessOrEqualNegInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
EXPECT_ABORT_BEGIN
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-1.0 / d_zero, 1.0);
VERIFY_FAILS_END
#endif
}
void testDoublesLessOrEqualBothInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(1.0 / d_zero, 1.0 / d_zero);
#endif
}
void testDoublesLessOrEqualBothNegInf(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE
TEST_IGNORE();
#else
TEST_ASSERT_LESS_OR_EQUAL_DOUBLE(-1.0 / d_zero, -1.0 / d_zero);
#endif
}
void testDoubleIsPosInf1(void)
{
#ifdef UNITY_EXCLUDE_DOUBLE

469
test/tests/test_unity_floats.c
View File

@ -42,6 +42,10 @@ void testFloatsWithinDelta(void)
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
}
@ -50,6 +54,8 @@ 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
@ -65,6 +71,10 @@ void testFloatsEqual(void)
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
}
@ -73,6 +83,8 @@ 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
@ -84,6 +96,8 @@ 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
@ -95,6 +109,8 @@ 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
@ -106,6 +122,8 @@ 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
@ -117,6 +135,8 @@ 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
@ -129,6 +149,10 @@ void testFloatsEqualBothNaN(void)
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
}
@ -137,6 +161,8 @@ 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
@ -148,6 +174,8 @@ 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
@ -159,6 +187,8 @@ 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
@ -170,6 +200,8 @@ 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
@ -182,6 +214,10 @@ void testFloatsEqualBothInf(void)
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
}
@ -190,12 +226,445 @@ 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