remove requirement that types be totally ordered in order to evaluate equality on them

Author: ianfixes

CHANGELOG.md

@@ -9,9 +9,11 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Added
 - Environment variable to run a custom initiialization 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)`)
 
 ### 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
 
 ### Deprecated
 

REFERENCE.md

@@ -208,15 +208,19 @@ This test defines one `unittest` (a macro provided by `ArduinoUnitTests.h`), cal
 
 The following assertion functions are available in unit tests.
 
-* `assertEqual(expected, actual)`
-* `assertNotEqual(expected, actual)`
-* `assertLess(expected, actual)`
-* `assertMore(expected, actual)`
-* `assertLessOrEqual(expected, actual)`
-* `assertMoreOrEqual(expected, actual)`
-* `assertTrue(actual)`
-* `assertFalse(actual)`
-* `assertNull(actual)`
+```c++
+assertEqual(expected, actual);               // a == b
+assertNotEqual(unwanted, actual);            // a != b
+assertComparativeEqual(expected, actual);    // abs(a - b) == 0 or (!(a > b) && !(a < b))
+assertComparativeNotEqual(unwanted, actual); // abs(a - b) > 0  or ((a > b) || (a < b))
+assertLess(upperBound, actual);              // a < b
+assertMore(lowerBound, actual);              // a > b
+assertLessOrEqual(upperBound, actual);       // a <= b
+assertMoreOrEqual(lowerBound, actual);       // a >= b
+assertTrue(actual);
+assertFalse(actual);
+assertNull(actual);
+```
 
 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

@@ -0,0 +1,24 @@
+#include <ArduinoUnitTests.h>
+
+
+#pragma once
+
+
+
+unittest(check_that_assertion_error_messages_are_comprehensible)
+{
+  assertEqual(1 ,2);
+  assertNotEqual(2, 2);
+  assertComparativeEqual(1, 2);
+  assertComparativeNotEqual(2, 2);
+  assertLess(2, 1);
+  assertMore(1, 2);
+  assertLessOrEqual(2, 1);
+  assertMoreOrEqual(1, 2);
+  assertTrue(false);
+  assertFalse(true);
+  assertNull(3);
+  assertNotNull(NULL);
+}
+
+unittest_main()

SampleProjects/DoSomething/test/good-assert.cpp

@@ -0,0 +1,35 @@
+#include <ArduinoUnitTests.h>
+#include "../do-something.h"
+
+class NonOrderedType {
+  public:
+    int x; // ehh why not
+    NonOrderedType(int some_x) : x(some_x) {}
+
+    bool operator==(const NonOrderedType &that) const {
+      return that.x == x;
+    }
+
+    bool operator!=(const NonOrderedType &that) const {
+      return that.x != x;
+    }
+};
+inline std::ostream& operator << ( std::ostream& out, const NonOrderedType& n ) {
+  out << "NonOrderedType(" << n.x << ")";
+  return out;
+}
+
+
+unittest(assert_equal_without_total_ordering)
+{
+  NonOrderedType a(3);
+  NonOrderedType b(3);
+  NonOrderedType c(4);
+
+  assertEqual(a, b);
+  assertEqual(a, a);
+  assertNotEqual(a, c);
+
+}
+
+unittest_main()

cpp/unittest/Assertion.h

@@ -30,26 +30,29 @@
 
 
 /** macro generates optional output and calls fail() but does not return if false. */
-#define assertEqual(arg1,arg2)       assertOp("assertEqual","expected",arg1,compareEqual,"==","actual",arg2)
-#define assertNotEqual(arg1,arg2)    assertOp("assertNotEqual","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 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)
 
 /** macro generates optional output and calls fail() followed by a return if false. */
-#define assureEqual(arg1,arg2)       assureOp("assureEqual","expected",arg1,compareEqual,"==","actual",arg2)
-#define assureNotEqual(arg1,arg2)    assureOp("assureNotEqual","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 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)
-

cpp/unittest/Compare.h

@@ -110,3 +110,6 @@ template <typename A, typename B> bool compareLess(       const A &a, const B &b
 template <typename A, typename B> bool compareMore(       const A &a, const B &b) { return Compare<A, B>::more(       a, b); }
 template <typename A, typename B> bool compareLessOrEqual(const A &a, const B &b) { return Compare<A, B>::lessOrEqual(a, b); }
 template <typename A, typename B> bool compareMoreOrEqual(const A &a, const B &b) { return Compare<A, B>::moreOrEqual(a, b); }
+
+template <typename A, typename B> bool evaluateDoubleEqual(const A &a, const B &b) { return a == b; }
+template <typename A, typename B> bool evaluateNotEqual(   const A &a, const B &b) { return a != b; }