cleanup

Signed-off-by: Pratik Mankawde <3397372+pratikmankawde@users.noreply.github.com>

src/doctest/MIGRATION.md

@@ -6,11 +6,26 @@ This document describes the migration of unit tests from the beast `unit_test` f
 
 Tests were migrated from `src/test/` (beast unit_test format) to `src/doctest/` (doctest format), following the pattern established in `src/tests/libxrpl/`.
 
+## Why Doctest?
+
+Doctest is a fully open source, light, and feature-rich C++11 single-header testing framework. Key advantages include:
+
+- **Ultra-light compile times**: ~10ms overhead per source file (vs ~430ms for Catch)
+- **Fast assertions**: 50,000 asserts compile in under 30 seconds
+- **Removable tests**: Use `DOCTEST_CONFIG_DISABLE` to completely remove tests from release binaries
+- **No namespace pollution**: Everything is in the `doctest` namespace
+- **No warnings**: Clean compilation even with aggressive warning levels (`-Wall -Wextra -Werror`)
+- **Expression decomposition**: Failed assertions show both the expression and values
+- **Single header**: No external dependencies except C/C++ standard library
+
+Reference: [ACCU article on doctest](https://accu.org/journals/overload/25/137/kirilov_2343/)
+
 ## Build Configuration
 
 ### CMakeLists.txt Structure
 
 Created `src/doctest/CMakeLists.txt` with:
+
 - Helper function `xrpl_add_doctest(name)` that creates per-module executables
 - Compiler flags: `-m64 -g -std=c++20 -fPIE -Wno-unknown-warning-option -Wall -Wdeprecated -Wno-deprecated-declarations -Wextra -Wno-unused-parameter -Werror -fstack-protector -Wno-sign-compare -Wno-unused-but-set-variable -MD -MT -MF`
 - Six module targets: `xrpl.doctest.basics`, `xrpl.doctest.beast`, `xrpl.doctest.core`, `xrpl.doctest.csf`, `xrpl.doctest.nodestore`, `xrpl.doctest.protocol`
@@ -18,6 +33,7 @@ Created `src/doctest/CMakeLists.txt` with:
 ### Module Structure
 
 Each module has its own `main.cpp` following the pre-migrated test pattern:
+
 ```
 src/doctest/
 ├── basics/main.cpp
@@ -28,17 +44,183 @@ src/doctest/
 └── protocol/main.cpp
 ```
 
+## Doctest Assertion Reference
+
+Doctest provides three severity levels for all assertion macros:
+
+| Level     | Behavior                                              |
+| --------- | ----------------------------------------------------- |
+| `REQUIRE` | Immediately quits the test case if the assert fails   |
+| `CHECK`   | Marks test as failed but continues with the test case |
+| `WARN`    | Only prints a message, does not mark test as failed   |
+
+### Expression Decomposing Asserts
+
+```cpp
+CHECK(expression);      // Expression can be binary comparison or single value
+REQUIRE(a == b);        // Fails and stops test if false
+WARN(vec.isEmpty());    // Just warns, doesn't fail test
+```
+
+### Negating Asserts
+
+Use `_FALSE` suffix when `!` prefix cannot be decomposed properly:
+
+```cpp
+REQUIRE_FALSE(thisReturnsFalse());  // Better than REQUIRE(!thisReturnsFalse())
+CHECK_FALSE(condition);
+```
+
+### Binary Asserts (57-68% faster compilation)
+
+These don't use template decomposition - faster to compile:
+
+```cpp
+CHECK_EQ(left, right);   // same as CHECK(left == right)
+CHECK_NE(left, right);   // same as CHECK(left != right)
+CHECK_GT(left, right);   // same as CHECK(left > right)
+CHECK_LT(left, right);   // same as CHECK(left < right)
+CHECK_GE(left, right);   // same as CHECK(left >= right)
+CHECK_LE(left, right);   // same as CHECK(left <= right)
+CHECK_UNARY(expr);       // same as CHECK(expr)
+CHECK_UNARY_FALSE(expr); // same as CHECK_FALSE(expr)
+```
+
+### Message Variants
+
+```cpp
+CHECK_MESSAGE(a < b, "relevant only to this assert ", other_local);
+INFO("this is relevant to all subsequent asserts");
+```
+
+### Exception Asserts
+
+```cpp
+CHECK_THROWS(expression);                              // Expects any exception
+CHECK_THROWS_AS(func(), std::runtime_error);           // Expects specific type
+CHECK_THROWS_WITH(func(), "error message");            // Expects specific message
+CHECK_THROWS_WITH_AS(func(), "msg", std::exception);   // Both type and message
+CHECK_NOTHROW(expression);                             // Expects no exception
+```
+
+### Floating Point Comparisons
+
+```cpp
+CHECK(value == doctest::Approx(expected));
+CHECK(22.0/7 == doctest::Approx(3.141).epsilon(0.01));  // 1% error tolerance
+```
+
+### String Containment
+
+```cpp
+CHECK("foobar" == doctest::Contains("foo"));
+CHECK_THROWS_WITH(func(), doctest::Contains("partial"));
+```
+
 ## Framework Conversion Patterns
 
-| Beast Unit Test | Doctest Equivalent |
-|-----------------|-------------------|
-| `#include <xrpl/beast/unit_test.h>` | `#include <doctest/doctest.h>` |
-| `BEAST_EXPECT(expr)` | `CHECK(expr)` |
-| `BEAST_EXPECTS(expr, msg)` | `CHECK_MESSAGE(expr, msg)` |
-| `testcase("name")` | `SUBCASE("name")` |
+| Beast Unit Test                             | Doctest Equivalent              |
+| ------------------------------------------- | ------------------------------- |
+| `#include <xrpl/beast/unit_test.h>`         | `#include <doctest/doctest.h>`  |
+| `BEAST_EXPECT(expr)`                        | `CHECK(expr)`                   |
+| `BEAST_EXPECTS(expr, msg)`                  | `CHECK_MESSAGE(expr, msg)`      |
+| `testcase("name")`                          | `SUBCASE("name")`               |
 | `class X : public unit_test::suite { ... }` | Free functions with `TEST_CASE` |
-| `BEAST_DEFINE_TESTSUITE(Name, Module, Lib)` | `TEST_CASE("Name")` |
-| `pass()` / `fail()` | `CHECK(true)` / `CHECK(false)` |
+| `BEAST_DEFINE_TESTSUITE(Name, Module, Lib)` | `TEST_CASE("Name")`             |
+| `pass()` / `fail()`                         | `CHECK(true)` / `CHECK(false)`  |
+
+### Test Case and Subcase Structure
+
+```cpp
+TEST_CASE("Test name") {
+    // Setup code runs for each subcase
+
+    SUBCASE("First scenario") {
+        CHECK(something);
+    }
+
+    SUBCASE("Second scenario") {
+        CHECK(something_else);
+    }
+}
+```
+
+### Test Suites
+
+Group related test cases using `TEST_SUITE` or `TEST_SUITE_BEGIN`/`TEST_SUITE_END`:
+
+```cpp
+TEST_SUITE_BEGIN("MyModule");
+
+TEST_CASE("test 1") { /* ... */ }
+TEST_CASE("test 2") { /* ... */ }
+
+TEST_SUITE_END();
+```
+
+Or using the block syntax:
+
+```cpp
+TEST_SUITE("MyModule") {
+    TEST_CASE("test 1") { /* ... */ }
+    TEST_CASE("test 2") { /* ... */ }
+}
+```
+
+### Test Fixtures
+
+Use `TEST_CASE_FIXTURE` for class-based fixtures:
+
+```cpp
+class MyFixture {
+protected:
+    int data = 42;
+public:
+    MyFixture() { /* setup */ }
+    ~MyFixture() { /* teardown */ }
+};
+
+TEST_CASE_FIXTURE(MyFixture, "test with fixture") {
+    CHECK_EQ(data, 42);  // can access fixture members
+}
+```
+
+### Templated Test Cases
+
+```cpp
+TEST_CASE_TEMPLATE("test for multiple types", T, int, float, double) {
+    T value = T(42);
+    CHECK_EQ(value, T(42));
+}
+```
+
+### BDD-Style Macros
+
+```cpp
+SCENARIO("vectors can be sized") {
+    GIVEN("A vector with some items") {
+        std::vector<int> v(5);
+
+        WHEN("the size is increased") {
+            v.resize(10);
+
+            THEN("the size changes") {
+                CHECK_EQ(v.size(), 10);
+            }
+        }
+    }
+}
+```
+
+### Logging
+
+```cpp
+INFO("this message appears if a subsequent assert fails");
+CAPTURE(variable);  // logs "variable := <value>"
+MESSAGE("always printed");
+FAIL("fails and stops test case");
+FAIL_CHECK("fails but continues");
+```
 
 ## Namespace Changes
 
@@ -49,10 +231,10 @@ src/doctest/
 
 ### 1. CHECK Macro with Complex Expressions
 
-**Problem**: Doctest's CHECK macro doesn't support `&&` or `||` in expressions.
+**Problem**: Doctest's CHECK macro doesn't support `&&` or `||` in expressions due to expression decomposition.
 
 ```cpp
-// Doesn't work
+// Doesn't work - can't decompose && properly
 CHECK(a && b);
 
 // Solution: Split into separate checks
@@ -65,10 +247,13 @@ CHECK(b);
 **Problem**: CHECK wraps expressions in `Expression_lhs<>` which breaks template argument deduction for custom comparison operators (especially boost::intrusive iterators).
 
 ```cpp
-// Doesn't compile
+// Doesn't compile with complex iterators
 CHECK(iter != container.end());
 
-// Solution: Store result in bool first
+// Solution: Use binary assert or store result in bool first
+CHECK_NE(iter, container.end());  // Preferred - uses binary assert
+
+// Or:
 bool notEnd = (iter != container.end());
 CHECK(notEnd);
 ```
@@ -94,53 +279,90 @@ For map types with `P&&` insert overloads, return types differ:
 if constexpr (!IsMulti && IsMap)
 {
     auto result = c.insert(c.end(), value);  // returns pair<iterator, bool>
-    CHECK(result.first != c.end());
+    CHECK_NE(result.first, c.end());
 }
 else
 {
     auto it = c.insert(c.end(), value);  // returns iterator
-    CHECK(it != c.end());
+    CHECK_NE(it, c.end());
 }
 ```
 
+### 5. Types Without Explicit Bool Conversion
+
+**Problem**: `CHECK_FALSE(x)` and `CHECK_UNARY(x)` require the type to have an explicit `operator bool()`. Types like `base_uint` may only have `operator!()`.
+
+```cpp
+// Error: base_uint has operator!() but no explicit bool conversion
+CHECK_FALSE(z);        // Fails: can't static_cast<bool>(z)
+CHECK_UNARY(z);        // Fails: same reason
+
+// Solution: Use the negation operator explicitly
+CHECK_UNARY(!z);       // Works: uses operator!() which returns bool
+CHECK_UNARY(!z.isNonZero());  // For bool methods, prefer explicit negation
+```
+
 ## Files Migrated
 
 ### basics/ (13 files)
+
 - Buffer.cpp, Expected.cpp, IOUAmount.cpp, KeyCache.cpp, Number.cpp
 - StringUtilities.cpp, TaggedCache.cpp, Units.cpp, XRPAmount.cpp
 - base58.cpp, base_uint.cpp, hardened_hash.cpp, join.cpp
 
 ### beast/ (11 files)
+
 - CurrentThreadName.cpp, IPEndpoint.cpp, Journal.cpp, LexicalCast.cpp
 - PropertyStream.cpp, SemanticVersion.cpp, aged_associative_container.cpp
 - basic_seconds_clock.cpp, beast_Zero.cpp, xxhasher.cpp
 
 ### core/ (1 file)
+
 - Workers.cpp
 
 ### csf/ (4 files)
+
 - BasicNetwork.cpp, Digraph.cpp, Histogram.cpp, Scheduler.cpp
 
 ### nodestore/ (1 file)
+
 - varint.cpp
 
 ### protocol/ (14 files)
+
 - ApiVersion.cpp, BuildInfo.cpp, Issue.cpp, MultiApiJson.cpp
 - PublicKey.cpp, Quality.cpp, STAccount.cpp, STInteger.cpp
 - STNumber.cpp, SecretKey.cpp, Seed.cpp, SeqProxy.cpp
 - Serializer.cpp, TER.cpp
 
+## Binary Assertion Conversion
+
+All migrated tests have been updated to use doctest's binary assertion macros for improved compilation speed (57-68% faster) and better error messages:
+
+| Original Pattern  | Converted To                                |
+| ----------------- | ------------------------------------------- |
+| `CHECK(a == b)`   | `CHECK_EQ(a, b)`                            |
+| `CHECK(a != b)`   | `CHECK_NE(a, b)`                            |
+| `CHECK(a > b)`    | `CHECK_GT(a, b)`                            |
+| `CHECK(a < b)`    | `CHECK_LT(a, b)`                            |
+| `CHECK(a >= b)`   | `CHECK_GE(a, b)`                            |
+| `CHECK(a <= b)`   | `CHECK_LE(a, b)`                            |
+| `CHECK(!expr)`    | `CHECK_FALSE(expr)` or `CHECK_UNARY(!expr)` |
+| `CHECK(boolExpr)` | `CHECK_UNARY(boolExpr)`                     |
+
+**Note**: Template type checks like `CHECK((std::is_same_v<T, U>))` and function calls with template parameters like `CHECK(tryEdgeCase<std::uint64_t>("..."))` remain as `CHECK()` since they are not comparison operations.
+
 ## Test Results Summary
 
-| Module | Test Cases | Assertions |
-|--------|------------|------------|
-| basics | 61 | 2,638,582 |
-| beast | 48 | 162,715 |
-| core | 6 | 66 |
-| csf | 8 | 101 |
-| nodestore | 1 | 68 |
-| protocol | 73 | 20,372 |
-| **Total** | **197** | **2,821,904** |
+| Module    | Test Cases | Assertions    |
+| --------- | ---------- | ------------- |
+| basics    | 61         | 2,638,582     |
+| beast     | 48         | 162,715       |
+| core      | 6          | 66            |
+| csf       | 8          | 101           |
+| nodestore | 1          | 68            |
+| protocol  | 73         | 20,372        |
+| **Total** | **197**    | **2,821,904** |
 
 ## Running Tests
 
@@ -164,8 +386,18 @@ for test in src/doctest/xrpl.doctest.*; do ./$test; done
 ## Tests Not Migrated
 
 Some tests were not migrated due to dependencies:
+
 - **Manual tests** requiring user interaction (e.g., `DetectCrash_test`)
 - **Tests using xrpld infrastructure** (`test/jtx.h`, `unit_test/SuiteJournal.h`)
 - **Complex async tests** using boost coroutines
 - **Tests with FileDirGuard** or other test-specific utilities
 
+## References
+
+- [Doctest GitHub Repository](https://github.com/doctest/doctest)
+- [Doctest Assertions](https://github.com/doctest/doctest/blob/master/doc/markdown/assertions.md)
+- [Doctest Test Cases](https://github.com/doctest/doctest/blob/master/doc/markdown/testcases.md)
+- [Doctest Configuration](https://github.com/doctest/doctest/blob/master/doc/markdown/configuration.md)
+- [Doctest Logging](https://github.com/doctest/doctest/blob/master/doc/markdown/logging.md)
+- [Doctest Examples](https://github.com/doctest/doctest/tree/master/examples)
+- [ACCU Article: doctest – the Lightest C++ Unit Testing Framework](https://accu.org/journals/overload/25/137/kirilov_2343/)

src/doctest/basics/Buffer.cpp

@@ -28,67 +28,67 @@ TEST_CASE("basic operations")
         0xf0, 0x2c, 0x15, 0xd1, 0xf9, 0x9b, 0x66, 0xd2, 0x30, 0xd3};
 
     Buffer b0;
-    CHECK(sane(b0));
-    CHECK(b0.empty());
+    CHECK_UNARY(sane(b0));
+    CHECK_UNARY(b0.empty());
 
     Buffer b1{0};
-    CHECK(sane(b1));
-    CHECK(b1.empty());
+    CHECK_UNARY(sane(b1));
+    CHECK_UNARY(b1.empty());
     std::memcpy(b1.alloc(16), data, 16);
-    CHECK(sane(b1));
-    CHECK(!b1.empty());
-    CHECK(b1.size() == 16);
+    CHECK_UNARY(sane(b1));
+    CHECK_FALSE(b1.empty());
+    CHECK_EQ(b1.size(), 16);
 
     Buffer b2{b1.size()};
-    CHECK(sane(b2));
-    CHECK(!b2.empty());
-    CHECK(b2.size() == b1.size());
+    CHECK_UNARY(sane(b2));
+    CHECK_FALSE(b2.empty());
+    CHECK_EQ(b2.size(), b1.size());
     std::memcpy(b2.data(), data + 16, 16);
 
     Buffer b3{data, sizeof(data)};
-    CHECK(sane(b3));
-    CHECK(!b3.empty());
-    CHECK(b3.size() == sizeof(data));
-    CHECK(std::memcmp(b3.data(), data, b3.size()) == 0);
+    CHECK_UNARY(sane(b3));
+    CHECK_FALSE(b3.empty());
+    CHECK_EQ(b3.size(), sizeof(data));
+    CHECK_EQ(std::memcmp(b3.data(), data, b3.size()), 0);
 
     // Check equality and inequality comparisons
-    CHECK(b0 == b0);
-    CHECK(b0 != b1);
-    CHECK(b1 == b1);
-    CHECK(b1 != b2);
-    CHECK(b2 != b3);
+    CHECK_EQ(b0, b0);
+    CHECK_NE(b0, b1);
+    CHECK_EQ(b1, b1);
+    CHECK_NE(b1, b2);
+    CHECK_NE(b2, b3);
 
     SUBCASE("Copy Construction / Assignment")
     {
         Buffer x{b0};
-        CHECK(x == b0);
-        CHECK(sane(x));
+        CHECK_EQ(x, b0);
+        CHECK_UNARY(sane(x));
         Buffer y{b1};
-        CHECK(y == b1);
-        CHECK(sane(y));
+        CHECK_EQ(y, b1);
+        CHECK_UNARY(sane(y));
         x = b2;
-        CHECK(x == b2);
-        CHECK(sane(x));
+        CHECK_EQ(x, b2);
+        CHECK_UNARY(sane(x));
         x = y;
-        CHECK(x == y);
-        CHECK(sane(x));
+        CHECK_EQ(x, y);
+        CHECK_UNARY(sane(x));
         y = b3;
-        CHECK(y == b3);
-        CHECK(sane(y));
+        CHECK_EQ(y, b3);
+        CHECK_UNARY(sane(y));
         x = b0;
-        CHECK(x == b0);
-        CHECK(sane(x));
+        CHECK_EQ(x, b0);
+        CHECK_UNARY(sane(x));
 #if defined(__clang__)
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wself-assign-overloaded"
 #endif
 
         x = x;
-        CHECK(x == b0);
-        CHECK(sane(x));
+        CHECK_EQ(x, b0);
+        CHECK_UNARY(sane(x));
         y = y;
-        CHECK(y == b3);
-        CHECK(sane(y));
+        CHECK_EQ(y, b3);
+        CHECK_UNARY(sane(y));
 
 #if defined(__clang__)
 #pragma clang diagnostic pop
@@ -103,20 +103,20 @@ TEST_CASE("basic operations")
         {  // Move-construct from empty buf
             Buffer x;
             Buffer y{std::move(x)};
-            CHECK(sane(x));
-            CHECK(x.empty());
-            CHECK(sane(y));
-            CHECK(y.empty());
-            CHECK(x == y);
+            CHECK_UNARY(sane(x));
+            CHECK_UNARY(x.empty());
+            CHECK_UNARY(sane(y));
+            CHECK_UNARY(y.empty());
+            CHECK_EQ(x, y);
         }
 
         {  // Move-construct from non-empty buf
             Buffer x{b1};
             Buffer y{std::move(x)};
-            CHECK(sane(x));
-            CHECK(x.empty());
-            CHECK(sane(y));
-            CHECK(y == b1);
+            CHECK_UNARY(sane(x));
+            CHECK_UNARY(x.empty());
+            CHECK_UNARY(sane(y));
+            CHECK_EQ(y, b1);
         }
 
         {  // Move assign empty buf to empty buf
@@ -124,10 +124,10 @@ TEST_CASE("basic operations")
             Buffer y;
 
             x = std::move(y);
-            CHECK(sane(x));
-            CHECK(x.empty());
-            CHECK(sane(y));
-            CHECK(y.empty());
+            CHECK_UNARY(sane(x));
+            CHECK_UNARY(x.empty());
+            CHECK_UNARY(sane(y));
+            CHECK_UNARY(y.empty());
         }
 
         {  // Move assign non-empty buf to empty buf
@@ -135,10 +135,10 @@ TEST_CASE("basic operations")
             Buffer y{b1};
 
             x = std::move(y);
-            CHECK(sane(x));
-            CHECK(x == b1);
-            CHECK(sane(y));
-            CHECK(y.empty());
+            CHECK_UNARY(sane(x));
+            CHECK_EQ(x, b1);
+            CHECK_UNARY(sane(y));
+            CHECK_UNARY(y.empty());
         }
 
         {  // Move assign empty buf to non-empty buf
@@ -146,10 +146,10 @@ TEST_CASE("basic operations")
             Buffer y;
 
             x = std::move(y);
-            CHECK(sane(x));
-            CHECK(x.empty());
-            CHECK(sane(y));
-            CHECK(y.empty());
+            CHECK_UNARY(sane(x));
+            CHECK_UNARY(x.empty());
+            CHECK_UNARY(sane(y));
+            CHECK_UNARY(y.empty());
         }
 
         {  // Move assign non-empty buf to non-empty buf
@@ -158,61 +158,61 @@ TEST_CASE("basic operations")
             Buffer z{b3};
 
             x = std::move(y);
-            CHECK(sane(x));
-            CHECK(!x.empty());
-            CHECK(sane(y));
-            CHECK(y.empty());
+            CHECK_UNARY(sane(x));
+            CHECK_FALSE(x.empty());
+            CHECK_UNARY(sane(y));
+            CHECK_UNARY(y.empty());
 
             x = std::move(z);
-            CHECK(sane(x));
-            CHECK(!x.empty());
-            CHECK(sane(z));
-            CHECK(z.empty());
+            CHECK_UNARY(sane(x));
+            CHECK_FALSE(x.empty());
+            CHECK_UNARY(sane(z));
+            CHECK_UNARY(z.empty());
         }
     }
 
     SUBCASE("Slice Conversion / Construction / Assignment")
     {
         Buffer w{static_cast<Slice>(b0)};
-        CHECK(sane(w));
-        CHECK(w == b0);
+        CHECK_UNARY(sane(w));
+        CHECK_EQ(w, b0);
 
         Buffer x{static_cast<Slice>(b1)};
-        CHECK(sane(x));
-        CHECK(x == b1);
+        CHECK_UNARY(sane(x));
+        CHECK_EQ(x, b1);
 
         Buffer y{static_cast<Slice>(b2)};
-        CHECK(sane(y));
-        CHECK(y == b2);
+        CHECK_UNARY(sane(y));
+        CHECK_EQ(y, b2);
 
         Buffer z{static_cast<Slice>(b3)};
-        CHECK(sane(z));
-        CHECK(z == b3);
+        CHECK_UNARY(sane(z));
+        CHECK_EQ(z, b3);
 
         // Assign empty slice to empty buffer
         w = static_cast<Slice>(b0);
-        CHECK(sane(w));
-        CHECK(w == b0);
+        CHECK_UNARY(sane(w));
+        CHECK_EQ(w, b0);
 
         // Assign non-empty slice to empty buffer
         w = static_cast<Slice>(b1);
-        CHECK(sane(w));
-        CHECK(w == b1);
+        CHECK_UNARY(sane(w));
+        CHECK_EQ(w, b1);
 
         // Assign non-empty slice to non-empty buffer
         x = static_cast<Slice>(b2);
-        CHECK(sane(x));
-        CHECK(x == b2);
+        CHECK_UNARY(sane(x));
+        CHECK_EQ(x, b2);
 
         // Assign non-empty slice to non-empty buffer
         y = static_cast<Slice>(z);
-        CHECK(sane(y));
-        CHECK(y == z);
+        CHECK_UNARY(sane(y));
+        CHECK_EQ(y, z);
 
         // Assign empty slice to non-empty buffer:
         z = static_cast<Slice>(b0);
-        CHECK(sane(z));
-        CHECK(z == b0);
+        CHECK_UNARY(sane(z));
+        CHECK_EQ(z, b0);
     }
 
     SUBCASE("Allocation, Deallocation and Clearing")
@@ -223,27 +223,27 @@ TEST_CASE("basic operations")
             // Try to allocate some number of bytes, possibly
             // zero (which means clear) and sanity check
             x(i);
-            CHECK(sane(x));
-            CHECK(x.size() == i);
-            CHECK((x.data() == nullptr) == (i == 0));
+            CHECK_UNARY(sane(x));
+            CHECK_EQ(x.size(), i);
+            CHECK_EQ((x.data() == nullptr), (i == 0));
 
             // Try to allocate some more data (always non-zero)
             x(i + 1);
-            CHECK(sane(x));
-            CHECK(x.size() == i + 1);
-            CHECK(x.data() != nullptr);
+            CHECK_UNARY(sane(x));
+            CHECK_EQ(x.size(), i + 1);
+            CHECK_NE(x.data(), nullptr);
 
             // Try to clear:
             x.clear();
-            CHECK(sane(x));
-            CHECK(x.size() == 0);
-            CHECK(x.data() == nullptr);
+            CHECK_UNARY(sane(x));
+            CHECK_EQ(x.size(), 0);
+            CHECK_EQ(x.data(), nullptr);
 
             // Try to clear again:
             x.clear();
-            CHECK(sane(x));
-            CHECK(x.size() == 0);
-            CHECK(x.data() == nullptr);
+            CHECK_UNARY(sane(x));
+            CHECK_EQ(x.size(), 0);
+            CHECK_EQ(x.data(), nullptr);
         };
 
         for (std::size_t i = 0; i < 16; ++i)

src/doctest/basics/Expected.cpp

@@ -18,11 +18,11 @@ TEST_CASE("non-error const construction")
     auto const expected = []() -> Expected<std::string, TER> {
         return "Valid value";
     }();
-    CHECK(expected);
-    CHECK(expected.has_value());
-    CHECK(expected.value() == "Valid value");
-    CHECK(*expected == "Valid value");
-    CHECK(expected->at(0) == 'V');
+    CHECK_UNARY(expected);
+    CHECK_UNARY(expected.has_value());
+    CHECK_EQ(expected.value(), "Valid value");
+    CHECK_EQ(*expected, "Valid value");
+    CHECK_EQ(expected->at(0), 'V');
 
     bool throwOccurred = false;
     try
@@ -32,10 +32,10 @@ TEST_CASE("non-error const construction")
     }
     catch (std::runtime_error const& e)
     {
-        CHECK(e.what() == std::string("bad expected access"));
+        CHECK_EQ(e.what(), std::string("bad expected access"));
         throwOccurred = true;
     }
-    CHECK(throwOccurred);
+    CHECK_UNARY(throwOccurred);
 }
 
 TEST_CASE("non-error non-const construction")
@@ -43,13 +43,13 @@ TEST_CASE("non-error non-const construction")
     auto expected = []() -> Expected<std::string, TER> {
         return "Valid value";
     }();
-    CHECK(expected);
-    CHECK(expected.has_value());
-    CHECK(expected.value() == "Valid value");
-    CHECK(*expected == "Valid value");
-    CHECK(expected->at(0) == 'V');
+    CHECK_UNARY(expected);
+    CHECK_UNARY(expected.has_value());
+    CHECK_EQ(expected.value(), "Valid value");
+    CHECK_EQ(*expected, "Valid value");
+    CHECK_EQ(expected->at(0), 'V');
     std::string mv = std::move(*expected);
-    CHECK(mv == "Valid value");
+    CHECK_EQ(mv, "Valid value");
 
     bool throwOccurred = false;
     try
@@ -59,10 +59,10 @@ TEST_CASE("non-error non-const construction")
     }
     catch (std::runtime_error const& e)
     {
-        CHECK(e.what() == std::string("bad expected access"));
+        CHECK_EQ(e.what(), std::string("bad expected access"));
         throwOccurred = true;
     }
-    CHECK(throwOccurred);
+    CHECK_UNARY(throwOccurred);
 }
 
 TEST_CASE("non-error overlapping type construction")
@@ -70,10 +70,10 @@ TEST_CASE("non-error overlapping type construction")
     auto expected = []() -> Expected<std::uint32_t, std::uint16_t> {
         return 1;
     }();
-    CHECK(expected);
-    CHECK(expected.has_value());
-    CHECK(expected.value() == 1);
-    CHECK(*expected == 1);
+    CHECK_UNARY(expected);
+    CHECK_UNARY(expected.has_value());
+    CHECK_EQ(expected.value(), 1);
+    CHECK_EQ(*expected, 1);
 
     bool throwOccurred = false;
     try
@@ -83,10 +83,10 @@ TEST_CASE("non-error overlapping type construction")
     }
     catch (std::runtime_error const& e)
     {
-        CHECK(e.what() == std::string("bad expected access"));
+        CHECK_EQ(e.what(), std::string("bad expected access"));
         throwOccurred = true;
     }
-    CHECK(throwOccurred);
+    CHECK_UNARY(throwOccurred);
 }
 
 TEST_CASE("error construction from rvalue")
@@ -94,9 +94,9 @@ TEST_CASE("error construction from rvalue")
     auto const expected = []() -> Expected<std::string, TER> {
         return Unexpected(telLOCAL_ERROR);
     }();
-    CHECK(!expected);
-    CHECK(!expected.has_value());
-    CHECK(expected.error() == telLOCAL_ERROR);
+    CHECK_FALSE(expected);
+    CHECK_FALSE(expected.has_value());
+    CHECK_EQ(expected.error(), telLOCAL_ERROR);
 
     bool throwOccurred = false;
     try
@@ -106,10 +106,10 @@ TEST_CASE("error construction from rvalue")
     }
     catch (std::runtime_error const& e)
     {
-        CHECK(e.what() == std::string("bad expected access"));
+        CHECK_EQ(e.what(), std::string("bad expected access"));
         throwOccurred = true;
     }
-    CHECK(throwOccurred);
+    CHECK_UNARY(throwOccurred);
 }
 
 TEST_CASE("error construction from lvalue")
@@ -118,9 +118,9 @@ TEST_CASE("error construction from lvalue")
     auto expected = [&err]() -> Expected<std::string, TER> {
         return Unexpected(err);
     }();
-    CHECK(!expected);
-    CHECK(!expected.has_value());
-    CHECK(expected.error() == telLOCAL_ERROR);
+    CHECK_FALSE(expected);
+    CHECK_FALSE(expected.has_value());
+    CHECK_EQ(expected.error(), telLOCAL_ERROR);
 
     bool throwOccurred = false;
     try
@@ -130,10 +130,10 @@ TEST_CASE("error construction from lvalue")
     }
     catch (std::runtime_error const& e)
     {
-        CHECK(e.what() == std::string("bad expected access"));
+        CHECK_EQ(e.what(), std::string("bad expected access"));
         throwOccurred = true;
     }
-    CHECK(throwOccurred);
+    CHECK_UNARY(throwOccurred);
 }
 
 TEST_CASE("error construction from const char*")
@@ -141,9 +141,9 @@ TEST_CASE("error construction from const char*")
     auto const expected = []() -> Expected<int, char const*> {
         return Unexpected("Not what is expected!");
     }();
-    CHECK(!expected);
-    CHECK(!expected.has_value());
-    CHECK(expected.error() == std::string("Not what is expected!"));
+    CHECK_FALSE(expected);
+    CHECK_FALSE(expected.has_value());
+    CHECK_EQ(expected.error(), std::string("Not what is expected!"));
 }
 
 TEST_CASE("error construction of string from const char*")
@@ -151,17 +151,17 @@ TEST_CASE("error construction of string from const char*")
     auto expected = []() -> Expected<int, std::string> {
         return Unexpected("Not what is expected!");
     }();
-    CHECK(!expected);
-    CHECK(!expected.has_value());
-    CHECK(expected.error() == "Not what is expected!");
+    CHECK_FALSE(expected);
+    CHECK_FALSE(expected.has_value());
+    CHECK_EQ(expected.error(), "Not what is expected!");
     std::string const s(std::move(expected.error()));
-    CHECK(s == "Not what is expected!");
+    CHECK_EQ(s, "Not what is expected!");
 }
 
 TEST_CASE("non-error const construction of Expected<void, T>")
 {
     auto const expected = []() -> Expected<void, std::string> { return {}; }();
-    CHECK(expected);
+    CHECK_UNARY(expected);
     bool throwOccurred = false;
     try
     {
@@ -170,16 +170,16 @@ TEST_CASE("non-error const construction of Expected<void, T>")
     }
     catch (std::runtime_error const& e)
     {
-        CHECK(e.what() == std::string("bad expected access"));
+        CHECK_EQ(e.what(), std::string("bad expected access"));
         throwOccurred = true;
     }
-    CHECK(throwOccurred);
+    CHECK_UNARY(throwOccurred);
 }
 
 TEST_CASE("non-error non-const construction of Expected<void, T>")
 {
     auto expected = []() -> Expected<void, std::string> { return {}; }();
-    CHECK(expected);
+    CHECK_UNARY(expected);
     bool throwOccurred = false;
     try
     {
@@ -188,10 +188,10 @@ TEST_CASE("non-error non-const construction of Expected<void, T>")
     }
     catch (std::runtime_error const& e)
     {
-        CHECK(e.what() == std::string("bad expected access"));
+        CHECK_EQ(e.what(), std::string("bad expected access"));
         throwOccurred = true;
     }
-    CHECK(throwOccurred);
+    CHECK_UNARY(throwOccurred);
 }
 
 TEST_CASE("error const construction of Expected<void, T>")
@@ -199,8 +199,8 @@ TEST_CASE("error const construction of Expected<void, T>")
     auto const expected = []() -> Expected<void, std::string> {
         return Unexpected("Not what is expected!");
     }();
-    CHECK(!expected);
-    CHECK(expected.error() == "Not what is expected!");
+    CHECK_FALSE(expected);
+    CHECK_EQ(expected.error(), "Not what is expected!");
 }
 
 TEST_CASE("error non-const construction of Expected<void, T>")
@@ -208,10 +208,10 @@ TEST_CASE("error non-const construction of Expected<void, T>")
     auto expected = []() -> Expected<void, std::string> {
         return Unexpected("Not what is expected!");
     }();
-    CHECK(!expected);
-    CHECK(expected.error() == "Not what is expected!");
+    CHECK_FALSE(expected);
+    CHECK_EQ(expected.error(), "Not what is expected!");
     std::string const s(std::move(expected.error()));
-    CHECK(s == "Not what is expected!");
+    CHECK_EQ(s, "Not what is expected!");
 }
 
 #if BOOST_VERSION >= 107500
@@ -220,8 +220,8 @@ TEST_CASE("boost::json::value construction")
     auto expected = []() -> Expected<boost::json::value, std::string> {
         return boost::json::object{{"oops", "me array now"}};
     }();
-    CHECK(expected);
-    CHECK(!expected.value().is_array());
+    CHECK_UNARY(expected);
+    CHECK_FALSE(expected.value().is_array());
 }
 #endif  // BOOST_VERSION
 

src/doctest/basics/IOUAmount.cpp

@@ -10,34 +10,34 @@ TEST_CASE("zero")
 {
     IOUAmount const z(0, 0);
 
-    CHECK(z.mantissa() == 0);
-    CHECK(z.exponent() == -100);
-    CHECK(!z);
-    CHECK(z.signum() == 0);
-    CHECK(z == beast::zero);
+    CHECK_EQ(z.mantissa(), 0);
+    CHECK_EQ(z.exponent(), -100);
+    CHECK_FALSE(z);
+    CHECK_EQ(z.signum(), 0);
+    CHECK_EQ(z, beast::zero);
 
-    CHECK((z + z) == z);
-    CHECK((z - z) == z);
-    CHECK(z == -z);
+    CHECK_EQ((z + z), z);
+    CHECK_EQ((z - z), z);
+    CHECK_EQ(z, -z);
 
     IOUAmount const zz(beast::zero);
-    CHECK(z == zz);
+    CHECK_EQ(z, zz);
 
     // https://github.com/XRPLF/rippled/issues/5170
     IOUAmount const zzz{};
-    CHECK(zzz == beast::zero);
+    CHECK_EQ(zzz, beast::zero);
 }
 
 TEST_CASE("signum")
 {
     IOUAmount const neg(-1, 0);
-    CHECK(neg.signum() < 0);
+    CHECK_LT(neg.signum(), 0);
 
     IOUAmount const zer(0, 0);
-    CHECK(zer.signum() == 0);
+    CHECK_EQ(zer.signum(), 0);
 
     IOUAmount const pos(1, 0);
-    CHECK(pos.signum() > 0);
+    CHECK_GT(pos.signum(), 0);
 }
 
 TEST_CASE("beast::Zero Comparisons")
@@ -46,28 +46,28 @@ TEST_CASE("beast::Zero Comparisons")
 
     {
         IOUAmount z(zero);
-        CHECK(z == zero);
-        CHECK(z >= zero);
-        CHECK(z <= zero);
-        CHECK(!(z != zero));
-        CHECK(!(z > zero));
-        CHECK(!(z < zero));
+        CHECK_EQ(z, zero);
+        CHECK_GE(z, zero);
+        CHECK_LE(z, zero);
+        CHECK_FALSE(z != zero);
+        CHECK_FALSE(z > zero);
+        CHECK_FALSE(z < zero);
     }
 
     {
         IOUAmount const neg(-2, 0);
-        CHECK(neg < zero);
-        CHECK(neg <= zero);
-        CHECK(neg != zero);
-        CHECK(!(neg == zero));
+        CHECK_LT(neg, zero);
+        CHECK_LE(neg, zero);
+        CHECK_NE(neg, zero);
+        CHECK_FALSE(neg == zero);
     }
 
     {
         IOUAmount const pos(2, 0);
-        CHECK(pos > zero);
-        CHECK(pos >= zero);
-        CHECK(pos != zero);
-        CHECK(!(pos == zero));
+        CHECK_GT(pos, zero);
+        CHECK_GE(pos, zero);
+        CHECK_NE(pos, zero);
+        CHECK_FALSE(pos == zero);
     }
 }
 
@@ -77,63 +77,63 @@ TEST_CASE("IOU Comparisons")
     IOUAmount const z(0, 0);
     IOUAmount const p(2, 0);
 
-    CHECK(z == z);
-    CHECK(z >= z);
-    CHECK(z <= z);
-    CHECK(z == -z);
-    CHECK(!(z > z));
-    CHECK(!(z < z));
-    CHECK(!(z != z));
-    CHECK(!(z != -z));
+    CHECK_EQ(z, z);
+    CHECK_GE(z, z);
+    CHECK_LE(z, z);
+    CHECK_EQ(z, -z);
+    CHECK_FALSE(z > z);
+    CHECK_FALSE(z < z);
+    CHECK_FALSE(z != z);
+    CHECK_FALSE(z != -z);
 
-    CHECK(n < z);
-    CHECK(n <= z);
-    CHECK(n != z);
-    CHECK(!(n > z));
-    CHECK(!(n >= z));
-    CHECK(!(n == z));
+    CHECK_LT(n, z);
+    CHECK_LE(n, z);
+    CHECK_NE(n, z);
+    CHECK_FALSE(n > z);
+    CHECK_FALSE(n >= z);
+    CHECK_FALSE(n == z);
 
-    CHECK(p > z);
-    CHECK(p >= z);
-    CHECK(p != z);
-    CHECK(!(p < z));
-    CHECK(!(p <= z));
-    CHECK(!(p == z));
+    CHECK_GT(p, z);
+    CHECK_GE(p, z);
+    CHECK_NE(p, z);
+    CHECK_FALSE(p < z);
+    CHECK_FALSE(p <= z);
+    CHECK_FALSE(p == z);
 
-    CHECK(n < p);
-    CHECK(n <= p);
-    CHECK(n != p);
-    CHECK(!(n > p));
-    CHECK(!(n >= p));
-    CHECK(!(n == p));
+    CHECK_LT(n, p);
+    CHECK_LE(n, p);
+    CHECK_NE(n, p);
+    CHECK_FALSE(n > p);
+    CHECK_FALSE(n >= p);
+    CHECK_FALSE(n == p);
 
-    CHECK(p > n);
-    CHECK(p >= n);
-    CHECK(p != n);
-    CHECK(!(p < n));
-    CHECK(!(p <= n));
-    CHECK(!(p == n));
+    CHECK_GT(p, n);
+    CHECK_GE(p, n);
+    CHECK_NE(p, n);
+    CHECK_FALSE(p < n);
+    CHECK_FALSE(p <= n);
+    CHECK_FALSE(p == n);
 
-    CHECK(p > -p);
-    CHECK(p >= -p);
-    CHECK(p != -p);
+    CHECK_GT(p, -p);
+    CHECK_GE(p, -p);
+    CHECK_NE(p, -p);
 
-    CHECK(n < -n);
-    CHECK(n <= -n);
-    CHECK(n != -n);
+    CHECK_LT(n, -n);
+    CHECK_LE(n, -n);
+    CHECK_NE(n, -n);
 }
 
 TEST_CASE("IOU strings")
 {
-    CHECK(to_string(IOUAmount(-2, 0)) == "-2");
-    CHECK(to_string(IOUAmount(0, 0)) == "0");
-    CHECK(to_string(IOUAmount(2, 0)) == "2");
-    CHECK(to_string(IOUAmount(25, -3)) == "0.025");
-    CHECK(to_string(IOUAmount(-25, -3)) == "-0.025");
-    CHECK(to_string(IOUAmount(25, 1)) == "250");
-    CHECK(to_string(IOUAmount(-25, 1)) == "-250");
-    CHECK(to_string(IOUAmount(2, 20)) == "2000000000000000e5");
-    CHECK(to_string(IOUAmount(-2, -20)) == "-2000000000000000e-35");
+    CHECK_EQ(to_string(IOUAmount(-2, 0)), "-2");
+    CHECK_EQ(to_string(IOUAmount(0, 0)), "0");
+    CHECK_EQ(to_string(IOUAmount(2, 0)), "2");
+    CHECK_EQ(to_string(IOUAmount(25, -3)), "0.025");
+    CHECK_EQ(to_string(IOUAmount(-25, -3)), "-0.025");
+    CHECK_EQ(to_string(IOUAmount(25, 1)), "250");
+    CHECK_EQ(to_string(IOUAmount(-25, 1)), "-250");
+    CHECK_EQ(to_string(IOUAmount(2, 20)), "2000000000000000e5");
+    CHECK_EQ(to_string(IOUAmount(-2, -20)), "-2000000000000000e-35");
 }
 
 TEST_CASE("mulRatio")
@@ -150,36 +150,36 @@ TEST_CASE("mulRatio")
         // multiply by a number that would overflow the mantissa, then
         // divide by the same number, and check we didn't lose any value
         IOUAmount bigMan(maxMantissa, 0);
-        CHECK(bigMan == mulRatio(bigMan, maxUInt, maxUInt, true));
+        CHECK_EQ(bigMan, mulRatio(bigMan, maxUInt, maxUInt, true));
         // rounding mode shouldn't matter as the result is exact
-        CHECK(bigMan == mulRatio(bigMan, maxUInt, maxUInt, false));
+        CHECK_EQ(bigMan, mulRatio(bigMan, maxUInt, maxUInt, false));
     }
     {
         // Similar test as above, but for negative values
         IOUAmount bigMan(-maxMantissa, 0);
-        CHECK(bigMan == mulRatio(bigMan, maxUInt, maxUInt, true));
+        CHECK_EQ(bigMan, mulRatio(bigMan, maxUInt, maxUInt, true));
         // rounding mode shouldn't matter as the result is exact
-        CHECK(bigMan == mulRatio(bigMan, maxUInt, maxUInt, false));
+        CHECK_EQ(bigMan, mulRatio(bigMan, maxUInt, maxUInt, false));
     }
 
     {
         // small amounts
         IOUAmount tiny(minMantissa, minExponent);
         // Round up should give the smallest allowable number
-        CHECK(tiny == mulRatio(tiny, 1, maxUInt, true));
-        CHECK(tiny == mulRatio(tiny, maxUInt - 1, maxUInt, true));
+        CHECK_EQ(tiny, mulRatio(tiny, 1, maxUInt, true));
+        CHECK_EQ(tiny, mulRatio(tiny, maxUInt - 1, maxUInt, true));
         // rounding down should be zero
-        CHECK(beast::zero == mulRatio(tiny, 1, maxUInt, false));
-        CHECK(beast::zero == mulRatio(tiny, maxUInt - 1, maxUInt, false));
+        CHECK_EQ(beast::zero, mulRatio(tiny, 1, maxUInt, false));
+        CHECK_EQ(beast::zero, mulRatio(tiny, maxUInt - 1, maxUInt, false));
 
         // tiny negative numbers
         IOUAmount tinyNeg(-minMantissa, minExponent);
         // Round up should give zero
-        CHECK(beast::zero == mulRatio(tinyNeg, 1, maxUInt, true));
-        CHECK(beast::zero == mulRatio(tinyNeg, maxUInt - 1, maxUInt, true));
+        CHECK_EQ(beast::zero, mulRatio(tinyNeg, 1, maxUInt, true));
+        CHECK_EQ(beast::zero, mulRatio(tinyNeg, maxUInt - 1, maxUInt, true));
         // rounding down should be tiny
-        CHECK(tinyNeg == mulRatio(tinyNeg, 1, maxUInt, false));
-        CHECK(tinyNeg == mulRatio(tinyNeg, maxUInt - 1, maxUInt, false));
+        CHECK_EQ(tinyNeg, mulRatio(tinyNeg, 1, maxUInt, false));
+        CHECK_EQ(tinyNeg, mulRatio(tinyNeg, maxUInt - 1, maxUInt, false));
     }
 
     {  // rounding
@@ -187,20 +187,20 @@ TEST_CASE("mulRatio")
             IOUAmount one(1, 0);
             auto const rup = mulRatio(one, maxUInt - 1, maxUInt, true);
             auto const rdown = mulRatio(one, maxUInt - 1, maxUInt, false);
-            CHECK(rup.mantissa() - rdown.mantissa() == 1);
+            CHECK_EQ(rup.mantissa() - rdown.mantissa(), 1);
         }
         {
             IOUAmount big(maxMantissa, maxExponent);
             auto const rup = mulRatio(big, maxUInt - 1, maxUInt, true);
             auto const rdown = mulRatio(big, maxUInt - 1, maxUInt, false);
-            CHECK(rup.mantissa() - rdown.mantissa() == 1);
+            CHECK_EQ(rup.mantissa() - rdown.mantissa(), 1);
         }
 
         {
             IOUAmount negOne(-1, 0);
             auto const rup = mulRatio(negOne, maxUInt - 1, maxUInt, true);
             auto const rdown = mulRatio(negOne, maxUInt - 1, maxUInt, false);
-            CHECK(rup.mantissa() - rdown.mantissa() == 1);
+            CHECK_EQ(rup.mantissa() - rdown.mantissa(), 1);
         }
     }
 

src/doctest/basics/KeyCache.cpp

@@ -24,50 +24,50 @@ TEST_CASE("KeyCache operations")
     {
         Cache c("test", LedgerIndex(1), 2s, clock, j);
 
-        CHECK(c.size() == 0);
-        CHECK(c.insert("one"));
-        CHECK(!c.insert("one"));
-        CHECK(c.size() == 1);
-        CHECK(c.touch_if_exists("one"));
+        CHECK_EQ(c.size(), 0);
+        CHECK_UNARY(c.insert("one"));
+        CHECK_FALSE(c.insert("one"));
+        CHECK_EQ(c.size(), 1);
+        CHECK_UNARY(c.touch_if_exists("one"));
         ++clock;
         c.sweep();
-        CHECK(c.size() == 1);
+        CHECK_EQ(c.size(), 1);
         ++clock;
         c.sweep();
-        CHECK(c.size() == 0);
-        CHECK(!c.touch_if_exists("one"));
+        CHECK_EQ(c.size(), 0);
+        CHECK_FALSE(c.touch_if_exists("one"));
     }
 
     SUBCASE("Insert two items, have one expire")
     {
         Cache c("test", LedgerIndex(2), 2s, clock, j);
 
-        CHECK(c.insert("one"));
-        CHECK(c.size() == 1);
-        CHECK(c.insert("two"));
-        CHECK(c.size() == 2);
+        CHECK_UNARY(c.insert("one"));
+        CHECK_EQ(c.size(), 1);
+        CHECK_UNARY(c.insert("two"));
+        CHECK_EQ(c.size(), 2);
         ++clock;
         c.sweep();
-        CHECK(c.size() == 2);
-        CHECK(c.touch_if_exists("two"));
+        CHECK_EQ(c.size(), 2);
+        CHECK_UNARY(c.touch_if_exists("two"));
         ++clock;
         c.sweep();
-        CHECK(c.size() == 1);
+        CHECK_EQ(c.size(), 1);
     }
 
     SUBCASE("Insert three items (1 over limit), sweep")
     {
         Cache c("test", LedgerIndex(2), 3s, clock, j);
 
-        CHECK(c.insert("one"));
+        CHECK_UNARY(c.insert("one"));
         ++clock;
-        CHECK(c.insert("two"));
+        CHECK_UNARY(c.insert("two"));
         ++clock;
-        CHECK(c.insert("three"));
+        CHECK_UNARY(c.insert("three"));
         ++clock;
-        CHECK(c.size() == 3);
+        CHECK_EQ(c.size(), 3);
         c.sweep();
-        CHECK(c.size() < 3);
+        CHECK_LT(c.size(), 3);
     }
 }
 

src/doctest/basics/Number.cpp

@@ -15,12 +15,12 @@ TEST_CASE("zero")
 {
     Number const z{0, 0};
 
-    CHECK(z.mantissa() == 0);
-    CHECK(z.exponent() == Number{}.exponent());
+    CHECK_EQ(z.mantissa(), 0);
+    CHECK_EQ(z.exponent(), Number{}.exponent());
 
-    CHECK((z + z) == z);
-    CHECK((z - z) == z);
-    CHECK(z == -z);
+    CHECK_EQ((z + z), z);
+    CHECK_EQ((z - z), z);
+    CHECK_EQ(z, -z);
 }
 
 TEST_CASE("limits")
@@ -34,17 +34,17 @@ TEST_CASE("limits")
     {
         caught = true;
     }
-    CHECK(caught);
+    CHECK_UNARY(caught);
     Number x{10'000'000'000'000'000, 32767};
-    CHECK((x == Number{1'000'000'000'000'000, 32768}));
+    CHECK_EQ(x, Number{1'000'000'000'000'000, 32768});
     Number z{1'000'000'000'000'000, -32769};
-    CHECK(z == Number{});
+    CHECK_EQ(z, Number{});
     Number y{1'000'000'000'000'001'500, 32000};
-    CHECK((y == Number{1'000'000'000'000'002, 32003}));
+    CHECK_EQ(y, Number{1'000'000'000'000'002, 32003});
     Number m{std::numeric_limits<std::int64_t>::min()};
-    CHECK((m == Number{-9'223'372'036'854'776, 3}));
+    CHECK_EQ(m, Number{-9'223'372'036'854'776, 3});
     Number M{std::numeric_limits<std::int64_t>::max()};
-    CHECK((M == Number{9'223'372'036'854'776, 3}));
+    CHECK_EQ(M, Number{9'223'372'036'854'776, 3});
     caught = false;
     try
     {
@@ -54,7 +54,7 @@ TEST_CASE("limits")
     {
         caught = true;
     }
-    CHECK(caught);
+    CHECK_UNARY(caught);
 }
 
 TEST_CASE("add")
@@ -81,7 +81,7 @@ TEST_CASE("add")
          Number{1'000'000'000'000'000, -15},
          Number{9'999'999'999'999'990, -16}}};
     for (auto const& [x, y, z] : c)
-        CHECK(x + y == z);
+        CHECK_EQ(x + y, z);
     bool caught = false;
     try
     {
@@ -92,7 +92,7 @@ TEST_CASE("add")
     {
         caught = true;
     }
-    CHECK(caught);
+    CHECK_UNARY(caught);
 }
 
 TEST_CASE("sub")
@@ -115,7 +115,7 @@ TEST_CASE("sub")
          Number{1'000'000'000'000'000, -15},
          Number{1'000'000'000'000'000, -30}}};
     for (auto const& [x, y, z] : c)
-        CHECK(x - y == z);
+        CHECK_EQ(x - y, z);
 }
 
 TEST_CASE("mul")
@@ -141,7 +141,7 @@ TEST_CASE("mul")
              Number{1000000000000000, -32768},
              Number{0}}};
         for (auto const& [x, y, z] : c)
-            CHECK(x * y == z);
+            CHECK_EQ(x * y, z);
     }
     Number::setround(Number::towards_zero);
     {
@@ -151,7 +151,7 @@ TEST_CASE("mul")
              Number{1414213562373095, -15},
              Number{1999999999999999, -15}}};
         for (auto const& [x, y, z] : c)
-            CHECK(x * y == z);
+            CHECK_EQ(x * y, z);
     }
     bool caught = false;
     try
@@ -163,7 +163,7 @@ TEST_CASE("mul")
     {
         caught = true;
     }
-    CHECK(caught);
+    CHECK_UNARY(caught);
 }
 
 TEST_CASE("div")
@@ -185,7 +185,7 @@ TEST_CASE("div")
             {Number{2}, Number{3}, Number{6'666'666'666'666'667, -16}},
             {Number{-2}, Number{3}, Number{-6'666'666'666'666'667, -16}}};
         for (auto const& [x, y, z] : c)
-            CHECK(x / y == z);
+            CHECK_EQ(x / y, z);
     }
     bool caught = false;
     try
@@ -196,7 +196,7 @@ TEST_CASE("div")
     {
         caught = true;
     }
-    CHECK(caught);
+    CHECK_UNARY(caught);
 }
 
 TEST_CASE("root")
@@ -213,7 +213,7 @@ TEST_CASE("root")
         {Number{0}, 5, Number{0}},
         {Number{5625, -4}, 2, Number{75, -2}}};
     for (auto const& [x, y, z] : c)
-        CHECK((root(x, y) == z));
+        CHECK_EQ(root(x, y), z);
     bool caught = false;
     try
     {
@@ -223,7 +223,7 @@ TEST_CASE("root")
     {
         caught = true;
     }
-    CHECK(caught);
+    CHECK_UNARY(caught);
     caught = false;
     try
     {
@@ -233,7 +233,7 @@ TEST_CASE("root")
     {
         caught = true;
     }
-    CHECK(caught);
+    CHECK_UNARY(caught);
 }
 
 TEST_CASE("power1")
@@ -247,7 +247,7 @@ TEST_CASE("power1")
         {Number{64}, 3, Number{262144}},
         {Number{-64}, 3, Number{-262144}}};
     for (auto const& [x, y, z] : c)
-        CHECK((power(x, y) == z));
+        CHECK_EQ(power(x, y), z);
 }
 
 TEST_CASE("power2")
@@ -261,7 +261,7 @@ TEST_CASE("power2")
         {Number{34}, 3, 3, Number{34}},
         {Number{4}, 3, 2, Number{8}}};
     for (auto const& [x, n, d, z] : c)
-        CHECK((power(x, n, d) == z));
+        CHECK_EQ(power(x, n, d), z);
     bool caught = false;
     try
     {
@@ -271,7 +271,7 @@ TEST_CASE("power2")
     {
         caught = true;
     }
-    CHECK(caught);
+    CHECK_UNARY(caught);
     caught = false;
     try
     {
@@ -281,7 +281,7 @@ TEST_CASE("power2")
     {
         caught = true;
     }
-    CHECK(caught);
+    CHECK_UNARY(caught);
     caught = false;
     try
     {
@@ -291,62 +291,62 @@ TEST_CASE("power2")
     {
         caught = true;
     }
-    CHECK(caught);
+    CHECK_UNARY(caught);
 }
 
 TEST_CASE("conversions")
 {
     IOUAmount x{5, 6};
     Number y = x;
-    CHECK((y == Number{5, 6}));
+    CHECK_EQ(y, Number{5, 6});
     IOUAmount z{y};
-    CHECK(x == z);
+    CHECK_EQ(x, z);
     XRPAmount xrp{500};
     STAmount st = xrp;
     Number n = st;
-    CHECK(XRPAmount{n} == xrp);
+    CHECK_EQ(XRPAmount{n}, xrp);
     IOUAmount x0{0, 0};
     Number y0 = x0;
-    CHECK((y0 == Number{0}));
+    CHECK_EQ(y0, Number{0});
     IOUAmount z0{y0};
-    CHECK(x0 == z0);
+    CHECK_EQ(x0, z0);
     XRPAmount xrp0{0};
     Number n0 = xrp0;
-    CHECK(n0 == Number{0});
+    CHECK_EQ(n0, Number{0});
     XRPAmount xrp1{n0};
-    CHECK(xrp1 == xrp0);
+    CHECK_EQ(xrp1, xrp0);
 }
 
 TEST_CASE("squelch")
 {
     Number limit{1, -6};
-    CHECK((squelch(Number{2, -6}, limit) == Number{2, -6}));
-    CHECK((squelch(Number{1, -6}, limit) == Number{1, -6}));
-    CHECK((squelch(Number{9, -7}, limit) == Number{0}));
-    CHECK((squelch(Number{-2, -6}, limit) == Number{-2, -6}));
-    CHECK((squelch(Number{-1, -6}, limit) == Number{-1, -6}));
-    CHECK((squelch(Number{-9, -7}, limit) == Number{0}));
+    CHECK_EQ(squelch(Number{2, -6}, limit), Number{2, -6});
+    CHECK_EQ(squelch(Number{1, -6}, limit), Number{1, -6});
+    CHECK_EQ(squelch(Number{9, -7}, limit), Number{0});
+    CHECK_EQ(squelch(Number{-2, -6}, limit), Number{-2, -6});
+    CHECK_EQ(squelch(Number{-1, -6}, limit), Number{-1, -6});
+    CHECK_EQ(squelch(Number{-9, -7}, limit), Number{0});
 }
 
 TEST_CASE("toString")
 {
-    CHECK(to_string(Number(-2, 0)) == "-2");
-    CHECK(to_string(Number(0, 0)) == "0");
-    CHECK(to_string(Number(2, 0)) == "2");
-    CHECK(to_string(Number(25, -3)) == "0.025");
-    CHECK(to_string(Number(-25, -3)) == "-0.025");
-    CHECK(to_string(Number(25, 1)) == "250");
-    CHECK(to_string(Number(-25, 1)) == "-250");
-    CHECK(to_string(Number(2, 20)) == "2000000000000000e5");
-    CHECK(to_string(Number(-2, -20)) == "-2000000000000000e-35");
+    CHECK_EQ(to_string(Number(-2, 0)), "-2");
+    CHECK_EQ(to_string(Number(0, 0)), "0");
+    CHECK_EQ(to_string(Number(2, 0)), "2");
+    CHECK_EQ(to_string(Number(25, -3)), "0.025");
+    CHECK_EQ(to_string(Number(-25, -3)), "-0.025");
+    CHECK_EQ(to_string(Number(25, 1)), "250");
+    CHECK_EQ(to_string(Number(-25, 1)), "-250");
+    CHECK_EQ(to_string(Number(2, 20)), "2000000000000000e5");
+    CHECK_EQ(to_string(Number(-2, -20)), "-2000000000000000e-35");
 }
 
 TEST_CASE("relationals")
 {
-    CHECK(!(Number{100} < Number{10}));
-    CHECK(Number{100} > Number{10});
-    CHECK(Number{100} >= Number{10});
-    CHECK(!(Number{100} <= Number{10}));
+    CHECK_FALSE(Number{100} < Number{10});
+    CHECK_GT(Number{100}, Number{10});
+    CHECK_GE(Number{100}, Number{10});
+    CHECK_FALSE(Number{100} <= Number{10});
 }
 
 TEST_CASE("stream")
@@ -354,18 +354,18 @@ TEST_CASE("stream")
     Number x{100};
     std::ostringstream os;
     os << x;
-    CHECK(os.str() == to_string(x));
+    CHECK_EQ(os.str(), to_string(x));
 }
 
 TEST_CASE("inc_dec")
 {
     Number x{100};
     Number y = +x;
-    CHECK(x == y);
-    CHECK(x++ == y);
-    CHECK(x == Number{101});
-    CHECK(x-- == Number{101});
-    CHECK(x == y);
+    CHECK_EQ(x, y);
+    CHECK_EQ(x++, y);
+    CHECK_EQ(x, Number{101});
+    CHECK_EQ(x--, Number{101});
+    CHECK_EQ(x, y);
 }
 
 TEST_CASE("toSTAmount")
@@ -375,42 +375,42 @@ TEST_CASE("toSTAmount")
     Number const n{7'518'783'80596, -5};
     saveNumberRoundMode const save{Number::setround(Number::to_nearest)};
     auto res2 = STAmount{issue, n.mantissa(), n.exponent()};
-    CHECK(res2 == STAmount{7518784});
+    CHECK_EQ(res2, STAmount{7518784});
 
     Number::setround(Number::towards_zero);
     res2 = STAmount{issue, n.mantissa(), n.exponent()};
-    CHECK(res2 == STAmount{7518783});
+    CHECK_EQ(res2, STAmount{7518783});
 
     Number::setround(Number::downward);
     res2 = STAmount{issue, n.mantissa(), n.exponent()};
-    CHECK(res2 == STAmount{7518783});
+    CHECK_EQ(res2, STAmount{7518783});
 
     Number::setround(Number::upward);
     res2 = STAmount{issue, n.mantissa(), n.exponent()};
-    CHECK(res2 == STAmount{7518784});
+    CHECK_EQ(res2, STAmount{7518784});
 }
 
 TEST_CASE("truncate")
 {
-    CHECK(Number(25, +1).truncate() == Number(250, 0));
-    CHECK(Number(25, 0).truncate() == Number(25, 0));
-    CHECK(Number(25, -1).truncate() == Number(2, 0));
-    CHECK(Number(25, -2).truncate() == Number(0, 0));
-    CHECK(Number(99, -2).truncate() == Number(0, 0));
+    CHECK_EQ(Number(25, +1).truncate(), Number(250, 0));
+    CHECK_EQ(Number(25, 0).truncate(), Number(25, 0));
+    CHECK_EQ(Number(25, -1).truncate(), Number(2, 0));
+    CHECK_EQ(Number(25, -2).truncate(), Number(0, 0));
+    CHECK_EQ(Number(99, -2).truncate(), Number(0, 0));
 
-    CHECK(Number(-25, +1).truncate() == Number(-250, 0));
-    CHECK(Number(-25, 0).truncate() == Number(-25, 0));
-    CHECK(Number(-25, -1).truncate() == Number(-2, 0));
-    CHECK(Number(-25, -2).truncate() == Number(0, 0));
-    CHECK(Number(-99, -2).truncate() == Number(0, 0));
+    CHECK_EQ(Number(-25, +1).truncate(), Number(-250, 0));
+    CHECK_EQ(Number(-25, 0).truncate(), Number(-25, 0));
+    CHECK_EQ(Number(-25, -1).truncate(), Number(-2, 0));
+    CHECK_EQ(Number(-25, -2).truncate(), Number(0, 0));
+    CHECK_EQ(Number(-99, -2).truncate(), Number(0, 0));
 
-    CHECK(Number(0, 0).truncate() == Number(0, 0));
-    CHECK(Number(0, 30000).truncate() == Number(0, 0));
-    CHECK(Number(0, -30000).truncate() == Number(0, 0));
-    CHECK(Number(100, -30000).truncate() == Number(0, 0));
-    CHECK(Number(100, -30000).truncate() == Number(0, 0));
-    CHECK(Number(-100, -30000).truncate() == Number(0, 0));
-    CHECK(Number(-100, -30000).truncate() == Number(0, 0));
+    CHECK_EQ(Number(0, 0).truncate(), Number(0, 0));
+    CHECK_EQ(Number(0, 30000).truncate(), Number(0, 0));
+    CHECK_EQ(Number(0, -30000).truncate(), Number(0, 0));
+    CHECK_EQ(Number(100, -30000).truncate(), Number(0, 0));
+    CHECK_EQ(Number(100, -30000).truncate(), Number(0, 0));
+    CHECK_EQ(Number(-100, -30000).truncate(), Number(0, 0));
+    CHECK_EQ(Number(-100, -30000).truncate(), Number(0, 0));
 }
 
 TEST_SUITE_END();

src/doctest/basics/StringUtilities.cpp

@@ -11,15 +11,15 @@ void
 testUnHexSuccess(std::string const& strIn, std::string const& strExpected)
 {
     auto rv = strUnHex(strIn);
-    CHECK(rv);
-    CHECK(makeSlice(*rv) == makeSlice(strExpected));
+    CHECK_UNARY(rv);
+    CHECK_EQ(makeSlice(*rv), makeSlice(strExpected));
 }
 
 void
 testUnHexFailure(std::string const& strIn)
 {
     auto rv = strUnHex(strIn);
-    CHECK(!rv);
+    CHECK_FALSE(rv);
 }
 }  // namespace
 
@@ -46,239 +46,240 @@ TEST_CASE("parseUrl")
     // Expected passes.
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain.empty());
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path.empty());
+        CHECK_UNARY(parseUrl(pUrl, "scheme://"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_UNARY(pUrl.domain.empty());
+        CHECK_FALSE(pUrl.port);
+        CHECK_UNARY(pUrl.path.empty());
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme:///"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain.empty());
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/");
+        CHECK_UNARY(parseUrl(pUrl, "scheme:///"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_UNARY(pUrl.domain.empty());
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "lower://domain"));
-        CHECK(pUrl.scheme == "lower");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == "domain");
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path.empty());
+        CHECK_UNARY(parseUrl(pUrl, "lower://domain"));
+        CHECK_EQ(pUrl.scheme, "lower");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_FALSE(pUrl.port);
+        CHECK_UNARY(pUrl.path.empty());
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "UPPER://domain:234/"));
-        CHECK(pUrl.scheme == "upper");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == "domain");
-        CHECK(*pUrl.port == 234);
-        CHECK(pUrl.path == "/");
+        CHECK_UNARY(parseUrl(pUrl, "UPPER://domain:234/"));
+        CHECK_EQ(pUrl.scheme, "upper");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_EQ(*pUrl.port, 234);
+        CHECK_EQ(pUrl.path, "/");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "Mixed://domain/path"));
-        CHECK(pUrl.scheme == "mixed");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == "domain");
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/path");
+        CHECK_UNARY(parseUrl(pUrl, "Mixed://domain/path"));
+        CHECK_EQ(pUrl.scheme, "mixed");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/path");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://[::1]:123/path"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == "::1");
-        CHECK(*pUrl.port == 123);
-        CHECK(pUrl.path == "/path");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://[::1]:123/path"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, "::1");
+        CHECK_EQ(*pUrl.port, 123);
+        CHECK_EQ(pUrl.path, "/path");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://user:pass@domain:123/abc:321"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username == "user");
-        CHECK(pUrl.password == "pass");
-        CHECK(pUrl.domain == "domain");
-        CHECK(*pUrl.port == 123);
-        CHECK(pUrl.path == "/abc:321");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://user:pass@domain:123/abc:321"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_EQ(pUrl.username, "user");
+        CHECK_EQ(pUrl.password, "pass");
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_EQ(*pUrl.port, 123);
+        CHECK_EQ(pUrl.path, "/abc:321");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://user@domain:123/abc:321"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username == "user");
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == "domain");
-        CHECK(*pUrl.port == 123);
-        CHECK(pUrl.path == "/abc:321");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://user@domain:123/abc:321"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_EQ(pUrl.username, "user");
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_EQ(*pUrl.port, 123);
+        CHECK_EQ(pUrl.path, "/abc:321");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://:pass@domain:123/abc:321"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password == "pass");
-        CHECK(pUrl.domain == "domain");
-        CHECK(*pUrl.port == 123);
-        CHECK(pUrl.path == "/abc:321");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://:pass@domain:123/abc:321"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_EQ(pUrl.password, "pass");
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_EQ(*pUrl.port, 123);
+        CHECK_EQ(pUrl.path, "/abc:321");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://domain:123/abc:321"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == "domain");
-        CHECK(*pUrl.port == 123);
-        CHECK(pUrl.path == "/abc:321");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://domain:123/abc:321"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_EQ(*pUrl.port, 123);
+        CHECK_EQ(pUrl.path, "/abc:321");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://user:pass@domain/abc:321"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username == "user");
-        CHECK(pUrl.password == "pass");
-        CHECK(pUrl.domain == "domain");
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/abc:321");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://user:pass@domain/abc:321"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_EQ(pUrl.username, "user");
+        CHECK_EQ(pUrl.password, "pass");
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/abc:321");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://user@domain/abc:321"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username == "user");
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == "domain");
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/abc:321");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://user@domain/abc:321"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_EQ(pUrl.username, "user");
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/abc:321");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://:pass@domain/abc:321"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password == "pass");
-        CHECK(pUrl.domain == "domain");
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/abc:321");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://:pass@domain/abc:321"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_EQ(pUrl.password, "pass");
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/abc:321");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://domain/abc:321"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == "domain");
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/abc:321");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://domain/abc:321"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/abc:321");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme:///path/to/file"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain.empty());
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/path/to/file");
+        CHECK_UNARY(parseUrl(pUrl, "scheme:///path/to/file"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_UNARY(pUrl.domain.empty());
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/path/to/file");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://user:pass@domain/path/with/an@sign"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username == "user");
-        CHECK(pUrl.password == "pass");
-        CHECK(pUrl.domain == "domain");
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/path/with/an@sign");
+        CHECK_UNARY(
+            parseUrl(pUrl, "scheme://user:pass@domain/path/with/an@sign"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_EQ(pUrl.username, "user");
+        CHECK_EQ(pUrl.password, "pass");
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/path/with/an@sign");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://domain/path/with/an@sign"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == "domain");
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/path/with/an@sign");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://domain/path/with/an@sign"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, "domain");
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/path/with/an@sign");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "scheme://:999/"));
-        CHECK(pUrl.scheme == "scheme");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == ":999");
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/");
+        CHECK_UNARY(parseUrl(pUrl, "scheme://:999/"));
+        CHECK_EQ(pUrl.scheme, "scheme");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, ":999");
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/");
     }
 
     {
         parsedURL pUrl;
-        CHECK(parseUrl(pUrl, "http://::1:1234/validators"));
-        CHECK(pUrl.scheme == "http");
-        CHECK(pUrl.username.empty());
-        CHECK(pUrl.password.empty());
-        CHECK(pUrl.domain == "::0.1.18.52");
-        CHECK(!pUrl.port);
-        CHECK(pUrl.path == "/validators");
+        CHECK_UNARY(parseUrl(pUrl, "http://::1:1234/validators"));
+        CHECK_EQ(pUrl.scheme, "http");
+        CHECK_UNARY(pUrl.username.empty());
+        CHECK_UNARY(pUrl.password.empty());
+        CHECK_EQ(pUrl.domain, "::0.1.18.52");
+        CHECK_FALSE(pUrl.port);
+        CHECK_EQ(pUrl.path, "/validators");
     }
 
     // Expected fails.
     {
         parsedURL pUrl;
-        CHECK(!parseUrl(pUrl, ""));
-        CHECK(!parseUrl(pUrl, "nonsense"));
-        CHECK(!parseUrl(pUrl, "://"));
-        CHECK(!parseUrl(pUrl, ":///"));
-        CHECK(!parseUrl(pUrl, "scheme://user:pass@domain:65536/abc:321"));
-        CHECK(!parseUrl(pUrl, "UPPER://domain:23498765/"));
-        CHECK(!parseUrl(pUrl, "UPPER://domain:0/"));
-        CHECK(!parseUrl(pUrl, "UPPER://domain:+7/"));
-        CHECK(!parseUrl(pUrl, "UPPER://domain:-7234/"));
-        CHECK(!parseUrl(pUrl, "UPPER://domain:@#$56!/"));
+        CHECK_FALSE(parseUrl(pUrl, ""));
+        CHECK_FALSE(parseUrl(pUrl, "nonsense"));
+        CHECK_FALSE(parseUrl(pUrl, "://"));
+        CHECK_FALSE(parseUrl(pUrl, ":///"));
+        CHECK_FALSE(parseUrl(pUrl, "scheme://user:pass@domain:65536/abc:321"));
+        CHECK_FALSE(parseUrl(pUrl, "UPPER://domain:23498765/"));
+        CHECK_FALSE(parseUrl(pUrl, "UPPER://domain:0/"));
+        CHECK_FALSE(parseUrl(pUrl, "UPPER://domain:+7/"));
+        CHECK_FALSE(parseUrl(pUrl, "UPPER://domain:-7234/"));
+        CHECK_FALSE(parseUrl(pUrl, "UPPER://domain:@#$56!/"));
     }
 
     {
         std::string strUrl("s://" + std::string(8192, ':'));
         parsedURL pUrl;
-        CHECK(!parseUrl(pUrl, strUrl));
+        CHECK_FALSE(parseUrl(pUrl, strUrl));
     }
 }
 
 TEST_CASE("toString")
 {
     auto result = to_string("hello");
-    CHECK(result == "hello");
+    CHECK_EQ(result, "hello");
 }
 
 TEST_SUITE_END();

src/doctest/basics/TaggedCache.cpp

@@ -26,93 +26,93 @@ TEST_CASE("TaggedCache operations")
 
     SUBCASE("Insert, retrieve, and age item")
     {
-        CHECK(c.getCacheSize() == 0);
-        CHECK(c.getTrackSize() == 0);
-        CHECK(!c.insert(1, "one"));
-        CHECK(c.getCacheSize() == 1);
-        CHECK(c.getTrackSize() == 1);
+        CHECK_EQ(c.getCacheSize(), 0);
+        CHECK_EQ(c.getTrackSize(), 0);
+        CHECK_FALSE(c.insert(1, "one"));
+        CHECK_EQ(c.getCacheSize(), 1);
+        CHECK_EQ(c.getTrackSize(), 1);
 
         {
             std::string s;
-            CHECK(c.retrieve(1, s));
-            CHECK(s == "one");
+            CHECK_UNARY(c.retrieve(1, s));
+            CHECK_EQ(s, "one");
         }
 
         ++clock;
         c.sweep();
-        CHECK(c.getCacheSize() == 0);
-        CHECK(c.getTrackSize() == 0);
+        CHECK_EQ(c.getCacheSize(), 0);
+        CHECK_EQ(c.getTrackSize(), 0);
     }
 
     SUBCASE("Insert item, maintain strong pointer, age it")
     {
-        CHECK(!c.insert(2, "two"));
-        CHECK(c.getCacheSize() == 1);
-        CHECK(c.getTrackSize() == 1);
+        CHECK_FALSE(c.insert(2, "two"));
+        CHECK_EQ(c.getCacheSize(), 1);
+        CHECK_EQ(c.getTrackSize(), 1);
 
         {
             auto p = c.fetch(2);
-            CHECK(p != nullptr);
+            CHECK_NE(p, nullptr);
             ++clock;
             c.sweep();
-            CHECK(c.getCacheSize() == 0);
-            CHECK(c.getTrackSize() == 1);
+            CHECK_EQ(c.getCacheSize(), 0);
+            CHECK_EQ(c.getTrackSize(), 1);
         }
 
         // Make sure its gone now that our reference is gone
         ++clock;
         c.sweep();
-        CHECK(c.getCacheSize() == 0);
-        CHECK(c.getTrackSize() == 0);
+        CHECK_EQ(c.getCacheSize(), 0);
+        CHECK_EQ(c.getTrackSize(), 0);
     }
 
     SUBCASE("Insert same key/value pair and canonicalize")
     {
-        CHECK(!c.insert(3, "three"));
+        CHECK_FALSE(c.insert(3, "three"));
 
         {
             auto const p1 = c.fetch(3);
             auto p2 = std::make_shared<Value>("three");
             c.canonicalize_replace_client(3, p2);
-            CHECK(p1.get() == p2.get());
+            CHECK_EQ(p1.get(), p2.get());
         }
         ++clock;
         c.sweep();
-        CHECK(c.getCacheSize() == 0);
-        CHECK(c.getTrackSize() == 0);
+        CHECK_EQ(c.getCacheSize(), 0);
+        CHECK_EQ(c.getTrackSize(), 0);
     }
 
     SUBCASE("Put object, keep strong pointer, advance clock, canonicalize")
     {
         // Put an object in
-        CHECK(!c.insert(4, "four"));
-        CHECK(c.getCacheSize() == 1);
-        CHECK(c.getTrackSize() == 1);
+        CHECK_FALSE(c.insert(4, "four"));
+        CHECK_EQ(c.getCacheSize(), 1);
+        CHECK_EQ(c.getTrackSize(), 1);
 
         {
             // Keep a strong pointer to it
             auto const p1 = c.fetch(4);
-            CHECK(p1 != nullptr);
-            CHECK(c.getCacheSize() == 1);
-            CHECK(c.getTrackSize() == 1);
+            CHECK_NE(p1, nullptr);
+            CHECK_EQ(c.getCacheSize(), 1);
+            CHECK_EQ(c.getTrackSize(), 1);
             // Advance the clock a lot
             ++clock;
             c.sweep();
-            CHECK(c.getCacheSize() == 0);
-            CHECK(c.getTrackSize() == 1);
+            CHECK_EQ(c.getCacheSize(), 0);
+            CHECK_EQ(c.getTrackSize(), 1);
             // Canonicalize a new object with the same key
             auto p2 = std::make_shared<std::string>("four");
-            CHECK(c.canonicalize_replace_client(4, p2));
-            CHECK(c.getCacheSize() == 1);
-            CHECK(c.getTrackSize() == 1);
+            CHECK_UNARY(c.canonicalize_replace_client(4, p2));
+            CHECK_EQ(c.getCacheSize(), 1);
+            CHECK_EQ(c.getTrackSize(), 1);
             // Make sure we get the original object
-            CHECK(p1.get() == p2.get());
+            CHECK_EQ(p1.get(), p2.get());
         }
 
         ++clock;
         c.sweep();
-        CHECK(c.getCacheSize() == 0);
-        CHECK(c.getTrackSize() == 0);
+        CHECK_EQ(c.getCacheSize(), 0);
+        CHECK_EQ(c.getTrackSize(), 0);
     }
 }
 

src/doctest/basics/Units.cpp

@@ -9,8 +9,8 @@ TEST_SUITE_BEGIN("Units");
 
 TEST_CASE("Initial XRP")
 {
-    CHECK(INITIAL_XRP.drops() == 100'000'000'000'000'000);
-    CHECK(INITIAL_XRP == XRPAmount{100'000'000'000'000'000});
+    CHECK_EQ(INITIAL_XRP.drops(), 100'000'000'000'000'000);
+    CHECK_EQ(INITIAL_XRP, XRPAmount{100'000'000'000'000'000});
 }
 
 TEST_CASE("Types")
@@ -20,14 +20,14 @@ TEST_CASE("Types")
     SUBCASE("XRPAmount with uint32 FeeLevel")
     {
         XRPAmount x{100};
-        CHECK(x.drops() == 100);
+        CHECK_EQ(x.drops(), 100);
         CHECK((std::is_same_v<decltype(x)::unit_type, unit::dropTag>));
         auto y = 4u * x;
-        CHECK(y.value() == 400);
+        CHECK_EQ(y.value(), 400);
         CHECK((std::is_same_v<decltype(y)::unit_type, unit::dropTag>));
 
         auto z = 4 * y;
-        CHECK(z.value() == 1600);
+        CHECK_EQ(z.value(), 1600);
         CHECK((std::is_same_v<decltype(z)::unit_type, unit::dropTag>));
 
         FeeLevel32 f{10};
@@ -35,8 +35,8 @@ TEST_CASE("Types")
 
         auto drops = mulDiv(baseFee, x, f);
 
-        CHECK(drops);
-        CHECK(drops.value() == 1000);
+        CHECK_UNARY(drops);
+        CHECK_EQ(drops.value(), 1000);
         CHECK((std::is_same_v<
                std::remove_reference_t<decltype(*drops)>::unit_type,
                unit::dropTag>));
@@ -49,10 +49,10 @@ TEST_CASE("Types")
     SUBCASE("XRPAmount with uint64 FeeLevel")
     {
         XRPAmount x{100};
-        CHECK(x.value() == 100);
+        CHECK_EQ(x.value(), 100);
         CHECK((std::is_same_v<decltype(x)::unit_type, unit::dropTag>));
         auto y = 4u * x;
-        CHECK(y.value() == 400);
+        CHECK_EQ(y.value(), 400);
         CHECK((std::is_same_v<decltype(y)::unit_type, unit::dropTag>));
 
         FeeLevel64 f{10};
@@ -60,8 +60,8 @@ TEST_CASE("Types")
 
         auto drops = mulDiv(baseFee, x, f);
 
-        CHECK(drops);
-        CHECK(drops.value() == 1000);
+        CHECK_UNARY(drops);
+        CHECK_EQ(drops.value(), 1000);
         CHECK((std::is_same_v<
                std::remove_reference_t<decltype(*drops)>::unit_type,
                unit::dropTag>));
@@ -73,11 +73,11 @@ TEST_CASE("Types")
     SUBCASE("FeeLevel64 operations")
     {
         FeeLevel64 x{1024};
-        CHECK(x.value() == 1024);
+        CHECK_EQ(x.value(), 1024);
         CHECK((std::is_same_v<decltype(x)::unit_type, unit::feelevelTag>));
         std::uint64_t m = 4;
         auto y = m * x;
-        CHECK(y.value() == 4096);
+        CHECK_EQ(y.value(), 4096);
         CHECK((std::is_same_v<decltype(y)::unit_type, unit::feelevelTag>));
 
         XRPAmount basefee{10};
@@ -85,8 +85,8 @@ TEST_CASE("Types")
 
         auto drops = mulDiv(x, basefee, referencefee);
 
-        CHECK(drops);
-        CHECK(drops.value() == 40);
+        CHECK_UNARY(drops);
+        CHECK_EQ(drops.value(), 40);
         CHECK((std::is_same_v<
                std::remove_reference_t<decltype(*drops)>::unit_type,
                unit::dropTag>));
@@ -104,64 +104,64 @@ TEST_CASE("Json")
     {
         FeeLevel32 x{std::numeric_limits<std::uint32_t>::max()};
         auto y = x.jsonClipped();
-        CHECK(y.type() == Json::uintValue);
-        CHECK(y == Json::Value{x.fee()});
+        CHECK_EQ(y.type(), Json::uintValue);
+        CHECK_EQ(y, Json::Value{x.fee()});
     }
 
     SUBCASE("FeeLevel32 min")
     {
         FeeLevel32 x{std::numeric_limits<std::uint32_t>::min()};
         auto y = x.jsonClipped();
-        CHECK(y.type() == Json::uintValue);
-        CHECK(y == Json::Value{x.fee()});
+        CHECK_EQ(y.type(), Json::uintValue);
+        CHECK_EQ(y, Json::Value{x.fee()});
     }
 
     SUBCASE("FeeLevel64 max")
     {
         FeeLevel64 x{std::numeric_limits<std::uint64_t>::max()};
         auto y = x.jsonClipped();
-        CHECK(y.type() == Json::uintValue);
-        CHECK(y == Json::Value{std::numeric_limits<std::uint32_t>::max()});
+        CHECK_EQ(y.type(), Json::uintValue);
+        CHECK_EQ(y, Json::Value{std::numeric_limits<std::uint32_t>::max()});
     }
 
     SUBCASE("FeeLevel64 min")
     {
         FeeLevel64 x{std::numeric_limits<std::uint64_t>::min()};
         auto y = x.jsonClipped();
-        CHECK(y.type() == Json::uintValue);
-        CHECK(y == Json::Value{0});
+        CHECK_EQ(y.type(), Json::uintValue);
+        CHECK_EQ(y, Json::Value{0});
     }
 
     SUBCASE("FeeLevelDouble max")
     {
         FeeLevelDouble x{std::numeric_limits<double>::max()};
         auto y = x.jsonClipped();
-        CHECK(y.type() == Json::realValue);
-        CHECK(y == Json::Value{std::numeric_limits<double>::max()});
+        CHECK_EQ(y.type(), Json::realValue);
+        CHECK_EQ(y, Json::Value{std::numeric_limits<double>::max()});
     }
 
     SUBCASE("FeeLevelDouble min")
     {
         FeeLevelDouble x{std::numeric_limits<double>::min()};
         auto y = x.jsonClipped();
-        CHECK(y.type() == Json::realValue);
-        CHECK(y == Json::Value{std::numeric_limits<double>::min()});
+        CHECK_EQ(y.type(), Json::realValue);
+        CHECK_EQ(y, Json::Value{std::numeric_limits<double>::min()});
     }
 
     SUBCASE("XRPAmount max")
     {
         XRPAmount x{std::numeric_limits<std::int64_t>::max()};
         auto y = x.jsonClipped();
-        CHECK(y.type() == Json::intValue);
-        CHECK(y == Json::Value{std::numeric_limits<std::int32_t>::max()});
+        CHECK_EQ(y.type(), Json::intValue);
+        CHECK_EQ(y, Json::Value{std::numeric_limits<std::int32_t>::max()});
     }
 
     SUBCASE("XRPAmount min")
     {
         XRPAmount x{std::numeric_limits<std::int64_t>::min()};
         auto y = x.jsonClipped();
-        CHECK(y.type() == Json::intValue);
-        CHECK(y == Json::Value{std::numeric_limits<std::int32_t>::min()});
+        CHECK_EQ(y.type(), Json::intValue);
+        CHECK_EQ(y, Json::Value{std::numeric_limits<std::int32_t>::min()});
     }
 }
 
@@ -176,75 +176,75 @@ TEST_CASE("Functions")
 
         [[maybe_unused]] FeeLevel64 defaulted;
         FeeLevel64 test{0};
-        CHECK(test.fee() == 0);
+        CHECK_EQ(test.fee(), 0);
 
         test = explicitmake(beast::zero);
-        CHECK(test.fee() == 0);
+        CHECK_EQ(test.fee(), 0);
 
         test = beast::zero;
-        CHECK(test.fee() == 0);
+        CHECK_EQ(test.fee(), 0);
 
         test = explicitmake(100u);
-        CHECK(test.fee() == 100);
+        CHECK_EQ(test.fee(), 100);
 
         FeeLevel64 const targetSame{200u};
         FeeLevel32 const targetOther{300u};
         test = make(targetSame);
-        CHECK(test.fee() == 200);
-        CHECK(test == targetSame);
-        CHECK(test < FeeLevel64{1000});
-        CHECK(test > FeeLevel64{100});
+        CHECK_EQ(test.fee(), 200);
+        CHECK_EQ(test, targetSame);
+        CHECK_LT(test, FeeLevel64{1000});
+        CHECK_GT(test, FeeLevel64{100});
         test = make(targetOther);
-        CHECK(test.fee() == 300);
-        CHECK(test == targetOther);
+        CHECK_EQ(test.fee(), 300);
+        CHECK_EQ(test, targetOther);
 
         test = std::uint64_t(200);
-        CHECK(test.fee() == 200);
+        CHECK_EQ(test.fee(), 200);
         test = std::uint32_t(300);
-        CHECK(test.fee() == 300);
+        CHECK_EQ(test.fee(), 300);
 
         test = targetSame;
-        CHECK(test.fee() == 200);
+        CHECK_EQ(test.fee(), 200);
         test = targetOther.fee();
-        CHECK(test.fee() == 300);
-        CHECK(test == targetOther);
+        CHECK_EQ(test.fee(), 300);
+        CHECK_EQ(test, targetOther);
 
         test = targetSame * 2;
-        CHECK(test.fee() == 400);
+        CHECK_EQ(test.fee(), 400);
         test = 3 * targetSame;
-        CHECK(test.fee() == 600);
+        CHECK_EQ(test.fee(), 600);
         test = targetSame / 10;
-        CHECK(test.fee() == 20);
+        CHECK_EQ(test.fee(), 20);
 
         test += targetSame;
-        CHECK(test.fee() == 220);
+        CHECK_EQ(test.fee(), 220);
 
         test -= targetSame;
-        CHECK(test.fee() == 20);
+        CHECK_EQ(test.fee(), 20);
 
         test++;
-        CHECK(test.fee() == 21);
+        CHECK_EQ(test.fee(), 21);
         ++test;
-        CHECK(test.fee() == 22);
+        CHECK_EQ(test.fee(), 22);
         test--;
-        CHECK(test.fee() == 21);
+        CHECK_EQ(test.fee(), 21);
         --test;
-        CHECK(test.fee() == 20);
+        CHECK_EQ(test.fee(), 20);
 
         test *= 5;
-        CHECK(test.fee() == 100);
+        CHECK_EQ(test.fee(), 100);
         test /= 2;
-        CHECK(test.fee() == 50);
+        CHECK_EQ(test.fee(), 50);
         test %= 13;
-        CHECK(test.fee() == 11);
+        CHECK_EQ(test.fee(), 11);
 
-        CHECK(test);
+        CHECK_UNARY(test);
         test = 0;
-        CHECK(!test);
-        CHECK(test.signum() == 0);
+        CHECK_FALSE(test);
+        CHECK_EQ(test.signum(), 0);
         test = targetSame;
-        CHECK(test.signum() == 1);
-        CHECK(to_string(test) == "200");
+        CHECK_EQ(test.signum(), 1);
+        CHECK_EQ(to_string(test), "200");
     }
 
     SUBCASE("FeeLevelDouble functions")
@@ -256,76 +256,76 @@ TEST_CASE("Functions")
 
         [[maybe_unused]] FeeLevelDouble defaulted;
         FeeLevelDouble test{0};
-        CHECK(test.fee() == 0);
+        CHECK_EQ(test.fee(), 0);
 
         test = explicitmake(beast::zero);
-        CHECK(test.fee() == 0);
+        CHECK_EQ(test.fee(), 0);
 
         test = beast::zero;
-        CHECK(test.fee() == 0);
+        CHECK_EQ(test.fee(), 0);
 
         test = explicitmake(100.0);
-        CHECK(test.fee() == 100);
+        CHECK_EQ(test.fee(), 100);
 
         FeeLevelDouble const targetSame{200.0};
         FeeLevel64 const targetOther{300};
         test = make(targetSame);
-        CHECK(test.fee() == 200);
-        CHECK(test == targetSame);
-        CHECK(test < FeeLevelDouble{1000.0});
-        CHECK(test > FeeLevelDouble{100.0});
+        CHECK_EQ(test.fee(), 200);
+        CHECK_EQ(test, targetSame);
+        CHECK_LT(test, FeeLevelDouble{1000.0});
+        CHECK_GT(test, FeeLevelDouble{100.0});
         test = targetOther.fee();
-        CHECK(test.fee() == 300);
-        CHECK(test == targetOther);
+        CHECK_EQ(test.fee(), 300);
+        CHECK_EQ(test, targetOther);
 
         test = 200.0;
-        CHECK(test.fee() == 200);
+        CHECK_EQ(test.fee(), 200);
         test = std::uint64_t(300);
-        CHECK(test.fee() == 300);
+        CHECK_EQ(test.fee(), 300);
 
         test = targetSame;
-        CHECK(test.fee() == 200);
+        CHECK_EQ(test.fee(), 200);
 
         test = targetSame * 2;
-        CHECK(test.fee() == 400);
+        CHECK_EQ(test.fee(), 400);
         test = 3 * targetSame;
-        CHECK(test.fee() == 600);
+        CHECK_EQ(test.fee(), 600);
         test = targetSame / 10;
-        CHECK(test.fee() == 20);
+        CHECK_EQ(test.fee(), 20);
 
         test += targetSame;
-        CHECK(test.fee() == 220);
+        CHECK_EQ(test.fee(), 220);
 
         test -= targetSame;
-        CHECK(test.fee() == 20);
+        CHECK_EQ(test.fee(), 20);
 
         test++;
-        CHECK(test.fee() == 21);
+        CHECK_EQ(test.fee(), 21);
         ++test;
-        CHECK(test.fee() == 22);
+        CHECK_EQ(test.fee(), 22);
         test--;
-        CHECK(test.fee() == 21);
+        CHECK_EQ(test.fee(), 21);
         --test;
-        CHECK(test.fee() == 20);
+        CHECK_EQ(test.fee(), 20);
 
         test *= 5;
-        CHECK(test.fee() == 100);
+        CHECK_EQ(test.fee(), 100);
         test /= 2;
-        CHECK(test.fee() == 50);
+        CHECK_EQ(test.fee(), 50);
 
         // legal with signed
         test = -test;
-        CHECK(test.fee() == -50);
-        CHECK(test.signum() == -1);
-        CHECK(to_string(test) == "-50.000000");
+        CHECK_EQ(test.fee(), -50);
+        CHECK_EQ(test.signum(), -1);
+        CHECK_EQ(to_string(test), "-50.000000");
 
-        CHECK(test);
+        CHECK_UNARY(test);
         test = 0;
-        CHECK(!test);
-        CHECK(test.signum() == 0);
+        CHECK_FALSE(test);
+        CHECK_EQ(test.signum(), 0);
         test = targetSame;
-        CHECK(test.signum() == 1);
-        CHECK(to_string(test) == "200.000000");
+        CHECK_EQ(test.signum(), 1);
+        CHECK_EQ(to_string(test), "200.000000");
     }
 }
 

src/doctest/basics/XRPAmount.cpp

@@ -13,11 +13,11 @@ TEST_CASE("signum")
         XRPAmount const x(i);
 
         if (i < 0)
-            CHECK(x.signum() < 0);
+            CHECK_LT(x.signum(), 0);
         else if (i > 0)
-            CHECK(x.signum() > 0);
+            CHECK_GT(x.signum(), 0);
         else
-            CHECK(x.signum() == 0);
+            CHECK_EQ(x.signum(), 0);
     }
 }
 
@@ -29,19 +29,19 @@ TEST_CASE("beast::Zero Comparisons")
     {
         XRPAmount const x(i);
 
-        CHECK((i == 0) == (x == zero));
-        CHECK((i != 0) == (x != zero));
-        CHECK((i < 0) == (x < zero));
-        CHECK((i > 0) == (x > zero));
-        CHECK((i <= 0) == (x <= zero));
-        CHECK((i >= 0) == (x >= zero));
+        CHECK_EQ((i == 0), (x == zero));
+        CHECK_EQ((i != 0), (x != zero));
+        CHECK_EQ((i < 0), (x < zero));
+        CHECK_EQ((i > 0), (x > zero));
+        CHECK_EQ((i <= 0), (x <= zero));
+        CHECK_EQ((i >= 0), (x >= zero));
 
-        CHECK((0 == i) == (zero == x));
-        CHECK((0 != i) == (zero != x));
-        CHECK((0 < i) == (zero < x));
-        CHECK((0 > i) == (zero > x));
-        CHECK((0 <= i) == (zero <= x));
-        CHECK((0 >= i) == (zero >= x));
+        CHECK_EQ((0 == i), (zero == x));
+        CHECK_EQ((0 != i), (zero != x));
+        CHECK_EQ((0 < i), (zero < x));
+        CHECK_EQ((0 > i), (zero > x));
+        CHECK_EQ((0 <= i), (zero <= x));
+        CHECK_EQ((0 >= i), (zero >= x));
     }
 }
 
@@ -55,12 +55,12 @@ TEST_CASE("XRP Comparisons")
         {
             XRPAmount const y(j);
 
-            CHECK((i == j) == (x == y));
-            CHECK((i != j) == (x != y));
-            CHECK((i < j) == (x < y));
-            CHECK((i > j) == (x > y));
-            CHECK((i <= j) == (x <= y));
-            CHECK((i >= j) == (x >= y));
+            CHECK_EQ((i == j), (x == y));
+            CHECK_EQ((i != j), (x != y));
+            CHECK_EQ((i < j), (x < y));
+            CHECK_EQ((i > j), (x > y));
+            CHECK_EQ((i <= j), (x <= y));
+            CHECK_EQ((i >= j), (x >= y));
         }
     }
 }
@@ -75,10 +75,10 @@ TEST_CASE("Addition & Subtraction")
         {
             XRPAmount const y(j);
 
-            CHECK(XRPAmount(i + j) == (x + y));
-            CHECK(XRPAmount(i - j) == (x - y));
+            CHECK_EQ(XRPAmount(i + j), (x + y));
+            CHECK_EQ(XRPAmount(i - j), (x - y));
 
-            CHECK((x + y) == (y + x));  // addition is commutative
+            CHECK_EQ((x + y), (y + x));  // addition is commutative
         }
     }
 }
@@ -86,19 +86,19 @@ TEST_CASE("Addition & Subtraction")
 TEST_CASE("decimalXRP")
 {
     // Tautology
-    CHECK(DROPS_PER_XRP.decimalXRP() == 1);
+    CHECK_EQ(DROPS_PER_XRP.decimalXRP(), 1);
 
     XRPAmount test{1};
-    CHECK(test.decimalXRP() == 0.000001);
+    CHECK_EQ(test.decimalXRP(), 0.000001);
 
     test = -test;
-    CHECK(test.decimalXRP() == -0.000001);
+    CHECK_EQ(test.decimalXRP(), -0.000001);
 
     test = 100'000'000;
-    CHECK(test.decimalXRP() == 100);
+    CHECK_EQ(test.decimalXRP(), 100);
 
     test = -test;
-    CHECK(test.decimalXRP() == -100);
+    CHECK_EQ(test.decimalXRP(), -100);
 }
 
 TEST_CASE("functions")
@@ -110,77 +110,77 @@ TEST_CASE("functions")
     XRPAmount defaulted;
     (void)defaulted;
     XRPAmount test{0};
-    CHECK(test.drops() == 0);
+    CHECK_EQ(test.drops(), 0);
 
     test = make(beast::zero);
-    CHECK(test.drops() == 0);
+    CHECK_EQ(test.drops(), 0);
 
     test = beast::zero;
-    CHECK(test.drops() == 0);
+    CHECK_EQ(test.drops(), 0);
 
     test = make(100);
-    CHECK(test.drops() == 100);
+    CHECK_EQ(test.drops(), 100);
 
     test = make(100u);
-    CHECK(test.drops() == 100);
+    CHECK_EQ(test.drops(), 100);
 
     XRPAmount const targetSame{200u};
     test = make(targetSame);
-    CHECK(test.drops() == 200);
-    CHECK(test == targetSame);
-    CHECK(test < XRPAmount{1000});
-    CHECK(test > XRPAmount{100});
+    CHECK_EQ(test.drops(), 200);
+    CHECK_EQ(test, targetSame);
+    CHECK_LT(test, XRPAmount{1000});
+    CHECK_GT(test, XRPAmount{100});
 
     test = std::int64_t(200);
-    CHECK(test.drops() == 200);
+    CHECK_EQ(test.drops(), 200);
     test = std::uint32_t(300);
-    CHECK(test.drops() == 300);
+    CHECK_EQ(test.drops(), 300);
 
     test = targetSame;
-    CHECK(test.drops() == 200);
+    CHECK_EQ(test.drops(), 200);
     auto testOther = test.dropsAs<std::uint32_t>();
-    CHECK(testOther);
-    CHECK(*testOther == 200);
+    CHECK_UNARY(testOther);
+    CHECK_EQ(*testOther, 200);
     test = std::numeric_limits<std::uint64_t>::max();
     testOther = test.dropsAs<std::uint32_t>();
-    CHECK(!testOther);
+    CHECK_FALSE(testOther);
     test = -1;
     testOther = test.dropsAs<std::uint32_t>();
-    CHECK(!testOther);
+    CHECK_FALSE(testOther);
 
     test = targetSame * 2;
-    CHECK(test.drops() == 400);
+    CHECK_EQ(test.drops(), 400);
     test = 3 * targetSame;
-    CHECK(test.drops() == 600);
+    CHECK_EQ(test.drops(), 600);
     test = 20;
-    CHECK(test.drops() == 20);
+    CHECK_EQ(test.drops(), 20);
 
     test += targetSame;
-    CHECK(test.drops() == 220);
+    CHECK_EQ(test.drops(), 220);
 
     test -= targetSame;
-    CHECK(test.drops() == 20);
+    CHECK_EQ(test.drops(), 20);
 
     test *= 5;
-    CHECK(test.drops() == 100);
+    CHECK_EQ(test.drops(), 100);
     test = 50;
-    CHECK(test.drops() == 50);
+    CHECK_EQ(test.drops(), 50);
     test -= 39;
-    CHECK(test.drops() == 11);
+    CHECK_EQ(test.drops(), 11);
 
     // legal with signed
     test = -test;
-    CHECK(test.drops() == -11);
-    CHECK(test.signum() == -1);
-    CHECK(to_string(test) == "-11");
+    CHECK_EQ(test.drops(), -11);
+    CHECK_EQ(test.signum(), -1);
+    CHECK_EQ(to_string(test), "-11");
 
-    CHECK(test);
+    CHECK_UNARY(test);
     test = 0;
-    CHECK(!test);
-    CHECK(test.signum() == 0);
+    CHECK_FALSE(test);
+    CHECK_EQ(test.signum(), 0);
     test = targetSame;
-    CHECK(test.signum() == 1);
-    CHECK(to_string(test) == "200");
+    CHECK_EQ(test.signum(), 1);
+    CHECK_EQ(to_string(test), "200");
 }
 
 TEST_CASE("mulRatio")
@@ -193,48 +193,49 @@ TEST_CASE("mulRatio")
         // multiply by a number that would overflow then divide by the same
         // number, and check we didn't lose any value
         XRPAmount big(maxXRP);
-        CHECK(big == mulRatio(big, maxUInt32, maxUInt32, true));
+        CHECK_EQ(big, mulRatio(big, maxUInt32, maxUInt32, true));
         // rounding mode shouldn't matter as the result is exact
-        CHECK(big == mulRatio(big, maxUInt32, maxUInt32, false));
+        CHECK_EQ(big, mulRatio(big, maxUInt32, maxUInt32, false));
 
         // multiply and divide by values that would overflow if done
         // naively, and check that it gives the correct answer
         big -= 0xf;  // Subtract a little so it's divisable by 4
-        CHECK(mulRatio(big, 3, 4, false).value() == (big.value() / 4) * 3);
-        CHECK(mulRatio(big, 3, 4, true).value() == (big.value() / 4) * 3);
-        CHECK((big.value() * 3) / 4 != (big.value() / 4) * 3);
+        CHECK_EQ(mulRatio(big, 3, 4, false).value(), (big.value() / 4) * 3);
+        CHECK_EQ(mulRatio(big, 3, 4, true).value(), (big.value() / 4) * 3);
+        CHECK_NE((big.value() * 3) / 4, (big.value() / 4) * 3);
     }
 
     {
         // Similar test as above, but for negative values
         XRPAmount big(minXRP);
-        CHECK(big == mulRatio(big, maxUInt32, maxUInt32, true));
+        CHECK_EQ(big, mulRatio(big, maxUInt32, maxUInt32, true));
         // rounding mode shouldn't matter as the result is exact
-        CHECK(big == mulRatio(big, maxUInt32, maxUInt32, false));
+        CHECK_EQ(big, mulRatio(big, maxUInt32, maxUInt32, false));
 
         // multiply and divide by values that would overflow if done
         // naively, and check that it gives the correct answer
-        CHECK(mulRatio(big, 3, 4, false).value() == (big.value() / 4) * 3);
-        CHECK(mulRatio(big, 3, 4, true).value() == (big.value() / 4) * 3);
-        CHECK((big.value() * 3) / 4 != (big.value() / 4) * 3);
+        CHECK_EQ(mulRatio(big, 3, 4, false).value(), (big.value() / 4) * 3);
+        CHECK_EQ(mulRatio(big, 3, 4, true).value(), (big.value() / 4) * 3);
+        CHECK_NE((big.value() * 3) / 4, (big.value() / 4) * 3);
     }
 
     {
         // small amounts
         XRPAmount tiny(1);
         // Round up should give the smallest allowable number
-        CHECK(tiny == mulRatio(tiny, 1, maxUInt32, true));
+        CHECK_EQ(tiny, mulRatio(tiny, 1, maxUInt32, true));
         // rounding down should be zero
-        CHECK(beast::zero == mulRatio(tiny, 1, maxUInt32, false));
-        CHECK(beast::zero == mulRatio(tiny, maxUInt32 - 1, maxUInt32, false));
+        CHECK_EQ(beast::zero, mulRatio(tiny, 1, maxUInt32, false));
+        CHECK_EQ(beast::zero, mulRatio(tiny, maxUInt32 - 1, maxUInt32, false));
 
         // tiny negative numbers
         XRPAmount tinyNeg(-1);
         // Round up should give zero
-        CHECK(beast::zero == mulRatio(tinyNeg, 1, maxUInt32, true));
-        CHECK(beast::zero == mulRatio(tinyNeg, maxUInt32 - 1, maxUInt32, true));
+        CHECK_EQ(beast::zero, mulRatio(tinyNeg, 1, maxUInt32, true));
+        CHECK_EQ(
+            beast::zero, mulRatio(tinyNeg, maxUInt32 - 1, maxUInt32, true));
         // rounding down should be tiny
-        CHECK(tinyNeg == mulRatio(tinyNeg, maxUInt32 - 1, maxUInt32, false));
+        CHECK_EQ(tinyNeg, mulRatio(tinyNeg, maxUInt32 - 1, maxUInt32, false));
     }
 
     {  // rounding
@@ -242,14 +243,14 @@ TEST_CASE("mulRatio")
             XRPAmount one(1);
             auto const rup = mulRatio(one, maxUInt32 - 1, maxUInt32, true);
             auto const rdown = mulRatio(one, maxUInt32 - 1, maxUInt32, false);
-            CHECK(rup.drops() - rdown.drops() == 1);
+            CHECK_EQ(rup.drops() - rdown.drops(), 1);
         }
 
         {
             XRPAmount big(maxXRP);
             auto const rup = mulRatio(big, maxUInt32 - 1, maxUInt32, true);
             auto const rdown = mulRatio(big, maxUInt32 - 1, maxUInt32, false);
-            CHECK(rup.drops() - rdown.drops() == 1);
+            CHECK_EQ(rup.drops() - rdown.drops(), 1);
         }
 
         {
@@ -257,7 +258,7 @@ TEST_CASE("mulRatio")
             auto const rup = mulRatio(negOne, maxUInt32 - 1, maxUInt32, true);
             auto const rdown =
                 mulRatio(negOne, maxUInt32 - 1, maxUInt32, false);
-            CHECK(rup.drops() - rdown.drops() == 1);
+            CHECK_EQ(rup.drops() - rdown.drops(), 1);
         }
     }
 
@@ -276,7 +277,7 @@ TEST_CASE("mulRatio")
     {
         // underflow
         XRPAmount bigNegative(minXRP + 10);
-        CHECK(mulRatio(bigNegative, 2, 1, true) == minXRP);
+        CHECK_EQ(mulRatio(bigNegative, 2, 1, true), minXRP);
     }
 }
 

src/doctest/basics/base58.cpp

@@ -180,8 +180,8 @@ TEST_CASE("b58_multiprecision")
         auto const mod = b58_fast::detail::inplace_bigint_div_rem(
             std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
         auto const foundDiv = multiprecision_utils::toBoostMP(bigInt);
-        CHECK(refMod.convert_to<std::uint64_t>() == mod);
-        CHECK(foundDiv == refDiv);
+        CHECK_EQ(refMod.convert_to<std::uint64_t>(), mod);
+        CHECK_EQ(foundDiv, refDiv);
     }
     for (int i = 0; i < iters; ++i)
     {
@@ -199,9 +199,9 @@ TEST_CASE("b58_multiprecision")
 
         auto const result = b58_fast::detail::inplace_bigint_add(
             std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
-        CHECK(result == TokenCodecErrc::success);
+        CHECK_EQ(result, TokenCodecErrc::success);
         auto const foundAdd = multiprecision_utils::toBoostMP(bigInt);
-        CHECK(refAdd == foundAdd);
+        CHECK_EQ(refAdd, foundAdd);
     }
     for (int i = 0; i < iters; ++i)
     {
@@ -217,9 +217,9 @@ TEST_CASE("b58_multiprecision")
 
         auto const result = b58_fast::detail::inplace_bigint_add(
             std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
-        CHECK(result == TokenCodecErrc::overflowAdd);
+        CHECK_EQ(result, TokenCodecErrc::overflowAdd);
         auto const foundAdd = multiprecision_utils::toBoostMP(bigInt);
-        CHECK(refAdd != foundAdd);
+        CHECK_NE(refAdd, foundAdd);
     }
     for (int i = 0; i < iters; ++i)
     {
@@ -235,9 +235,9 @@ TEST_CASE("b58_multiprecision")
 
         auto const result = b58_fast::detail::inplace_bigint_mul(
             std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
-        CHECK(result == TokenCodecErrc::success);
+        CHECK_EQ(result, TokenCodecErrc::success);
         auto const foundMul = multiprecision_utils::toBoostMP(bigInt);
-        CHECK(refMul == foundMul);
+        CHECK_EQ(refMul, foundMul);
     }
     for (int i = 0; i < iters; ++i)
     {
@@ -252,9 +252,9 @@ TEST_CASE("b58_multiprecision")
 
         auto const result = b58_fast::detail::inplace_bigint_mul(
             std::span<uint64_t>(bigInt.data(), bigInt.size()), d);
-        CHECK(result == TokenCodecErrc::inputTooLarge);
+        CHECK_EQ(result, TokenCodecErrc::inputTooLarge);
         auto const foundMul = multiprecision_utils::toBoostMP(bigInt);
-        CHECK(refMul != foundMul);
+        CHECK_NE(refMul, foundMul);
     }
 }
 
@@ -292,12 +292,11 @@ TEST_CASE("fast_matches_ref")
                 std::copy(s.begin(), s.end(), b58Result[i].begin());
             }
         }
-        REQUIRE(b58Result[0].size() == b58Result[1].size());
-        CHECK(
+        REQUIRE_EQ(b58Result[0].size(), b58Result[1].size());
+        CHECK_EQ(
             memcmp(
-                b58Result[0].data(),
-                b58Result[1].data(),
-                b58Result[0].size()) == 0);
+                b58Result[0].data(), b58Result[1].data(), b58Result[0].size()),
+            0);
 
         for (int i = 0; i < 2; ++i)
         {
@@ -323,12 +322,13 @@ TEST_CASE("fast_matches_ref")
             }
         }
 
-        REQUIRE(b256Result[0].size() == b256Result[1].size());
-        CHECK(
+        REQUIRE_EQ(b256Result[0].size(), b256Result[1].size());
+        CHECK_EQ(
             memcmp(
                 b256Result[0].data(),
                 b256Result[1].data(),
-                b256Result[0].size()) == 0);
+                b256Result[0].size()),
+            0);
     };
 
     auto testTokenEncode = [&](xrpl::TokenType const tokType,
@@ -358,12 +358,11 @@ TEST_CASE("fast_matches_ref")
                 std::copy(s.begin(), s.end(), b58Result[i].begin());
             }
         }
-        REQUIRE(b58Result[0].size() == b58Result[1].size());
-        CHECK(
+        REQUIRE_EQ(b58Result[0].size(), b58Result[1].size());
+        CHECK_EQ(
             memcmp(
-                b58Result[0].data(),
-                b58Result[1].data(),
-                b58Result[0].size()) == 0);
+                b58Result[0].data(), b58Result[1].data(), b58Result[0].size()),
+            0);
 
         for (int i = 0; i < 2; ++i)
         {
@@ -390,12 +389,13 @@ TEST_CASE("fast_matches_ref")
             }
         }
 
-        REQUIRE(b256Result[0].size() == b256Result[1].size());
-        CHECK(
+        REQUIRE_EQ(b256Result[0].size(), b256Result[1].size());
+        CHECK_EQ(
             memcmp(
                 b256Result[0].data(),
                 b256Result[1].data(),
-                b256Result[0].size()) == 0);
+                b256Result[0].size()),
+            0);
     };
 
     auto testIt = [&](xrpl::TokenType const tokType,

src/doctest/basics/base_uint.cpp

@@ -59,20 +59,20 @@ TEST_CASE("comparisons 64-bit")
     for (auto const& arg : test_args)
     {
         xrpl::base_uint<64> const u{arg.first}, v{arg.second};
-        CHECK(u < v);
-        CHECK(u <= v);
-        CHECK(u != v);
-        CHECK(!(u == v));
-        CHECK(!(u > v));
-        CHECK(!(u >= v));
-        CHECK(!(v < u));
-        CHECK(!(v <= u));
-        CHECK(v != u);
-        CHECK(!(v == u));
-        CHECK(v > u);
-        CHECK(v >= u);
-        CHECK(u == u);
-        CHECK(v == v);
+        CHECK_LT(u, v);
+        CHECK_LE(u, v);
+        CHECK_NE(u, v);
+        CHECK_FALSE(u == v);
+        CHECK_FALSE(u > v);
+        CHECK_FALSE(u >= v);
+        CHECK_FALSE(v < u);
+        CHECK_FALSE(v <= u);
+        CHECK_NE(v, u);
+        CHECK_FALSE(v == u);
+        CHECK_GT(v, u);
+        CHECK_GE(v, u);
+        CHECK_EQ(u, u);
+        CHECK_EQ(v, v);
     }
 }
 
@@ -92,20 +92,20 @@ TEST_CASE("comparisons 96-bit")
     for (auto const& arg : test_args)
     {
         xrpl::base_uint<96> const u{arg.first}, v{arg.second};
-        CHECK(u < v);
-        CHECK(u <= v);
-        CHECK(u != v);
-        CHECK(!(u == v));
-        CHECK(!(u > v));
-        CHECK(!(u >= v));
-        CHECK(!(v < u));
-        CHECK(!(v <= u));
-        CHECK(v != u);
-        CHECK(!(v == u));
-        CHECK(v > u);
-        CHECK(v >= u);
-        CHECK(u == u);
-        CHECK(v == v);
+        CHECK_LT(u, v);
+        CHECK_LE(u, v);
+        CHECK_NE(u, v);
+        CHECK_FALSE(u == v);
+        CHECK_FALSE(u > v);
+        CHECK_FALSE(u >= v);
+        CHECK_FALSE(v < u);
+        CHECK_FALSE(v <= u);
+        CHECK_NE(v, u);
+        CHECK_FALSE(v == u);
+        CHECK_GT(v, u);
+        CHECK_GE(v, u);
+        CHECK_EQ(u, u);
+        CHECK_EQ(v, v);
     }
 }
 
@@ -118,22 +118,22 @@ TEST_CASE("general purpose tests")
     std::unordered_set<test96, hardened_hash<>> uset;
 
     Blob raw{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
-    CHECK(test96::bytes == raw.size());
+    CHECK_EQ(test96::bytes, raw.size());
 
     test96 u{raw};
     uset.insert(u);
-    CHECK(raw.size() == u.size());
-    CHECK(to_string(u) == "0102030405060708090A0B0C");
-    CHECK(to_short_string(u) == "01020304...");
-    CHECK(*u.data() == 1);
-    CHECK(u.signum() == 1);
-    CHECK(!!u);
-    CHECK(!u.isZero());
-    CHECK(u.isNonZero());
+    CHECK_EQ(raw.size(), u.size());
+    CHECK_EQ(to_string(u), "0102030405060708090A0B0C");
+    CHECK_EQ(to_short_string(u), "01020304...");
+    CHECK_EQ(*u.data(), 1);
+    CHECK_EQ(u.signum(), 1);
+    CHECK_UNARY(!!u);
+    CHECK_FALSE(u.isZero());
+    CHECK_UNARY(u.isNonZero());
     unsigned char t = 0;
     for (auto& d : u)
     {
-        CHECK(d == ++t);
+        CHECK_EQ(d, ++t);
     }
 
     // Test hash_append by "hashing" with a no-op hasher (h)
@@ -142,56 +142,56 @@ TEST_CASE("general purpose tests")
     nonhash<96> h;
     hash_append(h, u);
     test96 w{std::vector<std::uint8_t>(h.data_.begin(), h.data_.end())};
-    CHECK(w == u);
+    CHECK_EQ(w, u);
 
     test96 v{~u};
     uset.insert(v);
-    CHECK(to_string(v) == "FEFDFCFBFAF9F8F7F6F5F4F3");
-    CHECK(to_short_string(v) == "FEFDFCFB...");
-    CHECK(*v.data() == 0xfe);
-    CHECK(v.signum() == 1);
-    CHECK(!!v);
-    CHECK(!v.isZero());
-    CHECK(v.isNonZero());
+    CHECK_EQ(to_string(v), "FEFDFCFBFAF9F8F7F6F5F4F3");
+    CHECK_EQ(to_short_string(v), "FEFDFCFB...");
+    CHECK_EQ(*v.data(), 0xfe);
+    CHECK_EQ(v.signum(), 1);
+    CHECK_UNARY(!!v);
+    CHECK_FALSE(v.isZero());
+    CHECK_UNARY(v.isNonZero());
     t = 0xff;
     for (auto& d : v)
     {
-        CHECK(d == --t);
+        CHECK_EQ(d, --t);
     }
 
-    CHECK(u < v);
-    CHECK(v > u);
+    CHECK_LT(u, v);
+    CHECK_GT(v, u);
 
     v = u;
-    CHECK(v == u);
+    CHECK_EQ(v, u);
 
     test96 z{beast::zero};
     uset.insert(z);
-    CHECK(to_string(z) == "000000000000000000000000");
-    CHECK(to_short_string(z) == "00000000...");
-    CHECK(*z.data() == 0);
-    CHECK(*z.begin() == 0);
-    CHECK(*std::prev(z.end(), 1) == 0);
-    CHECK(z.signum() == 0);
-    CHECK(!z);
-    CHECK(z.isZero());
-    CHECK(!z.isNonZero());
+    CHECK_EQ(to_string(z), "000000000000000000000000");
+    CHECK_EQ(to_short_string(z), "00000000...");
+    CHECK_EQ(*z.data(), 0);
+    CHECK_EQ(*z.begin(), 0);
+    CHECK_EQ(*std::prev(z.end(), 1), 0);
+    CHECK_EQ(z.signum(), 0);
+    CHECK_UNARY(!z);  // base_uint doesn't have explicit bool conversion
+    CHECK_UNARY(z.isZero());
+    CHECK_UNARY(!z.isNonZero());
     for (auto& d : z)
     {
-        CHECK(d == 0);
+        CHECK_EQ(d, 0);
     }
 
     test96 n{z};
     n++;
-    CHECK(n == test96(1));
+    CHECK_EQ(n, test96(1));
     n--;
-    CHECK(n == beast::zero);
-    CHECK(n == z);
+    CHECK_EQ(n, beast::zero);
+    CHECK_EQ(n, z);
     n--;
-    CHECK(to_string(n) == "FFFFFFFFFFFFFFFFFFFFFFFF");
-    CHECK(to_short_string(n) == "FFFFFFFF...");
+    CHECK_EQ(to_string(n), "FFFFFFFFFFFFFFFFFFFFFFFF");
+    CHECK_EQ(to_short_string(n), "FFFFFFFF...");
     n = beast::zero;
-    CHECK(n == z);
+    CHECK_EQ(n, z);
 
     test96 zp1{z};
     zp1++;
@@ -199,22 +199,22 @@ TEST_CASE("general purpose tests")
     zm1--;
     test96 x{zm1 ^ zp1};
     uset.insert(x);
-    CHECK(to_string(x) == "FFFFFFFFFFFFFFFFFFFFFFFE");
-    CHECK(to_short_string(x) == "FFFFFFFF...");
+    CHECK_EQ(to_string(x), "FFFFFFFFFFFFFFFFFFFFFFFE");
+    CHECK_EQ(to_short_string(x), "FFFFFFFF...");
 
-    CHECK(uset.size() == 4);
+    CHECK_EQ(uset.size(), 4);
 
     test96 tmp;
-    CHECK(tmp.parseHex(to_string(u)));
-    CHECK(tmp == u);
+    CHECK_UNARY(tmp.parseHex(to_string(u)));
+    CHECK_EQ(tmp, u);
     tmp = z;
 
     // fails with extra char
-    CHECK(!tmp.parseHex("A" + to_string(u)));
+    CHECK_FALSE(tmp.parseHex("A" + to_string(u)));
     tmp = z;
 
     // fails with extra char at end
-    CHECK(!tmp.parseHex(to_string(u) + "A"));
+    CHECK_FALSE(tmp.parseHex(to_string(u) + "A"));
 
     // fails with a non-hex character at some point in the string:
     tmp = z;
@@ -223,7 +223,7 @@ TEST_CASE("general purpose tests")
     {
         std::string x = to_string(z);
         x[i] = ('G' + (i % 10));
-        CHECK(!tmp.parseHex(x));
+        CHECK_FALSE(tmp.parseHex(x));
     }
 
     // Walking 1s:
@@ -232,8 +232,8 @@ TEST_CASE("general purpose tests")
         std::string s1 = "000000000000000000000000";
         s1[i] = '1';
 
-        CHECK(tmp.parseHex(s1));
-        CHECK(to_string(tmp) == s1);
+        CHECK_UNARY(tmp.parseHex(s1));
+        CHECK_EQ(to_string(tmp), s1);
     }
 
     // Walking 0s:
@@ -242,8 +242,8 @@ TEST_CASE("general purpose tests")
         std::string s1 = "111111111111111111111111";
         s1[i] = '0';
 
-        CHECK(tmp.parseHex(s1));
-        CHECK(to_string(tmp) == s1);
+        CHECK_UNARY(tmp.parseHex(s1));
+        CHECK_EQ(to_string(tmp), s1);
     }
 }
 
@@ -269,10 +269,10 @@ TEST_CASE("constexpr constructors")
         }
         catch (std::invalid_argument const& e)
         {
-            CHECK(e.what() == std::string("invalid length for hex string"));
+            CHECK_EQ(e.what(), std::string("invalid length for hex string"));
             caught = true;
         }
-        CHECK(caught);
+        CHECK_UNARY(caught);
     }
     {
         // Invalid character in string.
@@ -287,10 +287,10 @@ TEST_CASE("constexpr constructors")
         }
         catch (std::range_error const& e)
         {
-            CHECK(e.what() == std::string("invalid hex character"));
+            CHECK_EQ(e.what(), std::string("invalid hex character"));
             caught = true;
         }
-        CHECK(caught);
+        CHECK_UNARY(caught);
     }
 
     // Verify that constexpr base_uints interpret a string the same
@@ -315,8 +315,8 @@ TEST_CASE("constexpr constructors")
     for (StrBaseUint const& t : testCases)
     {
         test96 t96;
-        CHECK(t96.parseHex(t.str));
-        CHECK(t96 == t.tst);
+        CHECK_UNARY(t96.parseHex(t.str));
+        CHECK_EQ(t96, t.tst);
     }
 }
 

src/doctest/basics/join.cpp

@@ -20,9 +20,9 @@ TEST_CASE("CollectionAndDelimiter")
         // the << operator returns the stream correctly.
         ss << "(" << collectionanddelimiter << ")";
         auto const str = ss.str();
-        CHECK(str.substr(1, str.length() - 2) == expected);
-        CHECK(str.front() == '(');
-        CHECK(str.back() == ')');
+        CHECK_EQ(str.substr(1, str.length() - 2), expected);
+        CHECK_EQ(str.front(), '(');
+        CHECK_EQ(str.back(), ')');
     };
 
     // C++ array

src/doctest/beast/CurrentThreadName.cpp

@@ -62,8 +62,8 @@ TEST_CASE("Thread names are preserved")
     tB.join();
 
     // Both threads should still have the expected name when they exit.
-    CHECK(stateA == 2);
-    CHECK(stateB == 2);
+    CHECK_EQ(stateA, 2);
+    CHECK_EQ(stateB, 2);
 }
 
 TEST_SUITE_END();

src/doctest/beast/IPEndpoint.cpp

@@ -86,9 +86,9 @@ shouldParseEPV4(
     auto const result = Endpoint::from_string_checked(s);
     REQUIRE(result);
     REQUIRE(result->address().is_v4());
-    REQUIRE(result->address().to_v4() == AddressV4{value});
-    CHECK(result->port() == p);
-    CHECK(to_string(*result) == (normal.empty() ? s : normal));
+    REQUIRE_EQ(result->address().to_v4(), AddressV4{value});
+    CHECK_EQ(result->port(), p);
+    CHECK_EQ(to_string(*result), (normal.empty() ? s : normal));
 }
 
 void
@@ -101,9 +101,9 @@ shouldParseEPV6(
     auto result = Endpoint::from_string_checked(s);
     REQUIRE(result);
     REQUIRE(result->address().is_v6());
-    REQUIRE(result->address().to_v6() == AddressV6{value});
-    CHECK(result->port() == p);
-    CHECK(to_string(*result) == (normal.empty() ? s : normal));
+    REQUIRE_EQ(result->address().to_v6(), AddressV6{value});
+    CHECK_EQ(result->port(), p);
+    CHECK_EQ(to_string(*result), (normal.empty() ? s : normal));
 }
 
 void
@@ -151,23 +151,23 @@ shouldFail(std::string const& text)
 
 TEST_CASE("AddressV4")
 {
-    CHECK(AddressV4{}.to_uint() == 0);
-    CHECK(is_unspecified(AddressV4{}));
-    CHECK(AddressV4{0x01020304}.to_uint() == 0x01020304);
+    CHECK_EQ(AddressV4{}.to_uint(), 0);
+    CHECK_UNARY(is_unspecified(AddressV4{}));
+    CHECK_EQ(AddressV4{0x01020304}.to_uint(), 0x01020304);
 
     {
         AddressV4::bytes_type d = {{1, 2, 3, 4}};
-        CHECK(AddressV4{d}.to_uint() == 0x01020304);
+        CHECK_EQ(AddressV4{d}.to_uint(), 0x01020304);
         CHECK_FALSE(is_unspecified(AddressV4{d}));
     }
 
     AddressV4 const v1{1};
-    CHECK(AddressV4{v1}.to_uint() == 1);
+    CHECK_EQ(AddressV4{v1}.to_uint(), 1);
 
     {
         AddressV4 v;
         v = v1;
-        CHECK(v.to_uint() == v1.to_uint());
+        CHECK_EQ(v.to_uint(), v1.to_uint());
     }
 
     {
@@ -178,10 +178,10 @@ TEST_CASE("AddressV4")
         d[2] = 3;
         d[3] = 4;
         v = AddressV4{d};
-        CHECK(v.to_uint() == 0x01020304);
+        CHECK_EQ(v.to_uint(), 0x01020304);
     }
 
-    CHECK(AddressV4(0x01020304).to_string() == "1.2.3.4");
+    CHECK_EQ(AddressV4(0x01020304).to_string(), "1.2.3.4");
 
     shouldParseAddrV4("1.2.3.4", 0x01020304);
     shouldParseAddrV4("255.255.255.255", 0xffffffff);
@@ -213,20 +213,20 @@ TEST_CASE("AddressV4::Bytes")
 {
     AddressV4::bytes_type d1 = {{10, 0, 0, 1}};
     AddressV4 v4{d1};
-    CHECK(v4.to_bytes()[0] == 10);
-    CHECK(v4.to_bytes()[1] == 0);
-    CHECK(v4.to_bytes()[2] == 0);
-    CHECK(v4.to_bytes()[3] == 1);
+    CHECK_EQ(v4.to_bytes()[0], 10);
+    CHECK_EQ(v4.to_bytes()[1], 0);
+    CHECK_EQ(v4.to_bytes()[2], 0);
+    CHECK_EQ(v4.to_bytes()[3], 1);
 
-    CHECK((~((0xff) << 16)) == 0xff00ffff);
+    CHECK_EQ((~((0xff) << 16)), 0xff00ffff);
 
     auto d2 = v4.to_bytes();
     d2[1] = 10;
     v4 = AddressV4{d2};
-    CHECK(v4.to_bytes()[0] == 10);
-    CHECK(v4.to_bytes()[1] == 10);
-    CHECK(v4.to_bytes()[2] == 0);
-    CHECK(v4.to_bytes()[3] == 1);
+    CHECK_EQ(v4.to_bytes()[0], 10);
+    CHECK_EQ(v4.to_bytes()[1], 10);
+    CHECK_EQ(v4.to_bytes()[2], 0);
+    CHECK_EQ(v4.to_bytes()[3], 1);
 }
 
 TEST_CASE("Address")
@@ -234,9 +234,9 @@ TEST_CASE("Address")
     boost::system::error_code ec;
     Address result{boost::asio::ip::make_address("1.2.3.4", ec)};
     AddressV4::bytes_type d = {{1, 2, 3, 4}};
-    CHECK(!ec);
-    CHECK(result.is_v4());
-    CHECK(result.to_v4() == AddressV4{d});
+    CHECK_FALSE(ec);
+    CHECK_UNARY(result.is_v4());
+    CHECK_EQ(result.to_v4(), AddressV4{d});
 }
 
 TEST_CASE("Endpoint")
@@ -271,113 +271,114 @@ TEST_CASE("Endpoint")
 
     AddressV4::bytes_type d = {{127, 0, 0, 1}};
     ep = Endpoint(AddressV4{d}, 80);
-    CHECK(!is_unspecified(ep));
-    CHECK(!is_public(ep));
-    CHECK(is_private(ep));
-    CHECK(!is_multicast(ep));
-    CHECK(is_loopback(ep));
-    CHECK(to_string(ep) == "127.0.0.1:80");
+    CHECK_FALSE(is_unspecified(ep));
+    CHECK_FALSE(is_public(ep));
+    CHECK_UNARY(is_private(ep));
+    CHECK_FALSE(is_multicast(ep));
+    CHECK_UNARY(is_loopback(ep));
+    CHECK_EQ(to_string(ep), "127.0.0.1:80");
     // same address as v4 mapped in ipv6
     ep = Endpoint(
         boost::asio::ip::make_address_v6(
             boost::asio::ip::v4_mapped, AddressV4{d}),
         80);
-    CHECK(!is_unspecified(ep));
-    CHECK(!is_public(ep));
-    CHECK(is_private(ep));
-    CHECK(!is_multicast(ep));
-    CHECK(!is_loopback(ep));  // mapped loopback is not a loopback
-    CHECK(to_string(ep) == "[::ffff:127.0.0.1]:80");
+    CHECK_FALSE(is_unspecified(ep));
+    CHECK_FALSE(is_public(ep));
+    CHECK_UNARY(is_private(ep));
+    CHECK_FALSE(is_multicast(ep));
+    CHECK_FALSE(is_loopback(ep));  // mapped loopback is not a loopback
+    CHECK_EQ(to_string(ep), "[::ffff:127.0.0.1]:80");
 
     d = {{10, 0, 0, 1}};
     ep = Endpoint(AddressV4{d});
-    CHECK(get_class(ep.to_v4()) == 'A');
-    CHECK(!is_unspecified(ep));
-    CHECK(!is_public(ep));
-    CHECK(is_private(ep));
-    CHECK(!is_multicast(ep));
-    CHECK(!is_loopback(ep));
-    CHECK(to_string(ep) == "10.0.0.1");
+    CHECK_EQ(get_class(ep.to_v4()), 'A');
+    CHECK_FALSE(is_unspecified(ep));
+    CHECK_FALSE(is_public(ep));
+    CHECK_UNARY(is_private(ep));
+    CHECK_FALSE(is_multicast(ep));
+    CHECK_FALSE(is_loopback(ep));
+    CHECK_EQ(to_string(ep), "10.0.0.1");
     // same address as v4 mapped in ipv6
     ep = Endpoint(boost::asio::ip::make_address_v6(
         boost::asio::ip::v4_mapped, AddressV4{d}));
-    CHECK(
+    CHECK_EQ(
         get_class(boost::asio::ip::make_address_v4(
-            boost::asio::ip::v4_mapped, ep.to_v6())) == 'A');
-    CHECK(!is_unspecified(ep));
-    CHECK(!is_public(ep));
-    CHECK(is_private(ep));
-    CHECK(!is_multicast(ep));
-    CHECK(!is_loopback(ep));
-    CHECK(to_string(ep) == "::ffff:10.0.0.1");
+            boost::asio::ip::v4_mapped, ep.to_v6())),
+        'A');
+    CHECK_FALSE(is_unspecified(ep));
+    CHECK_FALSE(is_public(ep));
+    CHECK_UNARY(is_private(ep));
+    CHECK_FALSE(is_multicast(ep));
+    CHECK_FALSE(is_loopback(ep));
+    CHECK_EQ(to_string(ep), "::ffff:10.0.0.1");
 
     d = {{166, 78, 151, 147}};
     ep = Endpoint(AddressV4{d});
-    CHECK(!is_unspecified(ep));
-    CHECK(is_public(ep));
-    CHECK(!is_private(ep));
-    CHECK(!is_multicast(ep));
-    CHECK(!is_loopback(ep));
-    CHECK(to_string(ep) == "166.78.151.147");
+    CHECK_FALSE(is_unspecified(ep));
+    CHECK_UNARY(is_public(ep));
+    CHECK_FALSE(is_private(ep));
+    CHECK_FALSE(is_multicast(ep));
+    CHECK_FALSE(is_loopback(ep));
+    CHECK_EQ(to_string(ep), "166.78.151.147");
     // same address as v4 mapped in ipv6
     ep = Endpoint(boost::asio::ip::make_address_v6(
         boost::asio::ip::v4_mapped, AddressV4{d}));
-    CHECK(!is_unspecified(ep));
-    CHECK(is_public(ep));
-    CHECK(!is_private(ep));
-    CHECK(!is_multicast(ep));
-    CHECK(!is_loopback(ep));
-    CHECK(to_string(ep) == "::ffff:166.78.151.147");
+    CHECK_FALSE(is_unspecified(ep));
+    CHECK_UNARY(is_public(ep));
+    CHECK_FALSE(is_private(ep));
+    CHECK_FALSE(is_multicast(ep));
+    CHECK_FALSE(is_loopback(ep));
+    CHECK_EQ(to_string(ep), "::ffff:166.78.151.147");
 
     // a private IPv6
     AddressV6::bytes_type d2 = {
         {253, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}};
     ep = Endpoint(AddressV6{d2});
-    CHECK(!is_unspecified(ep));
-    CHECK(!is_public(ep));
-    CHECK(is_private(ep));
-    CHECK(!is_multicast(ep));
-    CHECK(!is_loopback(ep));
-    CHECK(to_string(ep) == "fd00::1");
+    CHECK_FALSE(is_unspecified(ep));
+    CHECK_FALSE(is_public(ep));
+    CHECK_UNARY(is_private(ep));
+    CHECK_FALSE(is_multicast(ep));
+    CHECK_FALSE(is_loopback(ep));
+    CHECK_EQ(to_string(ep), "fd00::1");
 
     {
         ep = Endpoint::from_string("192.0.2.112");
-        CHECK(!is_unspecified(ep));
-        CHECK(ep == Endpoint::from_string("192.0.2.112"));
+        CHECK_FALSE(is_unspecified(ep));
+        CHECK_EQ(ep, Endpoint::from_string("192.0.2.112"));
 
         auto const ep1 = Endpoint::from_string("192.0.2.112:2016");
-        CHECK(!is_unspecified(ep1));
-        CHECK(ep.address() == ep1.address());
-        CHECK(ep1.port() == 2016);
+        CHECK_FALSE(is_unspecified(ep1));
+        CHECK_EQ(ep.address(), ep1.address());
+        CHECK_EQ(ep1.port(), 2016);
 
         auto const ep2 = Endpoint::from_string("192.0.2.112:2016");
-        CHECK(!is_unspecified(ep2));
-        CHECK(ep.address() == ep2.address());
-        CHECK(ep2.port() == 2016);
-        CHECK(ep1 == ep2);
+        CHECK_FALSE(is_unspecified(ep2));
+        CHECK_EQ(ep.address(), ep2.address());
+        CHECK_EQ(ep2.port(), 2016);
+        CHECK_EQ(ep1, ep2);
 
         auto const ep3 = Endpoint::from_string("192.0.2.112 2016");
-        CHECK(!is_unspecified(ep3));
-        CHECK(ep.address() == ep3.address());
-        CHECK(ep3.port() == 2016);
-        CHECK(ep2 == ep3);
+        CHECK_FALSE(is_unspecified(ep3));
+        CHECK_EQ(ep.address(), ep3.address());
+        CHECK_EQ(ep3.port(), 2016);
+        CHECK_EQ(ep2, ep3);
 
         auto const ep4 = Endpoint::from_string("192.0.2.112     2016");
-        CHECK(!is_unspecified(ep4));
-        CHECK(ep.address() == ep4.address());
-        CHECK(ep4.port() == 2016);
-        CHECK(ep3 == ep4);
+        CHECK_FALSE(is_unspecified(ep4));
+        CHECK_EQ(ep.address(), ep4.address());
+        CHECK_EQ(ep4.port(), 2016);
+        CHECK_EQ(ep3, ep4);
 
-        CHECK(to_string(ep1) == to_string(ep2));
-        CHECK(to_string(ep1) == to_string(ep3));
-        CHECK(to_string(ep1) == to_string(ep4));
+        CHECK_EQ(to_string(ep1), to_string(ep2));
+        CHECK_EQ(to_string(ep1), to_string(ep3));
+        CHECK_EQ(to_string(ep1), to_string(ep4));
     }
 
     {
         ep = Endpoint::from_string("[::]:2017");
-        CHECK(is_unspecified(ep));
-        CHECK(ep.port() == 2017);
-        CHECK(ep.address() == AddressV6{});
+        CHECK_UNARY(is_unspecified(ep));
+        CHECK_EQ(ep.port(), 2017);
+        CHECK_EQ(ep.address(), AddressV6{});
     }
 
     // Failures:

src/doctest/beast/Journal.cpp

@@ -56,17 +56,17 @@ TEST_CASE("Journal threshold kInfo")
     Journal j(sink);
 
     j.trace() << " ";
-    CHECK(sink.count() == 0);
+    CHECK_EQ(sink.count(), 0);
     j.debug() << " ";
-    CHECK(sink.count() == 0);
+    CHECK_EQ(sink.count(), 0);
     j.info() << " ";
-    CHECK(sink.count() == 1);
+    CHECK_EQ(sink.count(), 1);
     j.warn() << " ";
-    CHECK(sink.count() == 2);
+    CHECK_EQ(sink.count(), 2);
     j.error() << " ";
-    CHECK(sink.count() == 3);
+    CHECK_EQ(sink.count(), 3);
     j.fatal() << " ";
-    CHECK(sink.count() == 4);
+    CHECK_EQ(sink.count(), 4);
 }
 
 TEST_CASE("Journal threshold kDebug")
@@ -79,17 +79,17 @@ TEST_CASE("Journal threshold kDebug")
     Journal j(sink);
 
     j.trace() << " ";
-    CHECK(sink.count() == 0);
+    CHECK_EQ(sink.count(), 0);
     j.debug() << " ";
-    CHECK(sink.count() == 1);
+    CHECK_EQ(sink.count(), 1);
     j.info() << " ";
-    CHECK(sink.count() == 2);
+    CHECK_EQ(sink.count(), 2);
     j.warn() << " ";
-    CHECK(sink.count() == 3);
+    CHECK_EQ(sink.count(), 3);
     j.error() << " ";
-    CHECK(sink.count() == 4);
+    CHECK_EQ(sink.count(), 4);
     j.fatal() << " ";
-    CHECK(sink.count() == 5);
+    CHECK_EQ(sink.count(), 5);
 }
 
 TEST_SUITE_END();

src/doctest/beast/LexicalCast.cpp

@@ -25,9 +25,9 @@ testInteger(IntType in)
     std::string s;
     IntType out(in + 1);
 
-    CHECK(lexicalCastChecked(s, in));
-    CHECK(lexicalCastChecked(out, s));
-    CHECK(out == in);
+    CHECK_UNARY(lexicalCastChecked(s, in));
+    CHECK_UNARY(lexicalCastChecked(out, s));
+    CHECK_EQ(out, in);
 }
 
 template <class IntType>
@@ -83,7 +83,7 @@ testThrowConvert(std::string const& s, bool success)
         result = false;
     }
 
-    CHECK(result == success);
+    CHECK_EQ(result, success);
 }
 
 }  // namespace
@@ -239,12 +239,12 @@ TEST_CASE("entire range")
 
         auto result = lexicalCast(j, empty);
 
-        CHECK(result == actual);
+        CHECK_EQ(result, actual);
 
         if (result == actual)
         {
             auto number = lexicalCast<std::int16_t>(result);
-            CHECK(number == j);
+            CHECK_EQ(number, j);
         }
 
         i++;

src/doctest/beast/PropertyStream.cpp

@@ -16,8 +16,8 @@ test_peel_name(
     std::string const& expected_remainder)
 {
     std::string const peeled_name = Source::peel_name(&s);
-    CHECK(peeled_name == expected);
-    CHECK(s == expected_remainder);
+    CHECK_EQ(peeled_name, expected);
+    CHECK_EQ(s, expected_remainder);
 }
 
 void
@@ -27,8 +27,8 @@ test_peel_leading_slash(
     bool should_be_found)
 {
     bool const found(Source::peel_leading_slash(&s));
-    CHECK(found == should_be_found);
-    CHECK(s == expected);
+    CHECK_EQ(found, should_be_found);
+    CHECK_EQ(s, expected);
 }
 
 void
@@ -38,37 +38,37 @@ test_peel_trailing_slashstar(
     bool should_be_found)
 {
     bool const found(Source::peel_trailing_slashstar(&s));
-    CHECK(found == should_be_found);
-    CHECK(s == expected_remainder);
+    CHECK_EQ(found, should_be_found);
+    CHECK_EQ(s, expected_remainder);
 }
 
 void
 test_find_one(Source& root, Source* expected, std::string const& name)
 {
     Source* source(root.find_one(name));
-    CHECK(source == expected);
+    CHECK_EQ(source, expected);
 }
 
 void
 test_find_path(Source& root, std::string const& path, Source* expected)
 {
     Source* source(root.find_path(path));
-    CHECK(source == expected);
+    CHECK_EQ(source, expected);
 }
 
 void
 test_find_one_deep(Source& root, std::string const& name, Source* expected)
 {
     Source* source(root.find_one_deep(name));
-    CHECK(source == expected);
+    CHECK_EQ(source, expected);
 }
 
 void
 test_find(Source& root, std::string path, Source* expected, bool expected_star)
 {
     auto const result(root.find(path));
-    CHECK(result.first == expected);
-    CHECK(result.second == expected_star);
+    CHECK_EQ(result.first, expected);
+    CHECK_EQ(result.second, expected_star);
 }
 
 }  // namespace

src/doctest/beast/SemanticVersion.cpp

@@ -17,8 +17,8 @@ checkPass(std::string const& input, bool shouldPass = true)
 
     if (shouldPass)
     {
-        CHECK(v.parse(input));
-        CHECK(v.print() == input);
+        CHECK_UNARY(v.parse(input));
+        CHECK_EQ(v.print(), input);
     }
     else
     {
@@ -140,14 +140,14 @@ checkValues(
 {
     SemanticVersion v;
 
-    CHECK(v.parse(input));
+    CHECK_UNARY(v.parse(input));
 
-    CHECK(v.majorVersion == majorVersion);
-    CHECK(v.minorVersion == minorVersion);
-    CHECK(v.patchVersion == patchVersion);
+    CHECK_EQ(v.majorVersion, majorVersion);
+    CHECK_EQ(v.minorVersion, minorVersion);
+    CHECK_EQ(v.patchVersion, patchVersion);
 
-    CHECK(v.preReleaseIdentifiers == preReleaseIdentifiers);
-    CHECK(v.metaData == metaData);
+    CHECK_EQ(v.preReleaseIdentifiers, preReleaseIdentifiers);
+    CHECK_EQ(v.metaData, metaData);
 }
 
 // makes sure the left version is less than the right
@@ -157,18 +157,18 @@ checkLessInternal(std::string const& lhs, std::string const& rhs)
     SemanticVersion left;
     SemanticVersion right;
 
-    CHECK(left.parse(lhs));
-    CHECK(right.parse(rhs));
+    CHECK_UNARY(left.parse(lhs));
+    CHECK_UNARY(right.parse(rhs));
 
-    CHECK(compare(left, left) == 0);
-    CHECK(compare(right, right) == 0);
-    CHECK(compare(left, right) < 0);
-    CHECK(compare(right, left) > 0);
+    CHECK_EQ(compare(left, left), 0);
+    CHECK_EQ(compare(right, right), 0);
+    CHECK_LT(compare(left, right), 0);
+    CHECK_GT(compare(right, left), 0);
 
-    CHECK(left < right);
-    CHECK(right > left);
-    CHECK(left == left);
-    CHECK(right == right);
+    CHECK_LT(left, right);
+    CHECK_GT(right, left);
+    CHECK_EQ(left, left);
+    CHECK_EQ(right, right);
 }
 
 void

src/doctest/beast/aged_associative_container.cpp

@@ -413,8 +413,8 @@ checkMapContents(Container& c, Values const& v)
 {
     if (v.empty())
     {
-        CHECK(c.empty());
-        CHECK(c.size() == 0);
+        CHECK_UNARY(c.empty());
+        CHECK_EQ(c.size(), 0);
         return;
     }
 
@@ -424,11 +424,11 @@ checkMapContents(Container& c, Values const& v)
         for (auto const& e : v)
             c.at(e.first);
         for (auto const& e : v)
-            CHECK(c.operator[](e.first) == e.second);
+            CHECK_EQ(c.operator[](e.first), e.second);
     }
     catch (std::out_of_range const&)
     {
-        CHECK(false);  // FAIL: caught exception
+        CHECK_UNARY(false);  // FAIL: caught exception
     }
 }
 
@@ -464,14 +464,10 @@ checkUnorderedContentsRefRef(C&& c, Values const& v)
                 [iter](typename Values::value_type const& e) {
                     return Traits::extract(*iter) == Traits::extract(e);
                 }));
-            bool found = (match != v.end());
-            CHECK(found);
-            bool keysEqual =
-                key_eq(Traits::extract(*iter), Traits::extract(*match));
-            CHECK(keysEqual);
-            bool hashesEqual =
-                (hash(Traits::extract(*iter)) == hash(Traits::extract(*match)));
-            CHECK(hashesEqual);
+            CHECK_NE(match, v.end());
+            CHECK(key_eq(Traits::extract(*iter), Traits::extract(*match)));
+            CHECK_EQ(
+                hash(Traits::extract(*iter)), hash(Traits::extract(*match)));
         }
     }
 }
@@ -490,21 +486,25 @@ checkContentsRefRef(C&& c, Values const& v)
     using Cont = typename std::remove_reference<C>::type;
     using size_type = typename Cont::size_type;
 
-    CHECK(c.size() == v.size());
-    CHECK(size_type(std::distance(c.begin(), c.end())) == v.size());
-    CHECK(size_type(std::distance(c.cbegin(), c.cend())) == v.size());
-    CHECK(
-        size_type(std::distance(
-            c.chronological.begin(), c.chronological.end())) == v.size());
-    CHECK(
-        size_type(std::distance(
-            c.chronological.cbegin(), c.chronological.cend())) == v.size());
-    CHECK(
-        size_type(std::distance(
-            c.chronological.rbegin(), c.chronological.rend())) == v.size());
-    CHECK(
-        size_type(std::distance(
-            c.chronological.crbegin(), c.chronological.crend())) == v.size());
+    CHECK_EQ(c.size(), v.size());
+    CHECK_EQ(size_type(std::distance(c.begin(), c.end())), v.size());
+    CHECK_EQ(size_type(std::distance(c.cbegin(), c.cend())), v.size());
+    CHECK_EQ(
+        size_type(
+            std::distance(c.chronological.begin(), c.chronological.end())),
+        v.size());
+    CHECK_EQ(
+        size_type(
+            std::distance(c.chronological.cbegin(), c.chronological.cend())),
+        v.size());
+    CHECK_EQ(
+        size_type(
+            std::distance(c.chronological.rbegin(), c.chronological.rend())),
+        v.size());
+    CHECK_EQ(
+        size_type(
+            std::distance(c.chronological.crbegin(), c.chronological.crend())),
+        v.size());
 
     checkUnorderedContentsRefRef(c, v);
 }
@@ -760,51 +760,39 @@ testIterator()
         auto const v(Traits::values());
         Cont c(v.cbegin(), v.cend(), clock);
         Cont const& cc(c);
-        CHECK(!c.empty());
-        CHECK(c.size() == v.size());
+        CHECK_FALSE(c.empty());
+        CHECK_EQ(c.size(), v.size());
 
         {
             auto i = c.begin();
-            bool eq1 = (i == c.begin());
-            CHECK(eq1);
-            bool ne1 = (i != c.end());
-            CHECK(ne1);
+            CHECK_EQ(i, c.begin());
+            CHECK_NE(i, c.end());
             ++i;
-            bool ne2 = (i != c.begin());
-            CHECK(ne2);
+            CHECK_NE(i, c.begin());
         }
 
         {
             auto i = cc.begin();
-            bool eq1 = (i == cc.begin());
-            CHECK(eq1);
-            bool ne1 = (i != cc.end());
-            CHECK(ne1);
+            CHECK_EQ(i, cc.begin());
+            CHECK_NE(i, cc.end());
             ++i;
-            bool ne2 = (i != cc.begin());
-            CHECK(ne2);
+            CHECK_NE(i, cc.begin());
         }
 
         {
             auto i = c.cbegin();
-            bool eq1 = (i == c.cbegin());
-            CHECK(eq1);
-            bool ne1 = (i != c.cend());
-            CHECK(ne1);
+            CHECK_EQ(i, c.cbegin());
+            CHECK_NE(i, c.cend());
             ++i;
-            bool ne2 = (i != c.cbegin());
-            CHECK(ne2);
+            CHECK_NE(i, c.cbegin());
         }
 
         {
             auto i = cc.cbegin();
-            bool eq1 = (i == cc.cbegin());
-            CHECK(eq1);
-            bool ne1 = (i != cc.cend());
-            CHECK(ne1);
+            CHECK_EQ(i, cc.cbegin());
+            CHECK_NE(i, cc.cend());
             ++i;
-            bool ne2 = (i != cc.cbegin());
-            CHECK(ne2);
+            CHECK_NE(i, cc.cbegin());
         }
     }
 }
@@ -826,46 +814,34 @@ testReverseIterator()
 
         {
             auto i = c.rbegin();
-            bool eq1 = (i == c.rbegin());
-            CHECK(eq1);
-            bool ne1 = (i != c.rend());
-            CHECK(ne1);
+            CHECK_EQ(i, c.rbegin());
+            CHECK_NE(i, c.rend());
             ++i;
-            bool ne2 = (i != c.rbegin());
-            CHECK(ne2);
+            CHECK_NE(i, c.rbegin());
         }
 
         {
             auto i = cc.rbegin();
-            bool eq1 = (i == cc.rbegin());
-            CHECK(eq1);
-            bool ne1 = (i != cc.rend());
-            CHECK(ne1);
+            CHECK_EQ(i, cc.rbegin());
+            CHECK_NE(i, cc.rend());
             ++i;
-            bool ne2 = (i != cc.rbegin());
-            CHECK(ne2);
+            CHECK_NE(i, cc.rbegin());
         }
 
         {
             auto i = c.crbegin();
-            bool eq1 = (i == c.crbegin());
-            CHECK(eq1);
-            bool ne1 = (i != c.crend());
-            CHECK(ne1);
+            CHECK_EQ(i, c.crbegin());
+            CHECK_NE(i, c.crend());
             ++i;
-            bool ne2 = (i != c.crbegin());
-            CHECK(ne2);
+            CHECK_NE(i, c.crbegin());
         }
 
         {
             auto i = cc.crbegin();
-            bool eq1 = (i == cc.crbegin());
-            CHECK(eq1);
-            bool ne1 = (i != cc.crend());
-            CHECK(ne1);
+            CHECK_EQ(i, cc.crbegin());
+            CHECK_NE(i, cc.crend());
             ++i;
-            bool ne2 = (i != cc.crbegin());
-            CHECK(ne2);
+            CHECK_NE(i, cc.crbegin());
         }
     }
 }
@@ -888,8 +864,7 @@ checkInsertCopy(Container& c, Values const& v)
         auto result = c.insert(e);
         if constexpr (Container::is_multi::value)
         {
-            bool isValid = (result != c.end());
-            CHECK(isValid);
+            CHECK_NE(result, c.end());
         }
         else
         {
@@ -907,8 +882,7 @@ checkInsertMove(Container& c, Values const& v)
         auto result = c.insert(std::move(e));
         if constexpr (Container::is_multi::value)
         {
-            bool isValid = (result != c.end());
-            CHECK(isValid);
+            CHECK_NE(result, c.end());
         }
         else
         {
@@ -930,13 +904,11 @@ checkInsertHintCopy(Container& c, Values const& v)
                           decltype(result),
                           std::pair<typename Container::iterator, bool>>)
         {
-            bool isValid = (result.first != c.end());
-            CHECK(isValid);
+            CHECK_NE(result.first, c.end());
         }
         else
         {
-            bool isValid = (result != c.end());
-            CHECK(isValid);
+            CHECK_NE(result, c.end());
         }
     }
 }
@@ -954,13 +926,11 @@ checkInsertHintMove(Container& c, Values const& v)
                           decltype(result),
                           std::pair<typename Container::iterator, bool>>)
         {
-            bool isValid = (result.first != c.end());
-            CHECK(isValid);
+            CHECK_NE(result.first, c.end());
         }
         else
         {
-            bool isValid = (result != c.end());
-            CHECK(isValid);
+            CHECK_NE(result, c.end());
         }
     }
 }
@@ -1023,27 +993,20 @@ testChronological()
         Cont const& cc(c);
 
         // Check chronological iterators
-        CHECK(!c.empty());
-        bool ne1 = (c.chronological.begin() != c.chronological.end());
-        CHECK(ne1);
-        bool ne2 = (cc.chronological.begin() != cc.chronological.end());
-        CHECK(ne2);
-        bool ne3 = (c.chronological.cbegin() != c.chronological.cend());
-        CHECK(ne3);
-        bool ne4 = (c.chronological.rbegin() != c.chronological.rend());
-        CHECK(ne4);
-        bool ne5 = (cc.chronological.rbegin() != cc.chronological.rend());
-        CHECK(ne5);
-        bool ne6 = (c.chronological.crbegin() != c.chronological.crend());
-        CHECK(ne6);
+        CHECK_FALSE(c.empty());
+        CHECK_NE(c.chronological.begin(), c.chronological.end());
+        CHECK_NE(cc.chronological.begin(), cc.chronological.end());
+        CHECK_NE(c.chronological.cbegin(), c.chronological.cend());
+        CHECK_NE(c.chronological.rbegin(), c.chronological.rend());
+        CHECK_NE(cc.chronological.rbegin(), cc.chronological.rend());
+        CHECK_NE(c.chronological.crbegin(), c.chronological.crend());
 
         // Check touch updates
         auto const before = c.clock().now();
         clock.advance(std::chrono::seconds(1));
         auto iter = c.begin();
         c.touch(iter);
-        bool isAfter = (iter.when() > before);
-        CHECK(isAfter);
+        CHECK_GT(iter.when(), before);
     }
 }
 

src/doctest/beast/beast_Zero.cpp

@@ -54,23 +54,23 @@ struct IntegerWrapper
 void
 test_lhs_zero(IntegerWrapper x)
 {
-    CHECK((x >= zero) == (x.signum() >= 0));
-    CHECK((x > zero) == (x.signum() > 0));
-    CHECK((x == zero) == (x.signum() == 0));
-    CHECK((x != zero) == (x.signum() != 0));
-    CHECK((x < zero) == (x.signum() < 0));
-    CHECK((x <= zero) == (x.signum() <= 0));
+    CHECK_EQ((x >= zero), (x.signum() >= 0));
+    CHECK_EQ((x > zero), (x.signum() > 0));
+    CHECK_EQ((x == zero), (x.signum() == 0));
+    CHECK_EQ((x != zero), (x.signum() != 0));
+    CHECK_EQ((x < zero), (x.signum() < 0));
+    CHECK_EQ((x <= zero), (x.signum() <= 0));
 }
 
 void
 test_rhs_zero(IntegerWrapper x)
 {
-    CHECK((zero >= x) == (0 >= x.signum()));
-    CHECK((zero > x) == (0 > x.signum()));
-    CHECK((zero == x) == (0 == x.signum()));
-    CHECK((zero != x) == (0 != x.signum()));
-    CHECK((zero < x) == (0 < x.signum()));
-    CHECK((zero <= x) == (0 <= x.signum()));
+    CHECK_EQ((zero >= x), (0 >= x.signum()));
+    CHECK_EQ((zero > x), (0 > x.signum()));
+    CHECK_EQ((zero == x), (0 == x.signum()));
+    CHECK_EQ((zero != x), (0 != x.signum()));
+    CHECK_EQ((zero < x), (0 < x.signum()));
+    CHECK_EQ((zero <= x), (0 <= x.signum()));
 }
 
 }  // namespace
@@ -91,8 +91,8 @@ TEST_CASE("rhs zero")
 
 TEST_CASE("ADL")
 {
-    CHECK(adl_tester{} == zero);
-    CHECK(inner_adl_test::adl_tester2{} == zero);
+    CHECK_EQ(adl_tester{}, zero);
+    CHECK_EQ(inner_adl_test::adl_tester2{}, zero);
 }
 
 TEST_SUITE_END();

src/doctest/beast/xxhasher.cpp

@@ -84,7 +84,8 @@ TEST_CASE("Big object with small and big updates without seed")
     hasher(bigObject.data(), bigObject.size());
     hasher(objectToHash.data(), objectToHash.size());
 
-    CHECK(static_cast<xxhasher::result_type>(hasher) == 1865045178324729219ULL);
+    CHECK_EQ(
+        static_cast<xxhasher::result_type>(hasher), 1865045178324729219ULL);
 }
 
 TEST_CASE("Big object with small and big updates with seed")
@@ -146,7 +147,7 @@ TEST_CASE("Operator result type doesn't change the internal state")
         auto xxhashResult1 = static_cast<xxhasher::result_type>(hasher);
         auto xxhashResult2 = static_cast<xxhasher::result_type>(hasher);
 
-        CHECK(xxhashResult1 == xxhashResult2);
+        CHECK_EQ(xxhashResult1, xxhashResult2);
     }
     SUBCASE("big object")
     {
@@ -161,7 +162,7 @@ TEST_CASE("Operator result type doesn't change the internal state")
         auto xxhashResult1 = hasher.operator xxhasher::result_type();
         auto xxhashResult2 = hasher.operator xxhasher::result_type();
 
-        CHECK(xxhashResult1 == xxhashResult2);
+        CHECK_EQ(xxhashResult1, xxhashResult2);
     }
 }
 

src/doctest/core/Workers.cpp

@@ -101,7 +101,7 @@ testThreads(int const tc1, int const tc2, int const tc3)
     std::unique_ptr<perf::PerfLog> perfLog = std::make_unique<PerfLogTest>();
 
     Workers w(cb, perfLog.get(), "Test", tc1);
-    CHECK(w.getNumberOfThreads() == tc1);
+    CHECK_EQ(w.getNumberOfThreads(), tc1);
 
     auto testForThreadCount = [&cb, &w](int const threadCount) {
         // Prepare the callback.
@@ -109,7 +109,7 @@ testThreads(int const tc1, int const tc2, int const tc3)
 
         // Execute the test.
         w.setNumberOfThreads(threadCount);
-        CHECK(w.getNumberOfThreads() == threadCount);
+        CHECK_EQ(w.getNumberOfThreads(), threadCount);
 
         for (int i = 0; i < threadCount; ++i)
             w.addTask();
@@ -119,8 +119,8 @@ testThreads(int const tc1, int const tc2, int const tc3)
         std::unique_lock<std::mutex> lk{cb.mut};
         bool const signaled =
             cb.cv.wait_for(lk, 10s, [&cb] { return cb.count == 0; });
-        CHECK(signaled);
-        CHECK(cb.count == 0);
+        CHECK_UNARY(signaled);
+        CHECK_EQ(cb.count, 0);
     };
     testForThreadCount(tc1);
     testForThreadCount(tc2);
@@ -128,7 +128,7 @@ testThreads(int const tc1, int const tc2, int const tc3)
     w.stop();
 
     // We had better finished all our work!
-    CHECK(cb.count == 0);
+    CHECK_EQ(cb.count, 0);
 }
 
 }  // namespace

src/doctest/csf/BasicNetwork.cpp

@@ -70,31 +70,31 @@ TEST_CASE("BasicNetwork operations")
     pv.emplace_back(2);
     Scheduler scheduler;
     BasicNetwork<Peer*> net(scheduler);
-    CHECK(!net.connect(&pv[0], &pv[0]));
-    CHECK(net.connect(&pv[0], &pv[1], 1s));
-    CHECK(net.connect(&pv[1], &pv[2], 1s));
-    CHECK(!net.connect(&pv[0], &pv[1]));
+    CHECK_FALSE(net.connect(&pv[0], &pv[0]));
+    CHECK_UNARY(net.connect(&pv[0], &pv[1], 1s));
+    CHECK_UNARY(net.connect(&pv[1], &pv[2], 1s));
+    CHECK_FALSE(net.connect(&pv[0], &pv[1]));
     for (auto& peer : pv)
         peer.start(scheduler, net);
-    CHECK(scheduler.step_for(0s));
-    CHECK(scheduler.step_for(1s));
-    CHECK(scheduler.step());
-    CHECK(!scheduler.step());
-    CHECK(!scheduler.step_for(1s));
+    CHECK_UNARY(scheduler.step_for(0s));
+    CHECK_UNARY(scheduler.step_for(1s));
+    CHECK_UNARY(scheduler.step());
+    CHECK_FALSE(scheduler.step());
+    CHECK_FALSE(scheduler.step_for(1s));
     net.send(&pv[0], &pv[1], [] {});
     net.send(&pv[1], &pv[0], [] {});
-    CHECK(net.disconnect(&pv[0], &pv[1]));
-    CHECK(!net.disconnect(&pv[0], &pv[1]));
+    CHECK_UNARY(net.disconnect(&pv[0], &pv[1]));
+    CHECK_FALSE(net.disconnect(&pv[0], &pv[1]));
     for (;;)
     {
         auto const links = net.links(&pv[1]);
         if (links.empty())
             break;
-        CHECK(net.disconnect(&pv[1], links[0].target));
+        CHECK_UNARY(net.disconnect(&pv[1], links[0].target));
     }
-    CHECK(pv[0].set == std::set<int>({0, 2, 4}));
-    CHECK(pv[1].set == std::set<int>({1, 3}));
-    CHECK(pv[2].set == std::set<int>({2, 4}));
+    CHECK_EQ(pv[0].set, std::set<int>({0, 2, 4}));
+    CHECK_EQ(pv[1].set, std::set<int>({1, 3}));
+    CHECK_EQ(pv[2].set, std::set<int>({2, 4}));
 }
 
 TEST_CASE("BasicNetwork disconnect")
@@ -102,21 +102,21 @@ TEST_CASE("BasicNetwork disconnect")
     using namespace std::chrono_literals;
     Scheduler scheduler;
     BasicNetwork<int> net(scheduler);
-    CHECK(net.connect(0, 1, 1s));
-    CHECK(net.connect(0, 2, 2s));
+    CHECK_UNARY(net.connect(0, 1, 1s));
+    CHECK_UNARY(net.connect(0, 2, 2s));
 
     std::set<int> delivered;
     net.send(0, 1, [&]() { delivered.insert(1); });
     net.send(0, 2, [&]() { delivered.insert(2); });
 
-    scheduler.in(1000ms, [&]() { CHECK(net.disconnect(0, 2)); });
-    scheduler.in(1100ms, [&]() { CHECK(net.connect(0, 2)); });
+    scheduler.in(1000ms, [&]() { CHECK_UNARY(net.disconnect(0, 2)); });
+    scheduler.in(1100ms, [&]() { CHECK_UNARY(net.connect(0, 2)); });
 
     scheduler.step();
 
     // only the first message is delivered because the disconnect at 1 s
     // purges all pending messages from 0 to 2
-    CHECK(delivered == std::set<int>({1}));
+    CHECK_EQ(delivered, std::set<int>({1}));
 }
 
 TEST_SUITE_END();

src/doctest/csf/Digraph.cpp

@@ -15,21 +15,21 @@ TEST_CASE("Digraph basic operations")
     using Graph = Digraph<char, std::string>;
     Graph graph;
 
-    CHECK(!graph.connected('a', 'b'));
-    CHECK(!graph.edge('a', 'b'));
-    CHECK(!graph.disconnect('a', 'b'));
+    CHECK_FALSE(graph.connected('a', 'b'));
+    CHECK_FALSE(graph.edge('a', 'b'));
+    CHECK_FALSE(graph.disconnect('a', 'b'));
 
-    CHECK(graph.connect('a', 'b', "foobar"));
-    CHECK(graph.connected('a', 'b'));
-    CHECK(*graph.edge('a', 'b') == "foobar");
+    CHECK_UNARY(graph.connect('a', 'b', "foobar"));
+    CHECK_UNARY(graph.connected('a', 'b'));
+    CHECK_EQ(*graph.edge('a', 'b'), "foobar");
 
-    CHECK(!graph.connect('a', 'b', "repeat"));
-    CHECK(graph.disconnect('a', 'b'));
-    CHECK(graph.connect('a', 'b', "repeat"));
-    CHECK(graph.connected('a', 'b'));
-    CHECK(*graph.edge('a', 'b') == "repeat");
+    CHECK_FALSE(graph.connect('a', 'b', "repeat"));
+    CHECK_UNARY(graph.disconnect('a', 'b'));
+    CHECK_UNARY(graph.connect('a', 'b', "repeat"));
+    CHECK_UNARY(graph.connected('a', 'b'));
+    CHECK_EQ(*graph.edge('a', 'b'), "repeat");
 
-    CHECK(graph.connect('a', 'c', "tree"));
+    CHECK_UNARY(graph.connect('a', 'c', "tree"));
 
     {
         std::vector<std::tuple<char, char, std::string>> edges;
@@ -42,22 +42,22 @@ TEST_CASE("Digraph basic operations")
         std::vector<std::tuple<char, char, std::string>> expected;
         expected.emplace_back('a', 'b', "repeat");
         expected.emplace_back('a', 'c', "tree");
-        CHECK(edges == expected);
-        CHECK(graph.outDegree('a') == expected.size());
+        CHECK_EQ(edges, expected);
+        CHECK_EQ(graph.outDegree('a'), expected.size());
     }
 
-    CHECK(graph.outEdges('r').size() == 0);
-    CHECK(graph.outDegree('r') == 0);
-    CHECK(graph.outDegree('c') == 0);
+    CHECK_EQ(graph.outEdges('r').size(), 0);
+    CHECK_EQ(graph.outDegree('r'), 0);
+    CHECK_EQ(graph.outDegree('c'), 0);
 
     // only 'a' has out edges
-    CHECK(graph.outVertices().size() == 1);
+    CHECK_EQ(graph.outVertices().size(), 1);
     std::vector<char> expected = {'b', 'c'};
 
-    CHECK((graph.outVertices('a') == expected));
-    CHECK(graph.outVertices('b').size() == 0);
-    CHECK(graph.outVertices('c').size() == 0);
-    CHECK(graph.outVertices('r').size() == 0);
+    CHECK_EQ(graph.outVertices('a'), expected);
+    CHECK_EQ(graph.outVertices('b').size(), 0);
+    CHECK_EQ(graph.outVertices('c').size(), 0);
+    CHECK_EQ(graph.outVertices('r').size(), 0);
 
     std::stringstream ss;
     graph.saveDot(ss, [](char v) { return v; });
@@ -66,7 +66,7 @@ TEST_CASE("Digraph basic operations")
         "a -> b;\n"
         "a -> c;\n"
         "}\n";
-    CHECK(ss.str() == expectedDot);
+    CHECK_EQ(ss.str(), expectedDot);
 }
 
 TEST_SUITE_END();

src/doctest/csf/Histogram.cpp

@@ -10,15 +10,15 @@ TEST_CASE("Histogram empty")
 {
     Histogram<int> hist;
 
-    CHECK(hist.size() == 0);
-    CHECK(hist.numBins() == 0);
-    CHECK(hist.minValue() == 0);
-    CHECK(hist.maxValue() == 0);
-    CHECK(hist.avg() == 0);
-    CHECK(hist.percentile(0.0f) == hist.minValue());
-    CHECK(hist.percentile(0.5f) == 0);
-    CHECK(hist.percentile(0.9f) == 0);
-    CHECK(hist.percentile(1.0f) == hist.maxValue());
+    CHECK_EQ(hist.size(), 0);
+    CHECK_EQ(hist.numBins(), 0);
+    CHECK_EQ(hist.minValue(), 0);
+    CHECK_EQ(hist.maxValue(), 0);
+    CHECK_EQ(hist.avg(), 0);
+    CHECK_EQ(hist.percentile(0.0f), hist.minValue());
+    CHECK_EQ(hist.percentile(0.5f), 0);
+    CHECK_EQ(hist.percentile(0.9f), 0);
+    CHECK_EQ(hist.percentile(1.0f), hist.maxValue());
 }
 
 TEST_CASE("Histogram single element")
@@ -26,15 +26,15 @@ TEST_CASE("Histogram single element")
     Histogram<int> hist;
     hist.insert(1);
 
-    CHECK(hist.size() == 1);
-    CHECK(hist.numBins() == 1);
-    CHECK(hist.minValue() == 1);
-    CHECK(hist.maxValue() == 1);
-    CHECK(hist.avg() == 1);
-    CHECK(hist.percentile(0.0f) == hist.minValue());
-    CHECK(hist.percentile(0.5f) == 1);
-    CHECK(hist.percentile(0.9f) == 1);
-    CHECK(hist.percentile(1.0f) == hist.maxValue());
+    CHECK_EQ(hist.size(), 1);
+    CHECK_EQ(hist.numBins(), 1);
+    CHECK_EQ(hist.minValue(), 1);
+    CHECK_EQ(hist.maxValue(), 1);
+    CHECK_EQ(hist.avg(), 1);
+    CHECK_EQ(hist.percentile(0.0f), hist.minValue());
+    CHECK_EQ(hist.percentile(0.5f), 1);
+    CHECK_EQ(hist.percentile(0.9f), 1);
+    CHECK_EQ(hist.percentile(1.0f), hist.maxValue());
 }
 
 TEST_CASE("Histogram two elements")
@@ -43,15 +43,15 @@ TEST_CASE("Histogram two elements")
     hist.insert(1);
     hist.insert(9);
 
-    CHECK(hist.size() == 2);
-    CHECK(hist.numBins() == 2);
-    CHECK(hist.minValue() == 1);
-    CHECK(hist.maxValue() == 9);
-    CHECK(hist.avg() == 5);
-    CHECK(hist.percentile(0.0f) == hist.minValue());
-    CHECK(hist.percentile(0.5f) == 1);
-    CHECK(hist.percentile(0.9f) == 9);
-    CHECK(hist.percentile(1.0f) == hist.maxValue());
+    CHECK_EQ(hist.size(), 2);
+    CHECK_EQ(hist.numBins(), 2);
+    CHECK_EQ(hist.minValue(), 1);
+    CHECK_EQ(hist.maxValue(), 9);
+    CHECK_EQ(hist.avg(), 5);
+    CHECK_EQ(hist.percentile(0.0f), hist.minValue());
+    CHECK_EQ(hist.percentile(0.5f), 1);
+    CHECK_EQ(hist.percentile(0.9f), 9);
+    CHECK_EQ(hist.percentile(1.0f), hist.maxValue());
 }
 
 TEST_CASE("Histogram duplicate elements")
@@ -61,15 +61,15 @@ TEST_CASE("Histogram duplicate elements")
     hist.insert(9);
     hist.insert(1);
 
-    CHECK(hist.size() == 3);
-    CHECK(hist.numBins() == 2);
-    CHECK(hist.minValue() == 1);
-    CHECK(hist.maxValue() == 9);
-    CHECK(hist.avg() == 11 / 3);
-    CHECK(hist.percentile(0.0f) == hist.minValue());
-    CHECK(hist.percentile(0.5f) == 1);
-    CHECK(hist.percentile(0.9f) == 9);
-    CHECK(hist.percentile(1.0f) == hist.maxValue());
+    CHECK_EQ(hist.size(), 3);
+    CHECK_EQ(hist.numBins(), 2);
+    CHECK_EQ(hist.minValue(), 1);
+    CHECK_EQ(hist.maxValue(), 9);
+    CHECK_EQ(hist.avg(), 11 / 3);
+    CHECK_EQ(hist.percentile(0.0f), hist.minValue());
+    CHECK_EQ(hist.percentile(0.5f), 1);
+    CHECK_EQ(hist.percentile(0.9f), 9);
+    CHECK_EQ(hist.percentile(1.0f), hist.maxValue());
 }
 
 TEST_SUITE_END();

src/doctest/csf/Scheduler.cpp

@@ -23,41 +23,41 @@ TEST_CASE("Scheduler basic operations")
     auto start = scheduler.now();
 
     // Process first event
-    CHECK(seen.empty());
-    CHECK(scheduler.step_one());
-    CHECK(seen == std::set<int>({1}));
-    CHECK(scheduler.now() == (start + 1s));
+    CHECK_UNARY(seen.empty());
+    CHECK_UNARY(scheduler.step_one());
+    CHECK_EQ(seen, std::set<int>({1}));
+    CHECK_EQ(scheduler.now(), start + 1s);
 
     // No processing if stepping until current time
-    CHECK(scheduler.step_until(scheduler.now()));
-    CHECK(seen == std::set<int>({1}));
-    CHECK(scheduler.now() == (start + 1s));
+    CHECK_UNARY(scheduler.step_until(scheduler.now()));
+    CHECK_EQ(seen, std::set<int>({1}));
+    CHECK_EQ(scheduler.now(), start + 1s);
 
     // Process next event
-    CHECK(scheduler.step_for(1s));
-    CHECK(seen == std::set<int>({1, 2}));
-    CHECK(scheduler.now() == (start + 2s));
+    CHECK_UNARY(scheduler.step_for(1s));
+    CHECK_EQ(seen, std::set<int>({1, 2}));
+    CHECK_EQ(scheduler.now(), start + 2s);
 
     // Don't process cancelled event, but advance clock
     scheduler.cancel(token);
-    CHECK(scheduler.step_for(1s));
-    CHECK(seen == std::set<int>({1, 2}));
-    CHECK(scheduler.now() == (start + 3s));
+    CHECK_UNARY(scheduler.step_for(1s));
+    CHECK_EQ(seen, std::set<int>({1, 2}));
+    CHECK_EQ(scheduler.now(), start + 3s);
 
     // Process until 3 seen ints
-    CHECK(scheduler.step_while([&]() { return seen.size() < 3; }));
-    CHECK(seen == std::set<int>({1, 2, 4}));
-    CHECK(scheduler.now() == (start + 4s));
+    CHECK_UNARY(scheduler.step_while([&]() { return seen.size() < 3; }));
+    CHECK_EQ(seen, std::set<int>({1, 2, 4}));
+    CHECK_EQ(scheduler.now(), start + 4s);
 
     // Process the rest
-    CHECK(scheduler.step());
-    CHECK(seen == std::set<int>({1, 2, 4, 8}));
-    CHECK(scheduler.now() == (start + 8s));
+    CHECK_UNARY(scheduler.step());
+    CHECK_EQ(seen, std::set<int>({1, 2, 4, 8}));
+    CHECK_EQ(scheduler.now(), start + 8s);
 
     // Process the rest again doesn't advance
-    CHECK(!scheduler.step());
-    CHECK(seen == std::set<int>({1, 2, 4, 8}));
-    CHECK(scheduler.now() == (start + 8s));
+    CHECK_FALSE(scheduler.step());
+    CHECK_EQ(seen, std::set<int>({1, 2, 4, 8}));
+    CHECK_EQ(scheduler.now(), start + 8s);
 }
 
 TEST_SUITE_END();

src/doctest/nodestore/varint.cpp

@@ -34,12 +34,12 @@ TEST_CASE("encode, decode")
     {
         std::array<std::uint8_t, varint_traits<std::size_t>::max> vi;
         auto const n0 = write_varint(vi.data(), v);
-        CHECK(n0 > 0);
-        CHECK(n0 == size_varint(v));
+        CHECK_GT(n0, 0);
+        CHECK_EQ(n0, size_varint(v));
         std::size_t v1;
         auto const n1 = read_varint(vi.data(), n0, v1);
-        CHECK(n1 == n0);
-        CHECK(v == v1);
+        CHECK_EQ(n1, n0);
+        CHECK_EQ(v, v1);
     }
 }
 

src/doctest/protocol/BuildInfo.cpp

@@ -12,15 +12,15 @@ TEST_CASE("EncodeSoftwareVersion")
 
     SUBCASE("first two bytes identify the particular implementation, 0x183B")
     {
-        CHECK(
-            (encodedVersion & 0xFFFF'0000'0000'0000LLU) ==
+        CHECK_EQ(
+            (encodedVersion & 0xFFFF'0000'0000'0000LLU),
             0x183B'0000'0000'0000LLU);
     }
 
     SUBCASE("next three bytes: major, minor, patch version")
     {
-        CHECK(
-            (encodedVersion & 0x0000'FFFF'FF00'0000LLU) ==
+        CHECK_EQ(
+            (encodedVersion & 0x0000'FFFF'FF00'0000LLU),
             0x0000'0102'0300'0000LLU);
     }
 
@@ -28,46 +28,46 @@ TEST_CASE("EncodeSoftwareVersion")
     {
         // 01 if a beta
         auto betaBits = (encodedVersion & 0x0000'0000'00C0'0000LLU) >> 22;
-        CHECK(betaBits == 0b01);
+        CHECK_EQ(betaBits, 0b01);
 
         // 10 if an RC
         auto rcVersion = BuildInfo::encodeSoftwareVersion("1.2.4-rc7");
         auto rcBits = (rcVersion & 0x0000'0000'00C0'0000LLU) >> 22;
-        CHECK(rcBits == 0b10);
+        CHECK_EQ(rcBits, 0b10);
 
         // 11 if neither an RC nor a beta
         auto releaseVersion = BuildInfo::encodeSoftwareVersion("1.2.5");
         auto releaseBits = (releaseVersion & 0x0000'0000'00C0'0000LLU) >> 22;
-        CHECK(releaseBits == 0b11);
+        CHECK_EQ(releaseBits, 0b11);
     }
 
     SUBCASE("next six bits: rc/beta number (1-63)")
     {
         auto v = BuildInfo::encodeSoftwareVersion("1.2.6-b63");
         auto betaNum = (v & 0x0000'0000'003F'0000LLU) >> 16;
-        CHECK(betaNum == 63);
+        CHECK_EQ(betaNum, 63);
     }
 
     SUBCASE("last two bytes are zeros")
     {
-        CHECK((encodedVersion & 0x0000'0000'0000'FFFFLLU) == 0);
+        CHECK_EQ((encodedVersion & 0x0000'0000'0000'FFFFLLU), 0);
     }
 
     SUBCASE("wrong format version strings")
     {
         // no rc/beta number
         auto v1 = BuildInfo::encodeSoftwareVersion("1.2.3-b");
-        CHECK((v1 & 0x0000'0000'00FF'0000LLU) == 0);
+        CHECK_EQ((v1 & 0x0000'0000'00FF'0000LLU), 0);
 
         // rc/beta number out of range
         auto v2 = BuildInfo::encodeSoftwareVersion("1.2.3-b64");
-        CHECK((v2 & 0x0000'0000'00FF'0000LLU) == 0);
+        CHECK_EQ((v2 & 0x0000'0000'00FF'0000LLU), 0);
     }
 
     SUBCASE("rc/beta number of a release is 0")
     {
         auto v = BuildInfo::encodeSoftwareVersion("1.2.6");
-        CHECK((v & 0x0000'0000'003F'0000LLU) == 0);
+        CHECK_EQ((v & 0x0000'0000'003F'0000LLU), 0);
     }
 }
 

src/doctest/protocol/Issue.cpp

@@ -41,23 +41,23 @@ testUnsigned()
     Unsigned const u2(2);
     Unsigned const u3(3);
 
-    CHECK(u1 != u2);
-    CHECK(u1 < u2);
-    CHECK(u1 <= u2);
-    CHECK(u2 <= u2);
-    CHECK(u2 == u2);
-    CHECK(u2 >= u2);
-    CHECK(u3 >= u2);
-    CHECK(u3 > u2);
+    CHECK_NE(u1, u2);
+    CHECK_LT(u1, u2);
+    CHECK_LE(u1, u2);
+    CHECK_LE(u2, u2);
+    CHECK_EQ(u2, u2);
+    CHECK_GE(u2, u2);
+    CHECK_GE(u3, u2);
+    CHECK_GT(u3, u2);
 
     std::hash<Unsigned> hash;
 
-    CHECK(hash(u1) == hash(u1));
-    CHECK(hash(u2) == hash(u2));
-    CHECK(hash(u3) == hash(u3));
-    CHECK(hash(u1) != hash(u2));
-    CHECK(hash(u1) != hash(u3));
-    CHECK(hash(u2) != hash(u3));
+    CHECK_EQ(hash(u1), hash(u1));
+    CHECK_EQ(hash(u2), hash(u2));
+    CHECK_EQ(hash(u3), hash(u3));
+    CHECK_NE(hash(u1), hash(u2));
+    CHECK_NE(hash(u1), hash(u3));
+    CHECK_NE(hash(u2), hash(u3));
 }
 
 // Comparison, hash tests for Issue
@@ -72,42 +72,42 @@ testIssue()
     Currency const c3(3);
     AccountID const i3(3);
 
-    CHECK(IssueType(c1, i1) != IssueType(c2, i1));
-    CHECK(IssueType(c1, i1) < IssueType(c2, i1));
-    CHECK(IssueType(c1, i1) <= IssueType(c2, i1));
-    CHECK(IssueType(c2, i1) <= IssueType(c2, i1));
-    CHECK(IssueType(c2, i1) == IssueType(c2, i1));
-    CHECK(IssueType(c2, i1) >= IssueType(c2, i1));
-    CHECK(IssueType(c3, i1) >= IssueType(c2, i1));
-    CHECK(IssueType(c3, i1) > IssueType(c2, i1));
-    CHECK(IssueType(c1, i1) != IssueType(c1, i2));
-    CHECK(IssueType(c1, i1) < IssueType(c1, i2));
-    CHECK(IssueType(c1, i1) <= IssueType(c1, i2));
-    CHECK(IssueType(c1, i2) <= IssueType(c1, i2));
-    CHECK(IssueType(c1, i2) == IssueType(c1, i2));
-    CHECK(IssueType(c1, i2) >= IssueType(c1, i2));
-    CHECK(IssueType(c1, i3) >= IssueType(c1, i2));
-    CHECK(IssueType(c1, i3) > IssueType(c1, i2));
+    CHECK_NE(IssueType(c1, i1), IssueType(c2, i1));
+    CHECK_LT(IssueType(c1, i1), IssueType(c2, i1));
+    CHECK_LE(IssueType(c1, i1), IssueType(c2, i1));
+    CHECK_LE(IssueType(c2, i1), IssueType(c2, i1));
+    CHECK_EQ(IssueType(c2, i1), IssueType(c2, i1));
+    CHECK_GE(IssueType(c2, i1), IssueType(c2, i1));
+    CHECK_GE(IssueType(c3, i1), IssueType(c2, i1));
+    CHECK_GT(IssueType(c3, i1), IssueType(c2, i1));
+    CHECK_NE(IssueType(c1, i1), IssueType(c1, i2));
+    CHECK_LT(IssueType(c1, i1), IssueType(c1, i2));
+    CHECK_LE(IssueType(c1, i1), IssueType(c1, i2));
+    CHECK_LE(IssueType(c1, i2), IssueType(c1, i2));
+    CHECK_EQ(IssueType(c1, i2), IssueType(c1, i2));
+    CHECK_GE(IssueType(c1, i2), IssueType(c1, i2));
+    CHECK_GE(IssueType(c1, i3), IssueType(c1, i2));
+    CHECK_GT(IssueType(c1, i3), IssueType(c1, i2));
 
     std::hash<IssueType> hash;
 
-    CHECK(hash(IssueType(c1, i1)) == hash(IssueType(c1, i1)));
-    CHECK(hash(IssueType(c1, i2)) == hash(IssueType(c1, i2)));
-    CHECK(hash(IssueType(c1, i3)) == hash(IssueType(c1, i3)));
-    CHECK(hash(IssueType(c2, i1)) == hash(IssueType(c2, i1)));
-    CHECK(hash(IssueType(c2, i2)) == hash(IssueType(c2, i2)));
-    CHECK(hash(IssueType(c2, i3)) == hash(IssueType(c2, i3)));
-    CHECK(hash(IssueType(c3, i1)) == hash(IssueType(c3, i1)));
-    CHECK(hash(IssueType(c3, i2)) == hash(IssueType(c3, i2)));
-    CHECK(hash(IssueType(c3, i3)) == hash(IssueType(c3, i3)));
-    CHECK(hash(IssueType(c1, i1)) != hash(IssueType(c1, i2)));
-    CHECK(hash(IssueType(c1, i1)) != hash(IssueType(c1, i3)));
-    CHECK(hash(IssueType(c1, i1)) != hash(IssueType(c2, i1)));
-    CHECK(hash(IssueType(c1, i1)) != hash(IssueType(c2, i2)));
-    CHECK(hash(IssueType(c1, i1)) != hash(IssueType(c2, i3)));
-    CHECK(hash(IssueType(c1, i1)) != hash(IssueType(c3, i1)));
-    CHECK(hash(IssueType(c1, i1)) != hash(IssueType(c3, i2)));
-    CHECK(hash(IssueType(c1, i1)) != hash(IssueType(c3, i3)));
+    CHECK_EQ(hash(IssueType(c1, i1)), hash(IssueType(c1, i1)));
+    CHECK_EQ(hash(IssueType(c1, i2)), hash(IssueType(c1, i2)));
+    CHECK_EQ(hash(IssueType(c1, i3)), hash(IssueType(c1, i3)));
+    CHECK_EQ(hash(IssueType(c2, i1)), hash(IssueType(c2, i1)));
+    CHECK_EQ(hash(IssueType(c2, i2)), hash(IssueType(c2, i2)));
+    CHECK_EQ(hash(IssueType(c2, i3)), hash(IssueType(c2, i3)));
+    CHECK_EQ(hash(IssueType(c3, i1)), hash(IssueType(c3, i1)));
+    CHECK_EQ(hash(IssueType(c3, i2)), hash(IssueType(c3, i2)));
+    CHECK_EQ(hash(IssueType(c3, i3)), hash(IssueType(c3, i3)));
+    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c1, i2)));
+    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c1, i3)));
+    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c2, i1)));
+    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c2, i2)));
+    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c2, i3)));
+    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c3, i1)));
+    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c3, i2)));
+    CHECK_NE(hash(IssueType(c1, i1)), hash(IssueType(c3, i3)));
 }
 
 template <class Set>

src/doctest/protocol/MultiApiJson.cpp

@@ -48,10 +48,10 @@ TEST_CASE("forApiVersions, forAllApiVersions")
     static_assert(
         std::is_same_v<decltype(subject.val), std::array<Json::Value, 3>>);
 
-    CHECK(subject.val.size() == 3);
-    CHECK(
-        (subject.val ==
-         std::array<Json::Value, 3>{jsonNull, jsonNull, jsonNull}));
+    CHECK_EQ(subject.val.size(), 3);
+    CHECK_EQ(
+        subject.val,
+        (std::array<Json::Value, 3>{jsonNull, jsonNull, jsonNull}));
 
     subject.val[0] = obj1;
     subject.val[1] = obj2;
@@ -73,15 +73,15 @@ TEST_CASE("forApiVersions, forAllApiVersions")
          ++i)
     {
         auto const index = i - RPC::apiMinimumSupportedVersion;
-        CHECK(index == s1.index(i));
-        CHECK(s1.valid(i));
+        CHECK_EQ(index, s1.index(i));
+        CHECK_UNARY(s1.valid(i));
         s1.val[index] = makeJson("value", primes[i]);
         productAllVersions *= primes[i];
     }
-    CHECK(!s1.valid(0));
-    CHECK(!s1.valid(RPC::apiMaximumValidVersion + 1));
-    CHECK(!s1.valid(std::numeric_limits<
-                    decltype(RPC::apiMaximumValidVersion.value)>::max()));
+    CHECK_FALSE(s1.valid(0));
+    CHECK_FALSE(s1.valid(RPC::apiMaximumValidVersion + 1));
+    CHECK_FALSE(s1.valid(std::numeric_limits<
+                         decltype(RPC::apiMaximumValidVersion.value)>::max()));
 
     int result = 1;
     static_assert(
@@ -91,25 +91,25 @@ TEST_CASE("forApiVersions, forAllApiVersions")
         RPC::apiMinimumSupportedVersion + 1>(
         std::as_const(s1).visit(),
         [](Json::Value const& json, unsigned int version, int* result) {
-            CHECK(version >= RPC::apiMinimumSupportedVersion);
-            CHECK(version <= RPC::apiMinimumSupportedVersion + 1);
+            CHECK_GE(version, RPC::apiMinimumSupportedVersion);
+            CHECK_LE(version, RPC::apiMinimumSupportedVersion + 1);
             if (json.isMember("value"))
             {
                 *result *= json["value"].asInt();
             }
         },
         &result);
-    CHECK(
-        result ==
+    CHECK_EQ(
+        result,
         primes[RPC::apiMinimumSupportedVersion] *
             primes[RPC::apiMinimumSupportedVersion + 1]);
 
     // Check all the values with mutable data
     forAllApiVersions(s1.visit(), [&s1](Json::Value& json, auto version) {
-        CHECK(s1.val[s1.index(version)] == json);
+        CHECK_EQ(s1.val[s1.index(version)], json);
         if (json.isMember("value"))
         {
-            CHECK(json["value"].asInt() == primes[version]);
+            CHECK_EQ(json["value"].asInt(), primes[version]);
         }
     });
 
@@ -117,8 +117,8 @@ TEST_CASE("forApiVersions, forAllApiVersions")
     forAllApiVersions(
         std::as_const(s1).visit(),
         [](Json::Value const& json, unsigned int version, int* result) {
-            CHECK(version >= RPC::apiMinimumSupportedVersion);
-            CHECK(version <= RPC::apiMaximumValidVersion);
+            CHECK_GE(version, RPC::apiMinimumSupportedVersion);
+            CHECK_LE(version, RPC::apiMaximumValidVersion);
             if (json.isMember("value"))
             {
                 *result *= json["value"].asInt();
@@ -126,7 +126,7 @@ TEST_CASE("forApiVersions, forAllApiVersions")
         },
         &result);
 
-    CHECK(result == productAllVersions);
+    CHECK_EQ(result, productAllVersions);
 
     // Several overloads we want to fail
     static_assert([](auto&& v) {
@@ -256,28 +256,28 @@ TEST_CASE("default copy construction / assignment")
 
     MultiApiJson<1, 3> x{subject};
 
-    CHECK(x.val.size() == subject.val.size());
-    CHECK(x.val[0] == subject.val[0]);
-    CHECK(x.val[1] == subject.val[1]);
-    CHECK(x.val[2] == subject.val[2]);
-    CHECK(x.val == subject.val);
-    CHECK(&x.val[0] != &subject.val[0]);
-    CHECK(&x.val[1] != &subject.val[1]);
-    CHECK(&x.val[2] != &subject.val[2]);
+    CHECK_EQ(x.val.size(), subject.val.size());
+    CHECK_EQ(x.val[0], subject.val[0]);
+    CHECK_EQ(x.val[1], subject.val[1]);
+    CHECK_EQ(x.val[2], subject.val[2]);
+    CHECK_EQ(x.val, subject.val);
+    CHECK_NE(&x.val[0], &subject.val[0]);
+    CHECK_NE(&x.val[1], &subject.val[1]);
+    CHECK_NE(&x.val[2], &subject.val[2]);
 
     MultiApiJson<1, 3> y;
-    CHECK((y.val == std::array<Json::Value, 3>{}));
+    CHECK_EQ(y.val, (std::array<Json::Value, 3>{}));
     y = subject;
-    CHECK(y.val == subject.val);
-    CHECK(&y.val[0] != &subject.val[0]);
-    CHECK(&y.val[1] != &subject.val[1]);
-    CHECK(&y.val[2] != &subject.val[2]);
+    CHECK_EQ(y.val, subject.val);
+    CHECK_NE(&y.val[0], &subject.val[0]);
+    CHECK_NE(&y.val[1], &subject.val[1]);
+    CHECK_NE(&y.val[2], &subject.val[2]);
 
     y = std::move(x);
-    CHECK(y.val == subject.val);
-    CHECK(&y.val[0] != &subject.val[0]);
-    CHECK(&y.val[1] != &subject.val[1]);
-    CHECK(&y.val[2] != &subject.val[2]);
+    CHECK_EQ(y.val, subject.val);
+    CHECK_NE(&y.val[0], &subject.val[0]);
+    CHECK_NE(&y.val[1], &subject.val[1]);
+    CHECK_NE(&y.val[2], &subject.val[2]);
 }
 
 TEST_CASE("set")
@@ -286,20 +286,20 @@ TEST_CASE("set")
 
     auto x = MultiApiJson<1, 2>{Json::objectValue};
     x.set("name1", 42);
-    CHECK(x.val[0].isMember("name1"));
-    CHECK(x.val[1].isMember("name1"));
-    CHECK(x.val[0]["name1"].isInt());
-    CHECK(x.val[1]["name1"].isInt());
-    CHECK(x.val[0]["name1"].asInt() == 42);
-    CHECK(x.val[1]["name1"].asInt() == 42);
+    CHECK_UNARY(x.val[0].isMember("name1"));
+    CHECK_UNARY(x.val[1].isMember("name1"));
+    CHECK_UNARY(x.val[0]["name1"].isInt());
+    CHECK_UNARY(x.val[1]["name1"].isInt());
+    CHECK_EQ(x.val[0]["name1"].asInt(), 42);
+    CHECK_EQ(x.val[1]["name1"].asInt(), 42);
 
     x.set("name2", "bar");
-    CHECK(x.val[0].isMember("name2"));
-    CHECK(x.val[1].isMember("name2"));
-    CHECK(x.val[0]["name2"].isString());
-    CHECK(x.val[1]["name2"].isString());
-    CHECK(x.val[0]["name2"].asString() == "bar");
-    CHECK(x.val[1]["name2"].asString() == "bar");
+    CHECK_UNARY(x.val[0].isMember("name2"));
+    CHECK_UNARY(x.val[1].isMember("name2"));
+    CHECK_UNARY(x.val[0]["name2"].isString());
+    CHECK_UNARY(x.val[1]["name2"].isString());
+    CHECK_EQ(x.val[0]["name2"].asString(), "bar");
+    CHECK_EQ(x.val[1]["name2"].asString(), "bar");
 
     // Tests of requires clause - these are expected to match
     static_assert([](auto&& v) {
@@ -333,15 +333,15 @@ TEST_CASE("isMember")
     subject.val[1] = obj2;
 
     // Well defined behaviour even if we have different types of members
-    CHECK(subject.isMember("foo") == decltype(subject)::none);
+    CHECK_EQ(subject.isMember("foo"), decltype(subject)::none);
 
     {
         // All variants have element "One", none have element "Two"
         MultiApiJson<1, 2> s1{};
         s1.val[0] = makeJson("One", 12);
         s1.val[1] = makeJson("One", 42);
-        CHECK(s1.isMember("One") == decltype(s1)::all);
-        CHECK(s1.isMember("Two") == decltype(s1)::none);
+        CHECK_EQ(s1.isMember("One"), decltype(s1)::all);
+        CHECK_EQ(s1.isMember("Two"), decltype(s1)::none);
     }
 
     {
@@ -349,8 +349,8 @@ TEST_CASE("isMember")
         MultiApiJson<1, 2> s2{};
         s2.val[0] = makeJson("One", 12);
         s2.val[1] = makeJson("Two", 42);
-        CHECK(s2.isMember("One") == decltype(s2)::some);
-        CHECK(s2.isMember("Two") == decltype(s2)::some);
+        CHECK_EQ(s2.isMember("One"), decltype(s2)::some);
+        CHECK_EQ(s2.isMember("Two"), decltype(s2)::some);
     }
 
     {
@@ -358,8 +358,8 @@ TEST_CASE("isMember")
         MultiApiJson<1, 3> s3{};
         s3.val[0] = makeJson("One", 12);
         s3.val[1] = makeJson("One", 42);
-        CHECK(s3.isMember("One") == decltype(s3)::some);
-        CHECK(s3.isMember("Two") == decltype(s3)::none);
+        CHECK_EQ(s3.isMember("One"), decltype(s3)::some);
+        CHECK_EQ(s3.isMember("Two"), decltype(s3)::none);
     }
 }
 
@@ -372,13 +372,13 @@ TEST_CASE("visitor")
     s1.val[1] = makeJson("value", 3);
     s1.val[2] = makeJson("value", 5);
 
-    CHECK(not s1.valid(0));
-    CHECK(s1.index(0) == 0);
+    CHECK_UNARY_FALSE(s1.valid(0));
+    CHECK_EQ(s1.index(0), 0);
 
-    CHECK(s1.valid(1));
-    CHECK(s1.index(1) == 0);
+    CHECK_UNARY(s1.valid(1));
+    CHECK_EQ(s1.index(1), 0);
 
-    CHECK(not s1.valid(4));
+    CHECK_UNARY_FALSE(s1.valid(4));
 
     // Test different overloads
     static_assert([](auto&& v) {
@@ -389,7 +389,7 @@ TEST_CASE("visitor")
                 [](Json::Value&, std::integral_constant<unsigned, 1>) {});
         };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             s1,
             std::integral_constant<unsigned, 1>{},
@@ -398,7 +398,8 @@ TEST_CASE("visitor")
                     return v["value"].asInt();
                 },
                 [](Json::Value const&, auto) { return 0; },
-                [](auto, auto) { return 0; }}) == 2);
+                [](auto, auto) { return 0; }}),
+        2);
 
     static_assert([](auto&& v) {
         return requires {
@@ -406,14 +407,15 @@ TEST_CASE("visitor")
                 v, std::integral_constant<unsigned, 1>{}, [](Json::Value&) {});
         };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             s1,
             std::integral_constant<unsigned, 1>{},
             Overload{
                 [](Json::Value& v) { return v["value"].asInt(); },
                 [](Json::Value const&) { return 0; },
-                [](auto...) { return 0; }}) == 2);
+                [](auto...) { return 0; }}),
+        2);
 
     static_assert([](auto&& v) {
         return requires {
@@ -423,7 +425,7 @@ TEST_CASE("visitor")
                 [](Json::Value const&, std::integral_constant<unsigned, 1>) {});
         };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             std::as_const(s1),
             std::integral_constant<unsigned, 2>{},
@@ -432,7 +434,8 @@ TEST_CASE("visitor")
                     return v["value"].asInt();
                 },
                 [](Json::Value&, auto) { return 0; },
-                [](auto, auto) { return 0; }}) == 3);
+                [](auto, auto) { return 0; }}),
+        3);
 
     static_assert([](auto&& v) {
         return requires {
@@ -442,45 +445,48 @@ TEST_CASE("visitor")
                 [](Json::Value const&) {});
         };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             std::as_const(s1),
             std::integral_constant<unsigned, 2>{},
             Overload{
                 [](Json::Value const& v) { return v["value"].asInt(); },
                 [](Json::Value&) { return 0; },
-                [](auto...) { return 0; }}) == 3);
+                [](auto...) { return 0; }}),
+        3);
 
     static_assert([](auto&& v) {
         return requires { v.visitor(v, 1, [](Json::Value&, unsigned) {}); };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             s1,  //
             3u,
             Overload{
                 [](Json::Value& v, unsigned) { return v["value"].asInt(); },
                 [](Json::Value const&, unsigned) { return 0; },
-                [](auto, auto) { return 0; }}) == 5);
+                [](auto, auto) { return 0; }}),
+        5);
 
     static_assert([](auto&& v) {
         return requires { v.visitor(v, 1, [](Json::Value&) {}); };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             s1,  //
             3,
             Overload{
                 [](Json::Value& v) { return v["value"].asInt(); },
                 [](Json::Value const&) { return 0; },
-                [](auto...) { return 0; }}) == 5);
+                [](auto...) { return 0; }}),
+        5);
 
     static_assert([](auto&& v) {
         return requires {
             v.visitor(v, 1, [](Json::Value const&, unsigned) {});
         };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             std::as_const(s1),  //
             2u,
@@ -489,84 +495,92 @@ TEST_CASE("visitor")
                     return v["value"].asInt();
                 },
                 [](Json::Value const&, auto) { return 0; },
-                [](auto, auto) { return 0; }}) == 3);
+                [](auto, auto) { return 0; }}),
+        3);
 
     static_assert([](auto&& v) {
         return requires { v.visitor(v, 1, [](Json::Value const&) {}); };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             std::as_const(s1),  //
             2,
             Overload{
                 [](Json::Value const& v) { return v["value"].asInt(); },
                 [](Json::Value&) { return 0; },
-                [](auto...) { return 0; }}) == 3);
+                [](auto...) { return 0; }}),
+        3);
 
     // Test type conversions
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             s1,
             std::integral_constant<unsigned, 1>{},  // to unsigned
-            [](Json::Value& v, unsigned) { return v["value"].asInt(); }) == 2);
-    CHECK(
+            [](Json::Value& v, unsigned) { return v["value"].asInt(); }),
+        2);
+    CHECK_EQ(
         s1.visitor(
             std::as_const(s1),
             std::integral_constant<unsigned, 2>{},  // to unsigned
-            [](Json::Value const& v, unsigned) {
-                return v["value"].asInt();
-            }) == 3);
-    CHECK(
+            [](Json::Value const& v, unsigned) { return v["value"].asInt(); }),
+        3);
+    CHECK_EQ(
         s1.visitor(
             s1,  // to const
             std::integral_constant<unsigned, 3>{},
-            [](Json::Value const& v, auto) { return v["value"].asInt(); }) ==
+            [](Json::Value const& v, auto) { return v["value"].asInt(); }),
         5);
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             s1,  // to const
             std::integral_constant<unsigned, 3>{},
-            [](Json::Value const& v) { return v["value"].asInt(); }) == 5);
-    CHECK(
+            [](Json::Value const& v) { return v["value"].asInt(); }),
+        5);
+    CHECK_EQ(
         s1.visitor(
             s1,
             3,  // to long
-            [](Json::Value& v, long) { return v["value"].asInt(); }) == 5);
-    CHECK(
+            [](Json::Value& v, long) { return v["value"].asInt(); }),
+        5);
+    CHECK_EQ(
         s1.visitor(
             std::as_const(s1),
             1,  // to long
-            [](Json::Value const& v, long) { return v["value"].asInt(); }) ==
+            [](Json::Value const& v, long) { return v["value"].asInt(); }),
         2);
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             s1,  // to const
             2,
-            [](Json::Value const& v, auto) { return v["value"].asInt(); }) ==
+            [](Json::Value const& v, auto) { return v["value"].asInt(); }),
         3);
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             s1,  // type deduction
             2,
-            [](auto& v, auto) { return v["value"].asInt(); }) == 3);
-    CHECK(
+            [](auto& v, auto) { return v["value"].asInt(); }),
+        3);
+    CHECK_EQ(
         s1.visitor(
             s1,  // to const, type deduction
             2,
-            [](auto const& v, auto) { return v["value"].asInt(); }) == 3);
-    CHECK(
+            [](auto const& v, auto) { return v["value"].asInt(); }),
+        3);
+    CHECK_EQ(
         s1.visitor(
             s1,  // type deduction
             2,
-            [](auto& v) { return v["value"].asInt(); }) == 3);
-    CHECK(
+            [](auto& v) { return v["value"].asInt(); }),
+        3);
+    CHECK_EQ(
         s1.visitor(
             s1,  // to const, type deduction
             2,
-            [](auto const& v) { return v["value"].asInt(); }) == 3);
+            [](auto const& v) { return v["value"].asInt(); }),
+        3);
 
     // Test passing of additional arguments
-    CHECK(
+    CHECK_EQ(
         s1.visitor(
             s1,
             std::integral_constant<unsigned, 2>{},
@@ -574,8 +588,9 @@ TEST_CASE("visitor")
                 return ver * a1 * a2 * v["value"].asInt();
             },
             5,
-            7) == 2 * 5 * 7 * 3);
-    CHECK(
+            7),
+        2 * 5 * 7 * 3);
+    CHECK_EQ(
         s1.visitor(
             s1,
             std::integral_constant<unsigned, 2>{},
@@ -583,7 +598,8 @@ TEST_CASE("visitor")
                 return ver * (1 * ... * args) * v["value"].asInt();
             },
             5,
-            7) == 2 * 5 * 7 * 3);
+            7),
+        2 * 5 * 7 * 3);
 
     // Several overloads we want to fail
     static_assert([](auto&& v) {
@@ -685,7 +701,7 @@ TEST_CASE("visit")
                 [](Json::Value&, std::integral_constant<unsigned, 1>) {});
         };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visit(
             std::integral_constant<unsigned, 1>{},
             Overload{
@@ -693,7 +709,8 @@ TEST_CASE("visit")
                     return v["value"].asInt();
                 },
                 [](Json::Value const&, auto) { return 0; },
-                [](auto, auto) { return 0; }}) == 2);
+                [](auto, auto) { return 0; }}),
+        2);
     static_assert([](auto&& v) {
         return requires {
             v.visit()(
@@ -701,7 +718,7 @@ TEST_CASE("visit")
                 [](Json::Value&, std::integral_constant<unsigned, 1>) {});
         };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visit()(
             std::integral_constant<unsigned, 1>{},
             Overload{
@@ -709,33 +726,36 @@ TEST_CASE("visit")
                     return v["value"].asInt();
                 },
                 [](Json::Value const&, auto) { return 0; },
-                [](auto, auto) { return 0; }}) == 2);
+                [](auto, auto) { return 0; }}),
+        2);
 
     static_assert([](auto&& v) {
         return requires {
             v.visit(std::integral_constant<unsigned, 1>{}, [](Json::Value&) {});
         };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visit(
             std::integral_constant<unsigned, 1>{},
             Overload{
                 [](Json::Value& v) { return v["value"].asInt(); },
                 [](Json::Value const&) { return 0; },
-                [](auto...) { return 0; }}) == 2);
+                [](auto...) { return 0; }}),
+        2);
     static_assert([](auto&& v) {
         return requires {
             v.visit()(
                 std::integral_constant<unsigned, 1>{}, [](Json::Value&) {});
         };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visit()(
             std::integral_constant<unsigned, 1>{},
             Overload{
                 [](Json::Value& v) { return v["value"].asInt(); },
                 [](Json::Value const&) { return 0; },
-                [](auto...) { return 0; }}) == 2);
+                [](auto...) { return 0; }}),
+        2);
 
     static_assert([](auto&& v) {
         return requires {
@@ -744,7 +764,7 @@ TEST_CASE("visit")
                 [](Json::Value const&, std::integral_constant<unsigned, 1>) {});
         };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         std::as_const(s1).visit(
             std::integral_constant<unsigned, 2>{},
             Overload{
@@ -752,7 +772,8 @@ TEST_CASE("visit")
                     return v["value"].asInt();
                 },
                 [](Json::Value&, auto) { return 0; },
-                [](auto, auto) { return 0; }}) == 3);
+                [](auto, auto) { return 0; }}),
+        3);
     static_assert([](auto&& v) {
         return requires {
             v.visit()(
@@ -760,7 +781,7 @@ TEST_CASE("visit")
                 [](Json::Value const&, std::integral_constant<unsigned, 1>) {});
         };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         std::as_const(s1).visit()(
             std::integral_constant<unsigned, 2>{},
             Overload{
@@ -768,7 +789,8 @@ TEST_CASE("visit")
                     return v["value"].asInt();
                 },
                 [](Json::Value&, auto) { return 0; },
-                [](auto, auto) { return 0; }}) == 3);
+                [](auto, auto) { return 0; }}),
+        3);
 
     static_assert([](auto&& v) {
         return requires {
@@ -777,13 +799,14 @@ TEST_CASE("visit")
                 [](Json::Value const&) {});
         };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         std::as_const(s1).visit(
             std::integral_constant<unsigned, 2>{},
             Overload{
                 [](Json::Value const& v) { return v["value"].asInt(); },
                 [](Json::Value&) { return 0; },
-                [](auto...) { return 0; }}) == 3);
+                [](auto...) { return 0; }}),
+        3);
     static_assert([](auto&& v) {
         return requires {
             v.visit()(
@@ -791,62 +814,67 @@ TEST_CASE("visit")
                 [](Json::Value const&) {});
         };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         std::as_const(s1).visit()(
             std::integral_constant<unsigned, 2>{},
             Overload{
                 [](Json::Value const& v) { return v["value"].asInt(); },
                 [](Json::Value&) { return 0; },
-                [](auto...) { return 0; }}) == 3);
+                [](auto...) { return 0; }}),
+        3);
 
     static_assert([](auto&& v) {
         return requires { v.visit(1, [](Json::Value&, unsigned) {}); };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visit(
             3u,
             Overload{
                 [](Json::Value& v, unsigned) { return v["value"].asInt(); },
                 [](Json::Value const&, unsigned) { return 0; },
                 [](Json::Value&, auto) { return 0; },
-                [](auto, auto) { return 0; }}) == 5);
+                [](auto, auto) { return 0; }}),
+        5);
     static_assert([](auto&& v) {
         return requires { v.visit()(1, [](Json::Value&, unsigned) {}); };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visit()(
             3u,
             Overload{
                 [](Json::Value& v, unsigned) { return v["value"].asInt(); },
                 [](Json::Value const&, unsigned) { return 0; },
                 [](Json::Value&, auto) { return 0; },
-                [](auto, auto) { return 0; }}) == 5);
+                [](auto, auto) { return 0; }}),
+        5);
 
     static_assert([](auto&& v) {
         return requires { v.visit(1, [](Json::Value&) {}); };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visit(
             3,
             Overload{
                 [](Json::Value& v) { return v["value"].asInt(); },
                 [](Json::Value const&) { return 0; },
-                [](auto...) { return 0; }}) == 5);
+                [](auto...) { return 0; }}),
+        5);
     static_assert([](auto&& v) {
         return requires { v.visit()(1, [](Json::Value&) {}); };
     }(s1));
-    CHECK(
+    CHECK_EQ(
         s1.visit()(
             3,
             Overload{
                 [](Json::Value& v) { return v["value"].asInt(); },
                 [](Json::Value const&) { return 0; },
-                [](auto...) { return 0; }}) == 5);
+                [](auto...) { return 0; }}),
+        5);
 
     static_assert([](auto&& v) {
         return requires { v.visit(1, [](Json::Value const&, unsigned) {}); };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         std::as_const(s1).visit(
             2u,
             Overload{
@@ -855,11 +883,12 @@ TEST_CASE("visit")
                 },
                 [](Json::Value const&, auto) { return 0; },
                 [](Json::Value&, unsigned) { return 0; },
-                [](auto, auto) { return 0; }}) == 3);
+                [](auto, auto) { return 0; }}),
+        3);
     static_assert([](auto&& v) {
         return requires { v.visit()(1, [](Json::Value const&, unsigned) {}); };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         std::as_const(s1).visit()(
             2u,
             Overload{
@@ -868,28 +897,31 @@ TEST_CASE("visit")
                 },
                 [](Json::Value const&, auto) { return 0; },
                 [](Json::Value&, unsigned) { return 0; },
-                [](auto, auto) { return 0; }}) == 3);
+                [](auto, auto) { return 0; }}),
+        3);
 
     static_assert([](auto&& v) {
         return requires { v.visit(1, [](Json::Value const&) {}); };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         std::as_const(s1).visit(
             2,
             Overload{
                 [](Json::Value const& v) { return v["value"].asInt(); },
                 [](Json::Value&) { return 0; },
-                [](auto...) { return 0; }}) == 3);
+                [](auto...) { return 0; }}),
+        3);
     static_assert([](auto&& v) {
         return requires { v.visit()(1, [](Json::Value const&) {}); };
     }(std::as_const(s1)));
-    CHECK(
+    CHECK_EQ(
         std::as_const(s1).visit()(
             2,
             Overload{
                 [](Json::Value const& v) { return v["value"].asInt(); },
                 [](Json::Value&) { return 0; },
-                [](auto...) { return 0; }}) == 3);
+                [](auto...) { return 0; }}),
+        3);
 
     // Rvalue MultivarJson visitor only binds to regular reference
     static_assert([](auto&& v) {

src/doctest/protocol/PublicKey.cpp

@@ -156,7 +156,7 @@ TEST_CASE("Base58: secp256k1")
         TokenType::NodePublic,
         "n94a1u4jAz288pZLtw6yFWVbi89YamiC6JBXPVUj5zmExe5fTVg9");
     CHECK(pk2);
-    CHECK(pk1 == *pk2);
+    CHECK_EQ(pk1, *pk2);
 
     // Try converting short, long and malformed data
     CHECK_FALSE(parseBase58<PublicKey>(TokenType::NodePublic, ""));
@@ -174,7 +174,7 @@ TEST_CASE("Base58: ed25519")
         TokenType::NodePublic,
         "nHUeeJCSY2dM71oxM8Cgjouf5ekTuev2mwDpc374aLMxzDLXNmjf");
     CHECK(pk2);
-    CHECK(pk1 == *pk2);
+    CHECK_EQ(pk1, *pk2);
 }
 
 TEST_CASE("Miscellaneous operations")
@@ -185,8 +185,8 @@ TEST_CASE("Miscellaneous operations")
             KeyType::secp256k1, generateSeed("masterpassphrase")));
 
     PublicKey pk2(pk1);
-    CHECK(pk1 == pk2);
-    CHECK(pk2 == pk1);
+    CHECK_EQ(pk1, pk2);
+    CHECK_EQ(pk2, pk1);
 
     PublicKey pk3 = derivePublicKey(
         KeyType::secp256k1,
@@ -194,8 +194,8 @@ TEST_CASE("Miscellaneous operations")
             KeyType::secp256k1, generateSeed("arbitraryPassPhrase")));
     // Testing the copy assignment operation of PublicKey class
     pk3 = pk2;
-    CHECK(pk3 == pk2);
-    CHECK(pk1 == pk3);
+    CHECK_EQ(pk3, pk2);
+    CHECK_EQ(pk1, pk3);
 }
 
 TEST_SUITE_END();

src/doctest/protocol/Quality.cpp

@@ -55,7 +55,7 @@ ceil_in(
     auto expect_result(amounts(in_expected, out_expected));
     auto actual_result(q.ceil_in(amounts(in, out), amount(limit)));
 
-    CHECK(actual_result == expect_result);
+    CHECK_EQ(actual_result, expect_result);
 }
 
 template <class In1, class Out1, class Int, class In2, class Out2>
@@ -71,7 +71,7 @@ ceil_out(
     auto const expect_result(amounts(in_expected, out_expected));
     auto const actual_result(q.ceil_out(amounts(in, out), amount(limit)));
 
-    CHECK(actual_result == expect_result);
+    CHECK_EQ(actual_result, expect_result);
 }
 
 }  // namespace
@@ -88,26 +88,26 @@ TEST_CASE("comparisons")
     Quality const q21(Amounts(amount2, amount1));
     Quality const q31(Amounts(amount3, amount1));
 
-    CHECK(q11 == q11);
-    CHECK(q11 < q12);
-    CHECK(q12 < q13);
-    CHECK(q31 < q21);
-    CHECK(q21 < q11);
-    CHECK(q11 >= q11);
-    CHECK(q12 >= q11);
-    CHECK(q13 >= q12);
-    CHECK(q21 >= q31);
-    CHECK(q11 >= q21);
-    CHECK(q12 > q11);
-    CHECK(q13 > q12);
-    CHECK(q21 > q31);
-    CHECK(q11 > q21);
-    CHECK(q11 <= q11);
-    CHECK(q11 <= q12);
-    CHECK(q12 <= q13);
-    CHECK(q31 <= q21);
-    CHECK(q21 <= q11);
-    CHECK(q31 != q21);
+    CHECK_EQ(q11, q11);
+    CHECK_LT(q11, q12);
+    CHECK_LT(q12, q13);
+    CHECK_LT(q31, q21);
+    CHECK_LT(q21, q11);
+    CHECK_GE(q11, q11);
+    CHECK_GE(q12, q11);
+    CHECK_GE(q13, q12);
+    CHECK_GE(q21, q31);
+    CHECK_GE(q11, q21);
+    CHECK_GT(q12, q11);
+    CHECK_GT(q13, q12);
+    CHECK_GT(q21, q31);
+    CHECK_GT(q11, q21);
+    CHECK_LE(q11, q11);
+    CHECK_LE(q11, q12);
+    CHECK_LE(q12, q13);
+    CHECK_LE(q31, q21);
+    CHECK_LE(q21, q11);
+    CHECK_NE(q31, q21);
 }
 
 TEST_CASE("composition")
@@ -122,13 +122,13 @@ TEST_CASE("composition")
     Quality const q21(Amounts(amount2, amount1));
     Quality const q31(Amounts(amount3, amount1));
 
-    CHECK(composed_quality(q12, q21) == q11);
+    CHECK_EQ(composed_quality(q12, q21), q11);
 
     Quality const q13_31(composed_quality(q13, q31));
     Quality const q31_13(composed_quality(q31, q13));
 
-    CHECK(q13_31 == q31_13);
-    CHECK(q13_31 == q11);
+    CHECK_EQ(q13_31, q31_13);
+    CHECK_EQ(q13_31, q11);
 }
 
 TEST_CASE("operations")
@@ -139,16 +139,16 @@ TEST_CASE("operations")
     Quality qa(q11);
     Quality qb(q11);
 
-    CHECK(qa == qb);
-    CHECK(++qa != q11);
-    CHECK(qa != qb);
-    CHECK(--qb != q11);
-    CHECK(qa != qb);
-    CHECK(qb < qa);
-    CHECK(qb++ < qa);
-    CHECK(qb++ < qa);
-    CHECK(qb++ == qa);
-    CHECK(qa < qb);
+    CHECK_EQ(qa, qb);
+    CHECK_NE(++qa, q11);
+    CHECK_NE(qa, qb);
+    CHECK_NE(--qb, q11);
+    CHECK_NE(qa, qb);
+    CHECK_LT(qb, qa);
+    CHECK_LT(qb++, qa);
+    CHECK_LT(qb++, qa);
+    CHECK_EQ(qb++, qa);
+    CHECK_LT(qa, qb);
 }
 
 TEST_CASE("ceil_in")
@@ -237,26 +237,26 @@ TEST_CASE("raw")
         raw(2755280000000000ull, -15));                // 2.75528
     STAmount const limit(raw(4131113916555555, -16));  // .4131113916555555
     Amounts const result(q.ceil_out(value, limit));
-    CHECK(result.in != beast::zero);
+    CHECK_NE(result.in, beast::zero);
 }
 
 TEST_CASE("round")
 {
     Quality q(0x59148191fb913522ull);  // 57719.63525051682
-    CHECK(q.round(3).rate().getText() == "57800");
-    CHECK(q.round(4).rate().getText() == "57720");
-    CHECK(q.round(5).rate().getText() == "57720");
-    CHECK(q.round(6).rate().getText() == "57719.7");
-    CHECK(q.round(7).rate().getText() == "57719.64");
-    CHECK(q.round(8).rate().getText() == "57719.636");
-    CHECK(q.round(9).rate().getText() == "57719.6353");
-    CHECK(q.round(10).rate().getText() == "57719.63526");
-    CHECK(q.round(11).rate().getText() == "57719.635251");
-    CHECK(q.round(12).rate().getText() == "57719.6352506");
-    CHECK(q.round(13).rate().getText() == "57719.63525052");
-    CHECK(q.round(14).rate().getText() == "57719.635250517");
-    CHECK(q.round(15).rate().getText() == "57719.6352505169");
-    CHECK(q.round(16).rate().getText() == "57719.63525051682");
+    CHECK_EQ(q.round(3).rate().getText(), "57800");
+    CHECK_EQ(q.round(4).rate().getText(), "57720");
+    CHECK_EQ(q.round(5).rate().getText(), "57720");
+    CHECK_EQ(q.round(6).rate().getText(), "57719.7");
+    CHECK_EQ(q.round(7).rate().getText(), "57719.64");
+    CHECK_EQ(q.round(8).rate().getText(), "57719.636");
+    CHECK_EQ(q.round(9).rate().getText(), "57719.6353");
+    CHECK_EQ(q.round(10).rate().getText(), "57719.63526");
+    CHECK_EQ(q.round(11).rate().getText(), "57719.635251");
+    CHECK_EQ(q.round(12).rate().getText(), "57719.6352506");
+    CHECK_EQ(q.round(13).rate().getText(), "57719.63525052");
+    CHECK_EQ(q.round(14).rate().getText(), "57719.635250517");
+    CHECK_EQ(q.round(15).rate().getText(), "57719.6352505169");
+    CHECK_EQ(q.round(16).rate().getText(), "57719.63525051682");
 }
 
 TEST_SUITE_END();

src/doctest/protocol/STAccount.cpp

@@ -9,10 +9,10 @@ TEST_SUITE_BEGIN("STAccount");
 TEST_CASE("STAccount default constructor")
 {
     STAccount const defaultAcct;
-    CHECK(defaultAcct.getSType() == STI_ACCOUNT);
-    CHECK(defaultAcct.getText() == "");
-    CHECK(defaultAcct.isDefault() == true);
-    CHECK(defaultAcct.value() == AccountID{});
+    CHECK_EQ(defaultAcct.getSType(), STI_ACCOUNT);
+    CHECK_EQ(defaultAcct.getText(), "");
+    CHECK_UNARY(defaultAcct.isDefault());
+    CHECK_EQ(defaultAcct.value(), AccountID{});
 }
 
 TEST_CASE("STAccount deserialized default")
@@ -23,26 +23,26 @@ TEST_CASE("STAccount deserialized default")
     s.addVL(nullptr, 0);
     SerialIter sit(s.slice());
     STAccount const deserializedDefault(sit, sfAccount);
-    CHECK(deserializedDefault.isEquivalent(defaultAcct));
+    CHECK_UNARY(deserializedDefault.isEquivalent(defaultAcct));
 }
 
 TEST_CASE("STAccount constructor from SField")
 {
     STAccount const defaultAcct;
     STAccount const sfAcct{sfAccount};
-    CHECK(sfAcct.getSType() == STI_ACCOUNT);
-    CHECK(sfAcct.getText() == "");
-    CHECK(sfAcct.isDefault());
-    CHECK(sfAcct.value() == AccountID{});
-    CHECK(sfAcct.isEquivalent(defaultAcct));
+    CHECK_EQ(sfAcct.getSType(), STI_ACCOUNT);
+    CHECK_EQ(sfAcct.getText(), "");
+    CHECK_UNARY(sfAcct.isDefault());
+    CHECK_EQ(sfAcct.value(), AccountID{});
+    CHECK_UNARY(sfAcct.isEquivalent(defaultAcct));
 
     Serializer s;
     sfAcct.add(s);
-    CHECK(s.size() == 1);
-    CHECK(strHex(s) == "00");
+    CHECK_EQ(s.size(), 1);
+    CHECK_EQ(strHex(s), "00");
     SerialIter sit(s.slice());
     STAccount const deserializedSf(sit, sfAccount);
-    CHECK(deserializedSf.isEquivalent(sfAcct));
+    CHECK_UNARY(deserializedSf.isEquivalent(sfAcct));
 }
 
 TEST_CASE("STAccount constructor from SField and AccountID")
@@ -50,19 +50,19 @@ TEST_CASE("STAccount constructor from SField and AccountID")
     STAccount const defaultAcct;
     STAccount const sfAcct{sfAccount};
     STAccount const zeroAcct{sfAccount, AccountID{}};
-    CHECK(zeroAcct.getText() == "rrrrrrrrrrrrrrrrrrrrrhoLvTp");
-    CHECK(!zeroAcct.isDefault());
-    CHECK(zeroAcct.value() == AccountID{0});
-    CHECK(!zeroAcct.isEquivalent(defaultAcct));
-    CHECK(!zeroAcct.isEquivalent(sfAcct));
+    CHECK_EQ(zeroAcct.getText(), "rrrrrrrrrrrrrrrrrrrrrhoLvTp");
+    CHECK_FALSE(zeroAcct.isDefault());
+    CHECK_EQ(zeroAcct.value(), AccountID{0});
+    CHECK_FALSE(zeroAcct.isEquivalent(defaultAcct));
+    CHECK_FALSE(zeroAcct.isEquivalent(sfAcct));
 
     Serializer s;
     zeroAcct.add(s);
-    CHECK(s.size() == 21);
-    CHECK(strHex(s) == "140000000000000000000000000000000000000000");
+    CHECK_EQ(s.size(), 21);
+    CHECK_EQ(strHex(s), "140000000000000000000000000000000000000000");
     SerialIter sit(s.slice());
     STAccount const deserializedZero(sit, sfAccount);
-    CHECK(deserializedZero.isEquivalent(zeroAcct));
+    CHECK_UNARY(deserializedZero.isEquivalent(zeroAcct));
 }
 
 TEST_CASE("STAccount bad size throws")
@@ -81,7 +81,7 @@ TEST_CASE("STAccount equivalent types")
     STAccount const zeroAcct{sfAccount, AccountID{}};
     // Interestingly, equal values but different types are equivalent!
     STAccount const regKey{sfRegularKey, AccountID{}};
-    CHECK(regKey.isEquivalent(zeroAcct));
+    CHECK_UNARY(regKey.isEquivalent(zeroAcct));
 }
 
 TEST_CASE("STAccount assignment")
@@ -90,12 +90,12 @@ TEST_CASE("STAccount assignment")
     STAccount const zeroAcct{sfAccount, AccountID{}};
 
     STAccount assignAcct;
-    CHECK(assignAcct.isEquivalent(defaultAcct));
-    CHECK(assignAcct.isDefault());
+    CHECK_UNARY(assignAcct.isEquivalent(defaultAcct));
+    CHECK_UNARY(assignAcct.isDefault());
     assignAcct = AccountID{};
-    CHECK(!assignAcct.isEquivalent(defaultAcct));
-    CHECK(assignAcct.isEquivalent(zeroAcct));
-    CHECK(!assignAcct.isDefault());
+    CHECK_FALSE(assignAcct.isEquivalent(defaultAcct));
+    CHECK_UNARY(assignAcct.isEquivalent(zeroAcct));
+    CHECK_FALSE(assignAcct.isDefault());
 }
 
 TEST_CASE("AccountID parsing")
@@ -103,14 +103,14 @@ TEST_CASE("AccountID parsing")
     auto const s = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh";
     auto const parsed = parseBase58<AccountID>(s);
     REQUIRE(parsed);
-    CHECK(toBase58(*parsed) == s);
+    CHECK_EQ(toBase58(*parsed), s);
 }
 
 TEST_CASE("AccountID invalid parsing")
 {
     auto const s =
         "âabcd1rNxp4h8apvRis6mJf9Sh8C6iRxfrDWNâabcdAVâ\xc2\x80\xc2\x8f";
-    CHECK(!parseBase58<AccountID>(s));
+    CHECK_FALSE(parseBase58<AccountID>(s));
 }
 
 TEST_SUITE_END();

src/doctest/protocol/STInteger.cpp

@@ -12,89 +12,89 @@ TEST_SUITE_BEGIN("STInteger");
 TEST_CASE("UInt8")
 {
     STUInt8 u8(255);
-    CHECK(u8.value() == 255);
-    CHECK(u8.getText() == "255");
-    CHECK(u8.getSType() == STI_UINT8);
-    CHECK(u8.getJson(JsonOptions::none) == 255);
+    CHECK_EQ(u8.value(), 255);
+    CHECK_EQ(u8.getText(), "255");
+    CHECK_EQ(u8.getSType(), STI_UINT8);
+    CHECK_EQ(u8.getJson(JsonOptions::none), 255);
 
     // there is some special handling for sfTransactionResult
     STUInt8 tr(sfTransactionResult, 0);
-    CHECK(tr.value() == 0);
-    CHECK(
-        tr.getText() ==
+    CHECK_EQ(tr.value(), 0);
+    CHECK_EQ(
+        tr.getText(),
         "The transaction was applied. Only final in a validated ledger.");
-    CHECK(tr.getSType() == STI_UINT8);
-    CHECK(tr.getJson(JsonOptions::none) == "tesSUCCESS");
+    CHECK_EQ(tr.getSType(), STI_UINT8);
+    CHECK_EQ(tr.getJson(JsonOptions::none), "tesSUCCESS");
 
     // invalid transaction result
     STUInt8 tr2(sfTransactionResult, 255);
-    CHECK(tr2.value() == 255);
-    CHECK(tr2.getText() == "255");
-    CHECK(tr2.getSType() == STI_UINT8);
-    CHECK(tr2.getJson(JsonOptions::none) == 255);
+    CHECK_EQ(tr2.value(), 255);
+    CHECK_EQ(tr2.getText(), "255");
+    CHECK_EQ(tr2.getSType(), STI_UINT8);
+    CHECK_EQ(tr2.getJson(JsonOptions::none), 255);
 }
 
 TEST_CASE("UInt16")
 {
     STUInt16 u16(65535);
-    CHECK(u16.value() == 65535);
-    CHECK(u16.getText() == "65535");
-    CHECK(u16.getSType() == STI_UINT16);
-    CHECK(u16.getJson(JsonOptions::none) == 65535);
+    CHECK_EQ(u16.value(), 65535);
+    CHECK_EQ(u16.getText(), "65535");
+    CHECK_EQ(u16.getSType(), STI_UINT16);
+    CHECK_EQ(u16.getJson(JsonOptions::none), 65535);
 
     // there is some special handling for sfLedgerEntryType
     STUInt16 let(sfLedgerEntryType, ltACCOUNT_ROOT);
-    CHECK(let.value() == ltACCOUNT_ROOT);
-    CHECK(let.getText() == "AccountRoot");
-    CHECK(let.getSType() == STI_UINT16);
-    CHECK(let.getJson(JsonOptions::none) == "AccountRoot");
+    CHECK_EQ(let.value(), ltACCOUNT_ROOT);
+    CHECK_EQ(let.getText(), "AccountRoot");
+    CHECK_EQ(let.getSType(), STI_UINT16);
+    CHECK_EQ(let.getJson(JsonOptions::none), "AccountRoot");
 
     // there is some special handling for sfTransactionType
     STUInt16 tlt(sfTransactionType, ttPAYMENT);
-    CHECK(tlt.value() == ttPAYMENT);
-    CHECK(tlt.getText() == "Payment");
-    CHECK(tlt.getSType() == STI_UINT16);
-    CHECK(tlt.getJson(JsonOptions::none) == "Payment");
+    CHECK_EQ(tlt.value(), ttPAYMENT);
+    CHECK_EQ(tlt.getText(), "Payment");
+    CHECK_EQ(tlt.getSType(), STI_UINT16);
+    CHECK_EQ(tlt.getJson(JsonOptions::none), "Payment");
 }
 
 TEST_CASE("UInt32")
 {
     STUInt32 u32(4'294'967'295u);
-    CHECK(u32.value() == 4'294'967'295u);
-    CHECK(u32.getText() == "4294967295");
-    CHECK(u32.getSType() == STI_UINT32);
-    CHECK(u32.getJson(JsonOptions::none) == 4'294'967'295u);
+    CHECK_EQ(u32.value(), 4'294'967'295u);
+    CHECK_EQ(u32.getText(), "4294967295");
+    CHECK_EQ(u32.getSType(), STI_UINT32);
+    CHECK_EQ(u32.getJson(JsonOptions::none), 4'294'967'295u);
 
     // there is some special handling for sfPermissionValue
     STUInt32 pv(sfPermissionValue, ttPAYMENT + 1);
-    CHECK(pv.value() == ttPAYMENT + 1);
-    CHECK(pv.getText() == "Payment");
-    CHECK(pv.getSType() == STI_UINT32);
-    CHECK(pv.getJson(JsonOptions::none) == "Payment");
+    CHECK_EQ(pv.value(), ttPAYMENT + 1);
+    CHECK_EQ(pv.getText(), "Payment");
+    CHECK_EQ(pv.getSType(), STI_UINT32);
+    CHECK_EQ(pv.getJson(JsonOptions::none), "Payment");
     STUInt32 pv2(sfPermissionValue, PaymentMint);
-    CHECK(pv2.value() == PaymentMint);
-    CHECK(pv2.getText() == "PaymentMint");
-    CHECK(pv2.getSType() == STI_UINT32);
-    CHECK(pv2.getJson(JsonOptions::none) == "PaymentMint");
+    CHECK_EQ(pv2.value(), PaymentMint);
+    CHECK_EQ(pv2.getText(), "PaymentMint");
+    CHECK_EQ(pv2.getSType(), STI_UINT32);
+    CHECK_EQ(pv2.getJson(JsonOptions::none), "PaymentMint");
 }
 
 TEST_CASE("UInt64")
 {
     STUInt64 u64(0xFFFFFFFFFFFFFFFFull);
-    CHECK(u64.value() == 0xFFFFFFFFFFFFFFFFull);
-    CHECK(u64.getText() == "18446744073709551615");
-    CHECK(u64.getSType() == STI_UINT64);
+    CHECK_EQ(u64.value(), 0xFFFFFFFFFFFFFFFFull);
+    CHECK_EQ(u64.getText(), "18446744073709551615");
+    CHECK_EQ(u64.getSType(), STI_UINT64);
 
     // By default, getJson returns hex string
     auto jsonVal = u64.getJson(JsonOptions::none);
-    CHECK(jsonVal.isString());
-    CHECK(jsonVal.asString() == "ffffffffffffffff");
+    CHECK_UNARY(jsonVal.isString());
+    CHECK_EQ(jsonVal.asString(), "ffffffffffffffff");
 
     STUInt64 u64_2(sfMaximumAmount, 0xFFFFFFFFFFFFFFFFull);
-    CHECK(u64_2.value() == 0xFFFFFFFFFFFFFFFFull);
-    CHECK(u64_2.getText() == "18446744073709551615");
-    CHECK(u64_2.getSType() == STI_UINT64);
-    CHECK(u64_2.getJson(JsonOptions::none) == "18446744073709551615");
+    CHECK_EQ(u64_2.value(), 0xFFFFFFFFFFFFFFFFull);
+    CHECK_EQ(u64_2.getText(), "18446744073709551615");
+    CHECK_EQ(u64_2.getSType(), STI_UINT64);
+    CHECK_EQ(u64_2.getJson(JsonOptions::none), "18446744073709551615");
 }
 
 TEST_CASE("Int32")
@@ -103,20 +103,20 @@ TEST_CASE("Int32")
     {
         int const minInt32 = -2147483648;
         STInt32 i32(minInt32);
-        CHECK(i32.value() == minInt32);
-        CHECK(i32.getText() == "-2147483648");
-        CHECK(i32.getSType() == STI_INT32);
-        CHECK(i32.getJson(JsonOptions::none) == minInt32);
+        CHECK_EQ(i32.value(), minInt32);
+        CHECK_EQ(i32.getText(), "-2147483648");
+        CHECK_EQ(i32.getSType(), STI_INT32);
+        CHECK_EQ(i32.getJson(JsonOptions::none), minInt32);
     }
 
     SUBCASE("max value")
     {
         int const maxInt32 = 2147483647;
         STInt32 i32(maxInt32);
-        CHECK(i32.value() == maxInt32);
-        CHECK(i32.getText() == "2147483647");
-        CHECK(i32.getSType() == STI_INT32);
-        CHECK(i32.getJson(JsonOptions::none) == maxInt32);
+        CHECK_EQ(i32.value(), maxInt32);
+        CHECK_EQ(i32.getText(), "2147483647");
+        CHECK_EQ(i32.getSType(), STI_INT32);
+        CHECK_EQ(i32.getJson(JsonOptions::none), maxInt32);
     }
 }
 

src/doctest/protocol/STNumber.cpp

@@ -18,14 +18,14 @@ void
 testCombo(Number number)
 {
     STNumber const before{sfNumber, number};
-    CHECK(number == before);
+    CHECK_EQ(number, before);
     Serializer s;
     before.add(s);
-    CHECK(s.size() == 12);
+    CHECK_EQ(s.size(), 12);
     SerialIter sit(s.slice());
     STNumber const after{sit, sfNumber};
-    CHECK(after.isEquivalent(before));
-    CHECK(number == after);
+    CHECK_UNARY(after.isEquivalent(before));
+    CHECK_EQ(number, after);
 }
 
 }  // namespace
@@ -35,10 +35,10 @@ TEST_CASE("STNumber default constructor")
     static_assert(!std::is_convertible_v<STNumber*, Number*>);
 
     STNumber const stnum{sfNumber};
-    CHECK(stnum.getSType() == STI_NUMBER);
-    CHECK(stnum.getText() == "0");
-    CHECK(stnum.isDefault() == true);
-    CHECK(stnum.value() == Number{0});
+    CHECK_EQ(stnum.getSType(), STI_NUMBER);
+    CHECK_EQ(stnum.getText(), "0");
+    CHECK_UNARY(stnum.isDefault());
+    CHECK_EQ(stnum.value(), Number{0});
 }
 
 TEST_CASE("STNumber mantissa serialization")
@@ -68,73 +68,72 @@ TEST_CASE("STNumber multiplication with STAmount")
     auto const iouValue = strikePrice.iou();
     IOUAmount totalValue{iouValue * factor};
     STAmount const totalAmount{totalValue, strikePrice.issue()};
-    CHECK(totalAmount == Number{10'000});
+    CHECK_EQ(totalAmount, Number{10'000});
 }
 
 TEST_CASE("numberFromJson integer values")
 {
-    CHECK(numberFromJson(sfNumber, Json::Value(42)) == STNumber(sfNumber, 42));
-    CHECK(
-        numberFromJson(sfNumber, Json::Value(-42)) == STNumber(sfNumber, -42));
-    CHECK(numberFromJson(sfNumber, Json::UInt(42)) == STNumber(sfNumber, 42));
+    CHECK_EQ(numberFromJson(sfNumber, Json::Value(42)), STNumber(sfNumber, 42));
+    CHECK_EQ(
+        numberFromJson(sfNumber, Json::Value(-42)), STNumber(sfNumber, -42));
+    CHECK_EQ(numberFromJson(sfNumber, Json::UInt(42)), STNumber(sfNumber, 42));
 }
 
 TEST_CASE("numberFromJson string values")
 {
-    CHECK(numberFromJson(sfNumber, "-123") == STNumber(sfNumber, -123));
-    CHECK(numberFromJson(sfNumber, "123") == STNumber(sfNumber, 123));
-    CHECK(numberFromJson(sfNumber, "-123") == STNumber(sfNumber, -123));
+    CHECK_EQ(numberFromJson(sfNumber, "-123"), STNumber(sfNumber, -123));
+    CHECK_EQ(numberFromJson(sfNumber, "123"), STNumber(sfNumber, 123));
+    CHECK_EQ(numberFromJson(sfNumber, "-123"), STNumber(sfNumber, -123));
 
-    CHECK(
-        numberFromJson(sfNumber, "3.14") ==
-        STNumber(sfNumber, Number(314, -2)));
-    CHECK(
-        numberFromJson(sfNumber, "-3.14") ==
+    CHECK_EQ(
+        numberFromJson(sfNumber, "3.14"), STNumber(sfNumber, Number(314, -2)));
+    CHECK_EQ(
+        numberFromJson(sfNumber, "-3.14"),
         STNumber(sfNumber, -Number(314, -2)));
-    CHECK(numberFromJson(sfNumber, "3.14e2") == STNumber(sfNumber, 314));
-    CHECK(numberFromJson(sfNumber, "-3.14e2") == STNumber(sfNumber, -314));
+    CHECK_EQ(numberFromJson(sfNumber, "3.14e2"), STNumber(sfNumber, 314));
+    CHECK_EQ(numberFromJson(sfNumber, "-3.14e2"), STNumber(sfNumber, -314));
 
-    CHECK(numberFromJson(sfNumber, "1000e-2") == STNumber(sfNumber, 10));
-    CHECK(numberFromJson(sfNumber, "-1000e-2") == STNumber(sfNumber, -10));
+    CHECK_EQ(numberFromJson(sfNumber, "1000e-2"), STNumber(sfNumber, 10));
+    CHECK_EQ(numberFromJson(sfNumber, "-1000e-2"), STNumber(sfNumber, -10));
 }
 
 TEST_CASE("numberFromJson zero values")
 {
-    CHECK(numberFromJson(sfNumber, "0") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "0.0") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "0.000") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "-0") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "-0.0") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "-0.000") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "0e6") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "0.0e6") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "0.000e6") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "-0e6") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "-0.0e6") == STNumber(sfNumber, 0));
-    CHECK(numberFromJson(sfNumber, "-0.000e6") == STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "0"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "0.0"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "0.000"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "-0"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "-0.0"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "-0.000"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "0e6"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "0.0e6"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "0.000e6"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "-0e6"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "-0.0e6"), STNumber(sfNumber, 0));
+    CHECK_EQ(numberFromJson(sfNumber, "-0.000e6"), STNumber(sfNumber, 0));
 }
 
 TEST_CASE("numberFromJson int limits")
 {
     constexpr auto imin = std::numeric_limits<int>::min();
-    CHECK(
-        numberFromJson(sfNumber, imin) == STNumber(sfNumber, Number(imin, 0)));
-    CHECK(
-        numberFromJson(sfNumber, std::to_string(imin)) ==
+    CHECK_EQ(
+        numberFromJson(sfNumber, imin), STNumber(sfNumber, Number(imin, 0)));
+    CHECK_EQ(
+        numberFromJson(sfNumber, std::to_string(imin)),
         STNumber(sfNumber, Number(imin, 0)));
 
     constexpr auto imax = std::numeric_limits<int>::max();
-    CHECK(
-        numberFromJson(sfNumber, imax) == STNumber(sfNumber, Number(imax, 0)));
-    CHECK(
-        numberFromJson(sfNumber, std::to_string(imax)) ==
+    CHECK_EQ(
+        numberFromJson(sfNumber, imax), STNumber(sfNumber, Number(imax, 0)));
+    CHECK_EQ(
+        numberFromJson(sfNumber, std::to_string(imax)),
         STNumber(sfNumber, Number(imax, 0)));
 
     constexpr auto umax = std::numeric_limits<unsigned int>::max();
-    CHECK(
-        numberFromJson(sfNumber, umax) == STNumber(sfNumber, Number(umax, 0)));
-    CHECK(
-        numberFromJson(sfNumber, std::to_string(umax)) ==
+    CHECK_EQ(
+        numberFromJson(sfNumber, umax), STNumber(sfNumber, Number(umax, 0)));
+    CHECK_EQ(
+        numberFromJson(sfNumber, std::to_string(umax)),
         STNumber(sfNumber, Number(umax, 0)));
 }
 

src/doctest/protocol/SecretKey.cpp

@@ -64,20 +64,20 @@ TEST_CASE("secp256k1: canonicality")
 
     {
         auto const canonicality = ecdsaCanonicality(makeSlice(sig));
-        CHECK(canonicality);
-        CHECK(*canonicality == ECDSACanonicality::fullyCanonical);
+        CHECK_UNARY(canonicality);
+        CHECK_EQ(*canonicality, ECDSACanonicality::fullyCanonical);
     }
 
     {
         auto const canonicality = ecdsaCanonicality(makeSlice(non));
-        CHECK(canonicality);
-        CHECK(*canonicality != ECDSACanonicality::fullyCanonical);
+        CHECK_UNARY(canonicality);
+        CHECK_NE(*canonicality, ECDSACanonicality::fullyCanonical);
     }
 
-    CHECK(verifyDigest(pk, digest, makeSlice(sig), false));
-    CHECK(verifyDigest(pk, digest, makeSlice(sig), true));
-    CHECK(verifyDigest(pk, digest, makeSlice(non), false));
-    CHECK(!verifyDigest(pk, digest, makeSlice(non), true));
+    CHECK_UNARY(verifyDigest(pk, digest, makeSlice(sig), false));
+    CHECK_UNARY(verifyDigest(pk, digest, makeSlice(sig), true));
+    CHECK_UNARY(verifyDigest(pk, digest, makeSlice(non), false));
+    CHECK_FALSE(verifyDigest(pk, digest, makeSlice(non), true));
 }
 
 TEST_CASE("secp256k1: digest signing & verification")
@@ -86,8 +86,8 @@ TEST_CASE("secp256k1: digest signing & verification")
     {
         auto const [pk, sk] = randomKeyPair(KeyType::secp256k1);
 
-        CHECK(pk == derivePublicKey(KeyType::secp256k1, sk));
-        CHECK(*publicKeyType(pk) == KeyType::secp256k1);
+        CHECK_EQ(pk, derivePublicKey(KeyType::secp256k1, sk));
+        CHECK_EQ(*publicKeyType(pk), KeyType::secp256k1);
 
         for (std::size_t j = 0; j < 32; j++)
         {
@@ -96,21 +96,21 @@ TEST_CASE("secp256k1: digest signing & verification")
 
             auto sig = signDigest(pk, sk, digest);
 
-            CHECK(sig.size() != 0);
-            CHECK(verifyDigest(pk, digest, sig, true));
+            CHECK_NE(sig.size(), 0);
+            CHECK_UNARY(verifyDigest(pk, digest, sig, true));
 
             // Wrong digest:
-            CHECK(!verifyDigest(pk, ~digest, sig, true));
+            CHECK_FALSE(verifyDigest(pk, ~digest, sig, true));
 
             // Slightly change the signature:
             if (auto ptr = sig.data())
                 ptr[j % sig.size()]++;
 
             // Wrong signature:
-            CHECK(!verifyDigest(pk, digest, sig, true));
+            CHECK_FALSE(verifyDigest(pk, digest, sig, true));
 
             // Wrong digest and signature:
-            CHECK(!verifyDigest(pk, ~digest, sig, true));
+            CHECK_FALSE(verifyDigest(pk, ~digest, sig, true));
         }
     }
 }
@@ -122,8 +122,8 @@ testSigning(KeyType type)
     {
         auto const [pk, sk] = randomKeyPair(type);
 
-        CHECK(pk == derivePublicKey(type, sk));
-        CHECK(*publicKeyType(pk) == type);
+        CHECK_EQ(pk, derivePublicKey(type, sk));
+        CHECK_EQ(*publicKeyType(pk), type);
 
         for (std::size_t j = 0; j < 32; j++)
         {
@@ -132,8 +132,8 @@ testSigning(KeyType type)
 
             auto sig = sign(pk, sk, makeSlice(data));
 
-            CHECK(sig.size() != 0);
-            CHECK(verify(pk, makeSlice(data), sig));
+            CHECK_NE(sig.size(), 0);
+            CHECK_UNARY(verify(pk, makeSlice(data), sig));
 
             // Construct wrong data:
             auto badData = data;
@@ -144,17 +144,17 @@ testSigning(KeyType type)
                 std::max_element(badData.begin(), badData.end()));
 
             // Wrong data: should fail
-            CHECK(!verify(pk, makeSlice(badData), sig));
+            CHECK_FALSE(verify(pk, makeSlice(badData), sig));
 
             // Slightly change the signature:
             if (auto ptr = sig.data())
                 ptr[j % sig.size()]++;
 
             // Wrong signature: should fail
-            CHECK(!verify(pk, makeSlice(data), sig));
+            CHECK_FALSE(verify(pk, makeSlice(data), sig));
 
             // Wrong data and signature: should fail
-            CHECK(!verify(pk, makeSlice(badData), sig));
+            CHECK_FALSE(verify(pk, makeSlice(badData), sig));
         }
     }
 }
@@ -191,13 +191,13 @@ TEST_CASE("secp256k1: key derivation")
     for (auto const& v : secp256k1TestVectors)
     {
         auto const id = parseBase58<AccountID>(v.addr);
-        CHECK(id);
+        CHECK_UNARY(id);
 
         auto kp = generateKeyPair(KeyType::secp256k1, Seed{makeSlice(v.seed)});
 
-        CHECK(kp.first == PublicKey{makeSlice(v.pubkey)});
-        CHECK(kp.second == SecretKey{makeSlice(v.seckey)});
-        CHECK(calcAccountID(kp.first) == *id);
+        CHECK_EQ(kp.first, PublicKey{makeSlice(v.pubkey)});
+        CHECK_EQ(kp.second, SecretKey{makeSlice(v.seckey)});
+        CHECK_EQ(calcAccountID(kp.first), *id);
     }
 }
 
@@ -223,13 +223,13 @@ TEST_CASE("ed25519: key derivation")
     for (auto const& v : ed25519TestVectors)
     {
         auto const id = parseBase58<AccountID>(v.addr);
-        CHECK(id);
+        CHECK_UNARY(id);
 
         auto kp = generateKeyPair(KeyType::ed25519, Seed{makeSlice(v.seed)});
 
-        CHECK(kp.first == PublicKey{makeSlice(v.pubkey)});
-        CHECK(kp.second == SecretKey{makeSlice(v.seckey)});
-        CHECK(calcAccountID(kp.first) == *id);
+        CHECK_EQ(kp.first, PublicKey{makeSlice(v.pubkey)});
+        CHECK_EQ(kp.second, SecretKey{makeSlice(v.seckey)});
+        CHECK_EQ(calcAccountID(kp.first), *id);
     }
 }
 
@@ -238,18 +238,18 @@ TEST_CASE("secp256k1: cross-type key mismatch")
     auto const [pk1, sk1] = randomKeyPair(KeyType::secp256k1);
     auto const [pk2, sk2] = randomKeyPair(KeyType::secp256k1);
 
-    CHECK(pk1 != pk2);
-    CHECK(sk1 != sk2);
+    CHECK_NE(pk1, pk2);
+    CHECK_NE(sk1, sk2);
 
     auto const [pk3, sk3] = randomKeyPair(KeyType::ed25519);
     auto const [pk4, sk4] = randomKeyPair(KeyType::ed25519);
 
-    CHECK(pk3 != pk4);
-    CHECK(sk3 != sk4);
+    CHECK_NE(pk3, pk4);
+    CHECK_NE(sk3, sk4);
 
     // Cross-type comparisons
-    CHECK(pk1 != pk3);
-    CHECK(pk2 != pk4);
+    CHECK_NE(pk1, pk3);
+    CHECK_NE(pk2, pk4);
 }
 
 TEST_SUITE_END();

src/doctest/protocol/Seed.cpp

@@ -47,7 +47,7 @@ TEST_CASE("construction")
         {
             beast::rngfill(src, sizeof(src), default_prng());
             Seed const seed({src, sizeof(src)});
-            CHECK(memcmp(seed.data(), src, sizeof(src)) == 0);
+            CHECK_EQ(memcmp(seed.data(), src, sizeof(src)), 0);
         }
     }
 
@@ -58,7 +58,7 @@ TEST_CASE("construction")
             uint128 src;
             beast::rngfill(src.data(), src.size(), default_prng());
             Seed const seed(src);
-            CHECK(memcmp(seed.data(), src.data(), src.size()) == 0);
+            CHECK_EQ(memcmp(seed.data(), src.data(), src.size()), 0);
         }
     }
 }
@@ -126,7 +126,7 @@ TEST_CASE("Node keypair generation & signing (secp256k1)")
         "7E59C17D50F5959C7B158FEC95C8F815BF653DC8");
 
     auto sig = sign(publicKey, secretKey, makeSlice(message1));
-    CHECK(sig.size() != 0);
+    CHECK_NE(sig.size(), 0);
     CHECK(verify(publicKey, makeSlice(message1), sig));
 
     // Correct public key but wrong message
@@ -172,8 +172,8 @@ TEST_CASE("Node keypair generation & signing (ed25519)")
         "AA066C988C712815CC37AF71472B7CBBBD4E2A0A");
 
     auto sig = sign(publicKey, secretKey, makeSlice(message1));
-    CHECK(sig.size() != 0);
-    CHECK(verify(publicKey, makeSlice(message1), sig));
+    CHECK_NE(sig.size(), 0);
+    CHECK_UNARY(verify(publicKey, makeSlice(message1), sig));
 
     // Correct public key but wrong message
     CHECK_FALSE(verify(publicKey, makeSlice(message2), sig));
@@ -205,7 +205,7 @@ TEST_CASE("Account keypair generation & signing (secp256k1)")
     auto const [pk, sk] =
         generateKeyPair(KeyType::secp256k1, generateSeed("masterpassphrase"));
 
-    CHECK(toBase58(calcAccountID(pk)) == "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh");
+    CHECK_EQ(toBase58(calcAccountID(pk)), "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh");
     CHECK(
         toBase58(TokenType::AccountPublic, pk) ==
         "aBQG8RQAzjs1eTKFEAQXr2gS4utcDiEC9wmi7pfUPTi27VCahwgw");
@@ -214,8 +214,8 @@ TEST_CASE("Account keypair generation & signing (secp256k1)")
         "p9JfM6HHi64m6mvB6v5k7G2b1cXzGmYiCNJf6GHPKvFTWdeRVjh");
 
     auto sig = sign(pk, sk, makeSlice(message1));
-    CHECK(sig.size() != 0);
-    CHECK(verify(pk, makeSlice(message1), sig));
+    CHECK_NE(sig.size(), 0);
+    CHECK_UNARY(verify(pk, makeSlice(message1), sig));
 
     // Correct public key but wrong message
     CHECK_FALSE(verify(pk, makeSlice(message2), sig));
@@ -245,7 +245,8 @@ TEST_CASE("Account keypair generation & signing (ed25519)")
     auto const [pk, sk] =
         generateKeyPair(KeyType::ed25519, generateSeed("masterpassphrase"));
 
-    CHECK(to_string(calcAccountID(pk)) == "rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf");
+    CHECK_EQ(
+        to_string(calcAccountID(pk)), "rGWrZyQqhTp9Xu7G5Pkayo7bXjH4k4QYpf");
     CHECK(
         toBase58(TokenType::AccountPublic, pk) ==
         "aKGheSBjmCsKJVuLNKRAKpZXT6wpk2FCuEZAXJupXgdAxX5THCqR");
@@ -254,8 +255,8 @@ TEST_CASE("Account keypair generation & signing (ed25519)")
         "pwDQjwEhbUBmPuEjFpEG75bFhv2obkCB7NxQsfFxM7xGHBMVPu9");
 
     auto sig = sign(pk, sk, makeSlice(message1));
-    CHECK(sig.size() != 0);
-    CHECK(verify(pk, makeSlice(message1), sig));
+    CHECK_NE(sig.size(), 0);
+    CHECK_UNARY(verify(pk, makeSlice(message1), sig));
 
     // Correct public key but wrong message
     CHECK_FALSE(verify(pk, makeSlice(message2), sig));

src/doctest/protocol/Serializer.cpp

@@ -20,9 +20,9 @@ TEST_CASE("Serializer add32/geti32")
     {
         Serializer s;
         s.add32(value);
-        CHECK(s.size() == 4);
+        CHECK_EQ(s.size(), 4);
         SerialIter sit(s.slice());
-        CHECK(sit.geti32() == value);
+        CHECK_EQ(sit.geti32(), value);
     }
 }
 
@@ -38,9 +38,9 @@ TEST_CASE("Serializer add64/geti64")
     {
         Serializer s;
         s.add64(value);
-        CHECK(s.size() == 8);
+        CHECK_EQ(s.size(), 8);
         SerialIter sit(s.slice());
-        CHECK(sit.geti64() == value);
+        CHECK_EQ(sit.geti64(), value);
     }
 }
 

src/doctest/protocol/TER.cpp

@@ -20,13 +20,13 @@ TEST_CASE("transResultInfo")
 
         std::string token, text;
         auto good = transResultInfo(t, token, text);
-        CHECK((inRange || !good));
-        CHECK(transToken(t) == (good ? token : "-"));
-        CHECK(transHuman(t) == (good ? text : "-"));
+        CHECK_UNARY((inRange || !good));
+        CHECK_EQ(transToken(t), (good ? token : "-"));
+        CHECK_EQ(transHuman(t), (good ? text : "-"));
 
         auto code = transCode(token);
-        CHECK(good == !!code);
-        CHECK((!code || *code == t));
+        CHECK_EQ(good, !!code);
+        CHECK_UNARY((!code || *code == t));
     }
 }
 
@@ -87,12 +87,12 @@ TEST_CASE("comparison")
 {
     // Test comparison operators on TER types
     auto checkComparable = [](auto lhs, auto rhs) {
-        CHECK((lhs == rhs) == (TERtoInt(lhs) == TERtoInt(rhs)));
-        CHECK((lhs != rhs) == (TERtoInt(lhs) != TERtoInt(rhs)));
-        CHECK((lhs < rhs) == (TERtoInt(lhs) < TERtoInt(rhs)));
-        CHECK((lhs <= rhs) == (TERtoInt(lhs) <= TERtoInt(rhs)));
-        CHECK((lhs > rhs) == (TERtoInt(lhs) > TERtoInt(rhs)));
-        CHECK((lhs >= rhs) == (TERtoInt(lhs) >= TERtoInt(rhs)));
+        CHECK_EQ((lhs == rhs), (TERtoInt(lhs) == TERtoInt(rhs)));
+        CHECK_EQ((lhs != rhs), (TERtoInt(lhs) != TERtoInt(rhs)));
+        CHECK_EQ((lhs < rhs), (TERtoInt(lhs) < TERtoInt(rhs)));
+        CHECK_EQ((lhs <= rhs), (TERtoInt(lhs) <= TERtoInt(rhs)));
+        CHECK_EQ((lhs > rhs), (TERtoInt(lhs) > TERtoInt(rhs)));
+        CHECK_EQ((lhs >= rhs), (TERtoInt(lhs) >= TERtoInt(rhs)));
     };
 
     // Test various TER type comparisons