Add float comparison operators

Author: ianfixes

CHANGELOG.md

@@ -10,10 +10,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Environment variable to run a custom initialization script during CI testing: `CUSTOM_INIT_SCRIPT`
 - Environment variable to run from a subdirectory during CI testing: `USE_SUBDIR`
 - `assertComparativeEqual()` and `assertComparativeNotEqual()` to evaluate equality on an `a - b == 0` basis (and/or `!(a > b) && !(a < b)`)
+- `assertEqualFloat()` and `assertNotEqualFloat()` for comparing floats with epsilon
+- `assertInfinity()` and `assertNotInfinity()` for comparing floats to infinity
+- `assertNAN()` and `assertNotNAN()` for comparing floats to `NaN`
+- `assertion()`, `ReporterTAP.onAssert()`, and `testBehaviorExp` macro to handle simple expression evaluation (is true, is false, etc)
 
 ### Changed
 - Rubocop expected syntax downgraded from ruby 2.6 to 2.5
 - `assertEqual()` and `assertNotEqual()` use actual `==` and `!=` -- they no longer require a type to be totally ordered just to do equality tests
+- Evaluative assertions (is true/false/null/etc) now produce simpler error messages instead of masquerading as an operation (e.g. "== true")
 
 ### Deprecated
 

REFERENCE.md

@@ -220,6 +220,14 @@ assertMoreOrEqual(lowerBound, actual);       // a >= b
 assertTrue(actual);
 assertFalse(actual);
 assertNull(actual);
+
+// special cases for floats
+assertEqualFloat(expected, actual, epsilon);    // fabs(a - b) <= epsilon
+assertNotEqualFloat(unwanted, actual, epsilon); // fabs(a - b) >= epsilon
+assertInfinity(actual);                         // isinf(a)
+assertNotInfinity(actual);                      // !isinf(a)
+assertNAN(arg);                                 // isnan(a)
+assertNotNAN(arg);                              // !isnan(a)
 ```
 
 These functions will report the result of the test to the console, and the testing will continue if they fail.

SampleProjects/DoSomething/test/bad-errormessages.cpp

@@ -7,7 +7,7 @@
 
 unittest(check_that_assertion_error_messages_are_comprehensible)
 {
-  assertEqual(1 ,2);
+  assertEqual(1, 2);
   assertNotEqual(2, 2);
   assertComparativeEqual(1, 2);
   assertComparativeNotEqual(2, 2);
@@ -19,6 +19,13 @@ unittest(check_that_assertion_error_messages_are_comprehensible)
   assertFalse(true);
   assertNull(3);
   assertNotNull(NULL);
+
+  assertEqualFloat(1.2, 1.0, 0.01);
+  assertNotEqualFloat(1.0, 1.02, 0.1);
+  assertInfinity(42);
+  assertNotInfinity(INFINITY);
+  assertNAN(42);
+  assertNotNAN(0.0/0.0);
 }
 
 unittest_main()

SampleProjects/DoSomething/test/good-assert.cpp

@@ -32,4 +32,15 @@ unittest(assert_equal_without_total_ordering)
 
 }
 
+unittest(float_assertions)
+{
+  assertInfinity(exp(800));
+  assertInfinity(0.0/0.0);
+  assertNotInfinity(42);
+
+  assertNAN(INFINITY - INFINITY);
+  assertNAN(0.0/0.0);
+  assertNotNAN(42);
+}
+
 unittest_main()

cpp/unittest/ArduinoUnitTests.h

@@ -69,6 +69,23 @@ class Test
           }
         }
 
+        // non-comparative assert
+        void onAssert(
+          const char* file,
+          int line,
+          const char* description,
+          bool pass
+        ) {
+          cerr << "    " << (pass ? "" : "not ") << "ok " << ++mAssertCounter << " - " << description << endl;
+          if (!pass) {
+            cerr << "      ---" << endl;
+            cerr << "      at:" << endl;
+            cerr << "        file: " << file << endl;
+            cerr << "        line: " << line << endl;
+            cerr << "      ..." << endl;
+          }
+        }
+
         template <typename A, typename B> void onAssert(
           const char* file,
           int line,
@@ -194,6 +211,21 @@ class Test
       excise();
     }
 
+    bool assertion(
+        const char *file,
+        int line,
+        const char *description,
+        bool ok)
+    {
+      if (mReporter) {
+        mReporter->onAssert(file, line, description, ok);
+      }
+
+      if (!ok)
+        fail();
+      return ok;
+    }
+
     template <typename A, typename B>
     bool assertion(
         const char *file,

cpp/unittest/Assertion.h

@@ -6,9 +6,19 @@
 
 #include "Compare.h"
 
+#define testBehaviorExp(die, desc, pass) \
+  do                                     \
+  {                                      \
+    if (!assertion(__FILE__, __LINE__,   \
+                   desc, pass))          \
+    {                                    \
+      if (die) return;                   \
+    }                                    \
+  } while (0)
+
 #define testBehaviorOp(die, desc, rel1, arg1, op, op_name, rel2, arg2) \
   do                                                                   \
-    {                                                                  \
+  {                                                                    \
     if (!assertion<typeof(arg1), typeof(arg2)>(__FILE__, __LINE__,     \
                                                desc,                   \
                                                rel1, #arg1, (arg1),    \
@@ -30,29 +40,44 @@
 
 
 /** macro generates optional output and calls fail() but does not return if false. */
+#define assertTrue(arg)                      testBehaviorExp(false, "assertTrue " #arg, (arg))
+#define assertFalse(arg)                     testBehaviorExp(false, "assertFalse " #arg, !(arg))
+#define assertNull(arg)                      testBehaviorExp(false, "assertNull " #arg, ((void*)NULL == (void*)(arg)))
+#define assertNotNull(arg)                   testBehaviorExp(false, "assertNotNull " #arg, ((void*)NULL != (void*)(arg)))
 #define assertEqual(arg1,arg2)               assertOp("assertEqual","expected",arg1,evaluateDoubleEqual,"==","actual",arg2)
 #define assertNotEqual(arg1,arg2)            assertOp("assertNotEqual","unwanted",arg1,evaluateNotEqual,"!=","actual",arg2)
 #define assertComparativeEqual(arg1,arg2)    assertOp("assertEqual","expected",arg1,compareEqual,"!<>","actual",arg2)
 #define assertComparativeNotEqual(arg1,arg2) assertOp("assertEqual","unwanted",arg1,compareNotEqual,"<>","actual",arg2)
-#define assertLess(arg1,arg2)                assertOp("assertLess","lowerBound",arg1,compareLess,"<","upperBound",arg2)
-#define assertMore(arg1,arg2)                assertOp("assertMore","upperBound",arg1,compareMore,">","lowerBound",arg2)
-#define assertLessOrEqual(arg1,arg2)         assertOp("assertLessOrEqual","lowerBound",arg1,compareLessOrEqual,"<=","upperBound",arg2)
-#define assertMoreOrEqual(arg1,arg2)         assertOp("assertMoreOrEqual","upperBound",arg1,compareMoreOrEqual,">=","lowerBound",arg2)
-#define assertTrue(arg) assertEqual(true, arg)
-#define assertFalse(arg) assertEqual(false, arg)
-#define assertNull(arg) assertEqual((void*)NULL, (void*)arg)
-#define assertNotNull(arg) assertNotEqual((void*)NULL, (void*)arg)
+#define assertLess(arg1,arg2)                assertOp("assertLess","lowerBound",arg1,compareLess,"<","actual",arg2)
+#define assertMore(arg1,arg2)                assertOp("assertMore","upperBound",arg1,compareMore,">","actual",arg2)
+#define assertLessOrEqual(arg1,arg2)         assertOp("assertLessOrEqual","lowerBound",arg1,compareLessOrEqual,"<=","actual",arg2)
+#define assertMoreOrEqual(arg1,arg2)         assertOp("assertMoreOrEqual","upperBound",arg1,compareMoreOrEqual,">=","actual",arg2)
+
+#define assertEqualFloat(arg1, arg2, arg3)    assertOp("assertEqualFloat", "epsilon", arg3, compareMoreOrEqual, ">=", "actualDifference", fabs(arg1 - arg2))
+#define assertNotEqualFloat(arg1, arg2, arg3) assertOp("assertNotEqualFloat", "epsilon", arg3, compareLessOrEqual, "<=", "insufficientDifference", fabs(arg1 - arg2))
+#define assertInfinity(arg)                   testBehaviorExp(false, "assertInfinity " #arg, isinf(arg))
+#define assertNotInfinity(arg)                testBehaviorExp(false, "assertNotInfinity " #arg, !isinf(arg))
+#define assertNAN(arg)                        testBehaviorExp(false, "assertNAN " #arg, isnan(arg))
+#define assertNotNAN(arg)                     testBehaviorExp(false, "assertNotNAN " #arg, !isnan(arg))
+
 
 /** macro generates optional output and calls fail() followed by a return if false. */
+#define assureTrue(arg)                      testBehaviorExp(true, "assertTrue " #arg, (arg))
+#define assureFalse(arg)                     testBehaviorExp(true, "assertFalse " #arg, !(arg))
+#define assureNull(arg)                      testBehaviorExp(true, "assertNull " #arg, ((void*)NULL == (void*)(arg)))
+#define assureNotNull(arg)                   testBehaviorExp(true, "assertNotNull " #arg, ((void*)NULL != (void*)(arg)))
 #define assureEqual(arg1,arg2)               assureOp("assureEqual","expected",arg1,evaluateDoubleEqual,"==","actual",arg2)
 #define assureNotEqual(arg1,arg2)            assureOp("assureNotEqual","unwanted",arg1,evaluateNotEqual,"!=","actual",arg2)
 #define assureComparativeEqual(arg1,arg2)    assertOp("assureEqual","expected",arg1,compareEqual,"!<>","actual",arg2)
 #define assureComparativeNotEqual(arg1,arg2) assertOp("assertEqual","unwanted",arg1,compareNotEqual,"<>","actual",arg2)
-#define assureLess(arg1,arg2)                assureOp("assureLess","lowerBound",arg1,compareLess,"<","upperBound",arg2)
-#define assureMore(arg1,arg2)                assureOp("assureMore","upperBound",arg1,compareMore,">","lowerBound",arg2)
-#define assureLessOrEqual(arg1,arg2)         assureOp("assureLessOrEqual","lowerBound",arg1,compareLessOrEqual,"<=","upperBound",arg2)
-#define assureMoreOrEqual(arg1,arg2)         assureOp("assureMoreOrEqual","upperBound",arg1,compareMoreOrEqual,">=","lowerBound",arg2)
-#define assureTrue(arg) assureEqual(true, arg)
-#define assureFalse(arg) assureEqual(false, arg)
-#define assureNull(arg) assureEqual((void*)NULL, (void*)arg)
-#define assureNotNull(arg) assureNotEqual((void*)NULL, (void*)arg)
+#define assureLess(arg1,arg2)                assureOp("assureLess","lowerBound",arg1,compareLess,"<","actual",arg2)
+#define assureMore(arg1,arg2)                assureOp("assureMore","upperBound",arg1,compareMore,">","actual",arg2)
+#define assureLessOrEqual(arg1,arg2)         assureOp("assureLessOrEqual","lowerBound",arg1,compareLessOrEqual,"<=","actual",arg2)
+#define assureMoreOrEqual(arg1,arg2)         assureOp("assureMoreOrEqual","upperBound",arg1,compareMoreOrEqual,">=","actual",arg2)
+
+#define assureEqualFloat(arg1, arg2, arg3)    assureOp("assureEqualFloat", "epsilon", arg3, compareMoreOrEqual, ">=", "actualDifference", fabs(arg1 - arg2))
+#define assureNotEqualFloat(arg1, arg2, arg3) assureOp("assureNotEqualFloat", "epsilon", arg3, compareLessOrEqual, "<=", "insufficientDifference", fabs(arg1 - arg2))
+#define assureInfinity(arg)                   testBehaviorExp(true, "assertInfinity " #arg, isinf(arg))
+#define assureNotInfinity(arg)                testBehaviorExp(true, "assertNotInfinity " #arg, !isinf(arg))
+#define assureNAN(arg)                        testBehaviorExp(true, "assertNAN " #arg, isnan(arg))
+#define assureNotNAN(arg)                     testBehaviorExp(true, "assertNotNAN " #arg, !isnan(arg))