From 244edf6c1692515936cdb94c68c865299a896e09 Mon Sep 17 00:00:00 2001
From: Jonathan Reichelt Gjertsen
<jonathan.gjertsen@disruptive-technologies.com>
Date: Fri, 3 Dec 2021 19:29:30 +0100
Subject: [PATCH] Add NOT_EQUAL* and NOT_WITHIN* checks for floats and doubles
---
README.md | 11 +++++++++
docs/UnityAssertionsReference.md | 18 ++++++++++++++
src/unity.c | 42 ++++++++++++++++++++++++++++++++
src/unity.h | 4 +++
src/unity_internals.h | 17 +++++++++++++
test/tests/test_unity_doubles.c | 38 +++++++++++++++++++++++++++++
test/tests/test_unity_floats.c | 38 +++++++++++++++++++++++++++++
7 files changed, 168 insertions(+)
diff --git a/README.md b/README.md
index 0fbdc52..0cd5a43 100644
--- a/README.md
+++ b/README.md
@@ -142,14 +142,25 @@ The bit is specified 0-31 for a 32-bit integer.
### Numerical Assertions: Floats
TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual)
+ TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual)
Asserts that the actual value is within plus or minus delta of the expected value.
+ TEST_ASSERT_FLOAT_NOT_WITHIN(delta, expected, actual)
+ TEST_ASSERT_DOUBLE_NOT_WITHIN(delta, expected, actual)
+
+Asserts that the actual value is NOT within plus or minus delta of the expected value.
+
TEST_ASSERT_EQUAL_FLOAT(expected, actual)
TEST_ASSERT_EQUAL_DOUBLE(expected, actual)
Asserts that two floating point values are "equal" within a small % delta of the expected value.
+ TEST_ASSERT_NOT_EQUAL_FLOAT(expected, actual)
+ TEST_ASSERT_NOT_EQUAL_DOUBLE(expected, actual)
+
+Asserts that two floating point values are NOT "equal" within a small % delta of the expected value.
+
TEST_ASSERT_LESS_THAN_FLOAT(threshold, actual)
TEST_ASSERT_LESS_THAN_DOUBLE(threshold, actual)
TEST_ASSERT_GREATER_THAN_FLOAT(threshold, actual)
diff --git a/docs/UnityAssertionsReference.md b/docs/UnityAssertionsReference.md
index c2acf1f..02d35ab 100644
--- a/docs/UnityAssertionsReference.md
+++ b/docs/UnityAssertionsReference.md
@@ -555,6 +555,10 @@ Asserts that the `actual` value is within +/- `delta` of the `expected` value.
The nature of floating point representation is such that exact evaluations of
equality are not guaranteed.
+#### `TEST_ASSERT_FLOAT_WITHIN (delta, expected, actual)`
+
+Asserts that the `actual` value is NOT within +/- `delta` of the `expected` value.
+
#### `TEST_ASSERT_EQUAL_FLOAT (expected, actual)`
Asserts that the `actual` value is "close enough to be considered equal" to the
@@ -563,6 +567,11 @@ Asserting section for more details on this. Omitting a user-specified delta in a
floating point assertion is both a shorthand convenience and a requirement of
code generation conventions for CMock.
+#### `TEST_ASSERT_NOT_EQUAL_FLOAT (expected, actual)`
+
+Asserts that the `actual` value is NOT "close enough to be considered equal" to the
+`expected` value.
+
#### `TEST_ASSERT_EQUAL_FLOAT_ARRAY (expected, actual, num_elements)`
See Array assertion section for details. Note that individual array element
@@ -631,6 +640,10 @@ Asserts that the `actual` value is within +/- `delta` of the `expected` value.
The nature of floating point representation is such that exact evaluations of
equality are not guaranteed.
+#### `TEST_ASSERT_DOUBLE_NOT_WITHIN (delta, expected, actual)`
+
+Asserts that the `actual` value is NOT within +/- `delta` of the `expected` value.
+
#### `TEST_ASSERT_EQUAL_DOUBLE (expected, actual)`
Asserts that the `actual` value is "close enough to be considered equal" to the
@@ -639,6 +652,11 @@ Asserting section for more details. Omitting a user-specified delta in a
floating point assertion is both a shorthand convenience and a requirement of
code generation conventions for CMock.
+#### `TEST_ASSERT_NOT_EQUAL_DOUBLE (expected, actual)`
+
+Asserts that the `actual` value is NOT "close enough to be considered equal" to the
+`expected` value.
+
#### `TEST_ASSERT_EQUAL_DOUBLE_ARRAY (expected, actual, num_elements)`
See Array assertion section for details. Note that individual array element
diff --git a/src/unity.c b/src/unity.c
index 71f3db5..fab13a0 100644
--- a/src/unity.c
+++ b/src/unity.c
@@ -977,6 +977,27 @@ void UnityAssertFloatsWithin(const UNITY_FLOAT delta,
}
}
+/*-----------------------------------------------*/
+void UnityAssertFloatsNotWithin(const UNITY_FLOAT delta,
+ const UNITY_FLOAT expected,
+ const UNITY_FLOAT actual,
+ const char* msg,
+ const UNITY_LINE_TYPE lineNumber)
+{
+ RETURN_IF_FAIL_OR_IGNORE;
+
+ if (UnityFloatsWithin(delta, expected, actual))
+ {
+ UnityTestResultsFailBegin(lineNumber);
+ UnityPrint(UnityStrExpected);
+ UnityPrintFloat((UNITY_DOUBLE)expected);
+ UnityPrint(UnityStrNotEqual);
+ UnityPrintFloat((UNITY_DOUBLE)actual);
+ UnityAddMsgIfSpecified(msg);
+ UNITY_FAIL_AND_BAIL;
+ }
+}
+
/*-----------------------------------------------*/
void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold,
const UNITY_FLOAT actual,
@@ -1145,6 +1166,27 @@ void UnityAssertDoublesWithin(const UNITY_DOUBLE delta,
}
}
+/*-----------------------------------------------*/
+void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta,
+ const UNITY_DOUBLE expected,
+ const UNITY_DOUBLE actual,
+ const char* msg,
+ const UNITY_LINE_TYPE lineNumber)
+{
+ RETURN_IF_FAIL_OR_IGNORE;
+
+ if (UnityDoublesWithin(delta, expected, actual))
+ {
+ UnityTestResultsFailBegin(lineNumber);
+ UnityPrint(UnityStrExpected);
+ UnityPrintFloat((UNITY_DOUBLE)expected);
+ UnityPrint(UnityStrNotEqual);
+ UnityPrintFloat((UNITY_DOUBLE)actual);
+ UnityAddMsgIfSpecified(msg);
+ UNITY_FAIL_AND_BAIL;
+ }
+}
+
/*-----------------------------------------------*/
void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold,
const UNITY_DOUBLE actual,
diff --git a/src/unity.h b/src/unity.h
index 3e53961..0125624 100644
--- a/src/unity.h
+++ b/src/unity.h
@@ -337,7 +337,9 @@ void verifyTest(void);
/* Floating Point (If Enabled) */
#define TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_FLOAT_WITHIN((delta), (expected), (actual), __LINE__, NULL)
+#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_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)
@@ -353,7 +355,9 @@ void verifyTest(void);
/* Double (If Enabled) */
#define TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual) UNITY_TEST_ASSERT_DOUBLE_WITHIN((delta), (expected), (actual), __LINE__, NULL)
+#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_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)
diff --git a/src/unity_internals.h b/src/unity_internals.h
index 4492119..2450868 100644
--- a/src/unity_internals.h
+++ b/src/unity_internals.h
@@ -648,6 +648,12 @@ void UnityAssertFloatsWithin(const UNITY_FLOAT delta,
const char* msg,
const UNITY_LINE_TYPE lineNumber);
+void UnityAssertFloatsNotWithin(const UNITY_FLOAT delta,
+ const UNITY_FLOAT expected,
+ const UNITY_FLOAT actual,
+ const char* msg,
+ const UNITY_LINE_TYPE lineNumber);
+
void UnityAssertGreaterOrLessFloat(const UNITY_FLOAT threshold,
const UNITY_FLOAT actual,
const UNITY_COMPARISON_T compare,
@@ -674,6 +680,12 @@ void UnityAssertDoublesWithin(const UNITY_DOUBLE delta,
const char* msg,
const UNITY_LINE_TYPE lineNumber);
+void UnityAssertDoublesNotWithin(const UNITY_DOUBLE delta,
+ const UNITY_DOUBLE expected,
+ const UNITY_DOUBLE actual,
+ const char* msg,
+ const UNITY_LINE_TYPE lineNumber);
+
void UnityAssertGreaterOrLessDouble(const UNITY_DOUBLE threshold,
const UNITY_DOUBLE actual,
const UNITY_COMPARISON_T compare,
@@ -1007,6 +1019,7 @@ int UnityTestMatches(void);
#ifdef UNITY_EXCLUDE_FLOAT
#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_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)
@@ -1022,7 +1035,9 @@ int UnityTestMatches(void);
#define UNITY_TEST_ASSERT_FLOAT_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrFloat)
#else
#define UNITY_TEST_ASSERT_FLOAT_WITHIN(delta, expected, actual, line, message) UnityAssertFloatsWithin((UNITY_FLOAT)(delta), (UNITY_FLOAT)(expected), (UNITY_FLOAT)(actual), (message), (UNITY_LINE_TYPE)(line))
+#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_GREATER_THAN_FLOAT(threshold, actual, line, message) UnityAssertGreaterOrLessFloat((UNITY_FLOAT)(threshold), (UNITY_FLOAT)(actual), UNITY_GREATER_THAN, (message), (UNITY_LINE_TYPE)(line))
@@ -1054,7 +1069,9 @@ int UnityTestMatches(void);
#define UNITY_TEST_ASSERT_DOUBLE_IS_NOT_DETERMINATE(actual, line, message) UNITY_TEST_FAIL((UNITY_LINE_TYPE)(line), UnityStrErrDouble)
#else
#define UNITY_TEST_ASSERT_DOUBLE_WITHIN(delta, expected, actual, line, message) UnityAssertDoublesWithin((UNITY_DOUBLE)(delta), (UNITY_DOUBLE)(expected), (UNITY_DOUBLE)(actual), (message), (UNITY_LINE_TYPE)(line))
+#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_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 3202071..b188bac 100644
--- a/test/tests/test_unity_doubles.c
+++ b/test/tests/test_unity_doubles.c
@@ -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,6 +227,8 @@ 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
diff --git a/test/tests/test_unity_floats.c b/test/tests/test_unity_floats.c
index 2f15c1a..4e0ac65 100644
--- a/test/tests/test_unity_floats.c
+++ b/test/tests/test_unity_floats.c
@@ -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,6 +226,8 @@ 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