From 7466a40ada2b2faec9ee6f55aec74d3bbab8c37e Mon Sep 17 00:00:00 2001 From: Pratik Mankawde <3397372+pratikmankawde@users.noreply.github.com> Date: Wed, 21 Jan 2026 17:53:17 +0000 Subject: [PATCH] cleanup Signed-off-by: Pratik Mankawde <3397372+pratikmankawde@users.noreply.github.com> --- src/doctest/MIGRATION.md | 278 ++++++++++++++-- src/doctest/basics/Buffer.cpp | 188 +++++------ src/doctest/basics/Expected.cpp | 102 +++--- src/doctest/basics/IOUAmount.cpp | 178 +++++----- src/doctest/basics/KeyCache.cpp | 40 +-- src/doctest/basics/Number.cpp | 162 +++++----- src/doctest/basics/StringUtilities.cpp | 297 ++++++++--------- src/doctest/basics/TaggedCache.cpp | 70 ++-- src/doctest/basics/Units.cpp | 190 +++++------ src/doctest/basics/XRPAmount.cpp | 163 +++++----- src/doctest/basics/base58.cpp | 52 +-- src/doctest/basics/base_uint.cpp | 168 +++++----- src/doctest/basics/join.cpp | 6 +- src/doctest/beast/CurrentThreadName.cpp | 4 +- src/doctest/beast/IPEndpoint.cpp | 189 +++++------ src/doctest/beast/Journal.cpp | 24 +- src/doctest/beast/LexicalCast.cpp | 12 +- src/doctest/beast/PropertyStream.cpp | 22 +- src/doctest/beast/SemanticVersion.cpp | 36 +-- .../beast/aged_associative_container.cpp | 171 ++++------ src/doctest/beast/beast_Zero.cpp | 28 +- src/doctest/beast/xxhasher.cpp | 7 +- src/doctest/core/Workers.cpp | 10 +- src/doctest/csf/BasicNetwork.cpp | 40 +-- src/doctest/csf/Digraph.cpp | 46 +-- src/doctest/csf/Histogram.cpp | 72 ++--- src/doctest/csf/Scheduler.cpp | 44 +-- src/doctest/nodestore/varint.cpp | 8 +- src/doctest/protocol/BuildInfo.cpp | 24 +- src/doctest/protocol/Issue.cpp | 94 +++--- src/doctest/protocol/MultiApiJson.cpp | 304 ++++++++++-------- src/doctest/protocol/PublicKey.cpp | 12 +- src/doctest/protocol/Quality.cpp | 100 +++--- src/doctest/protocol/STAccount.cpp | 58 ++-- src/doctest/protocol/STInteger.cpp | 108 +++---- src/doctest/protocol/STNumber.cpp | 97 +++--- src/doctest/protocol/SecretKey.cpp | 72 ++--- src/doctest/protocol/Seed.cpp | 23 +- src/doctest/protocol/Serializer.cpp | 8 +- src/doctest/protocol/TER.cpp | 22 +- 40 files changed, 1880 insertions(+), 1649 deletions(-) diff --git a/src/doctest/MIGRATION.md b/src/doctest/MIGRATION.md index b4943b2d62..d614be7242 100644 --- a/src/doctest/MIGRATION.md +++ b/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 ` | `#include ` | -| `BEAST_EXPECT(expr)` | `CHECK(expr)` | -| `BEAST_EXPECTS(expr, msg)` | `CHECK_MESSAGE(expr, msg)` | -| `testcase("name")` | `SUBCASE("name")` | +| Beast Unit Test | Doctest Equivalent | +| ------------------------------------------- | ------------------------------- | +| `#include ` | `#include ` | +| `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 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 := " +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 - 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(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))` and function calls with template parameters like `CHECK(tryEdgeCase("..."))` 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/) diff --git a/src/doctest/basics/Buffer.cpp b/src/doctest/basics/Buffer.cpp index dc7cef1788..b9da19d508 100644 --- a/src/doctest/basics/Buffer.cpp +++ b/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(b0)}; - CHECK(sane(w)); - CHECK(w == b0); + CHECK_UNARY(sane(w)); + CHECK_EQ(w, b0); Buffer x{static_cast(b1)}; - CHECK(sane(x)); - CHECK(x == b1); + CHECK_UNARY(sane(x)); + CHECK_EQ(x, b1); Buffer y{static_cast(b2)}; - CHECK(sane(y)); - CHECK(y == b2); + CHECK_UNARY(sane(y)); + CHECK_EQ(y, b2); Buffer z{static_cast(b3)}; - CHECK(sane(z)); - CHECK(z == b3); + CHECK_UNARY(sane(z)); + CHECK_EQ(z, b3); // Assign empty slice to empty buffer w = static_cast(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(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(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(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(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) diff --git a/src/doctest/basics/Expected.cpp b/src/doctest/basics/Expected.cpp index 3edb30770b..1747bba420 100644 --- a/src/doctest/basics/Expected.cpp +++ b/src/doctest/basics/Expected.cpp @@ -18,11 +18,11 @@ TEST_CASE("non-error const construction") auto const expected = []() -> Expected { 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 { 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 { 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 { 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 { 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 { 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 { 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") { auto const expected = []() -> Expected { return {}; }(); - CHECK(expected); + CHECK_UNARY(expected); bool throwOccurred = false; try { @@ -170,16 +170,16 @@ TEST_CASE("non-error const construction of Expected") } 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") { auto expected = []() -> Expected { return {}; }(); - CHECK(expected); + CHECK_UNARY(expected); bool throwOccurred = false; try { @@ -188,10 +188,10 @@ TEST_CASE("non-error non-const construction of Expected") } 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") @@ -199,8 +199,8 @@ TEST_CASE("error const construction of Expected") auto const expected = []() -> Expected { 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") @@ -208,10 +208,10 @@ TEST_CASE("error non-const construction of Expected") auto expected = []() -> Expected { 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 { 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 diff --git a/src/doctest/basics/IOUAmount.cpp b/src/doctest/basics/IOUAmount.cpp index 7b662a1afa..de155f8db2 100644 --- a/src/doctest/basics/IOUAmount.cpp +++ b/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); } } diff --git a/src/doctest/basics/KeyCache.cpp b/src/doctest/basics/KeyCache.cpp index 286e24e7ef..0ec25d9158 100644 --- a/src/doctest/basics/KeyCache.cpp +++ b/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); } } diff --git a/src/doctest/basics/Number.cpp b/src/doctest/basics/Number.cpp index 4855915599..bf2b212146 100644 --- a/src/doctest/basics/Number.cpp +++ b/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::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::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(); diff --git a/src/doctest/basics/StringUtilities.cpp b/src/doctest/basics/StringUtilities.cpp index b848afe191..b177c3e16a 100644 --- a/src/doctest/basics/StringUtilities.cpp +++ b/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(); diff --git a/src/doctest/basics/TaggedCache.cpp b/src/doctest/basics/TaggedCache.cpp index dee8423a88..298f3c528c 100644 --- a/src/doctest/basics/TaggedCache.cpp +++ b/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("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("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); } } diff --git a/src/doctest/basics/Units.cpp b/src/doctest/basics/Units.cpp index ebfc56f964..c5fb2f9879 100644 --- a/src/doctest/basics/Units.cpp +++ b/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)); auto y = 4u * x; - CHECK(y.value() == 400); + CHECK_EQ(y.value(), 400); CHECK((std::is_same_v)); auto z = 4 * y; - CHECK(z.value() == 1600); + CHECK_EQ(z.value(), 1600); CHECK((std::is_same_v)); 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::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)); auto y = 4u * x; - CHECK(y.value() == 400); + CHECK_EQ(y.value(), 400); CHECK((std::is_same_v)); 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::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)); std::uint64_t m = 4; auto y = m * x; - CHECK(y.value() == 4096); + CHECK_EQ(y.value(), 4096); CHECK((std::is_same_v)); 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::unit_type, unit::dropTag>)); @@ -104,64 +104,64 @@ TEST_CASE("Json") { FeeLevel32 x{std::numeric_limits::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::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::max()}; auto y = x.jsonClipped(); - CHECK(y.type() == Json::uintValue); - CHECK(y == Json::Value{std::numeric_limits::max()}); + CHECK_EQ(y.type(), Json::uintValue); + CHECK_EQ(y, Json::Value{std::numeric_limits::max()}); } SUBCASE("FeeLevel64 min") { FeeLevel64 x{std::numeric_limits::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::max()}; auto y = x.jsonClipped(); - CHECK(y.type() == Json::realValue); - CHECK(y == Json::Value{std::numeric_limits::max()}); + CHECK_EQ(y.type(), Json::realValue); + CHECK_EQ(y, Json::Value{std::numeric_limits::max()}); } SUBCASE("FeeLevelDouble min") { FeeLevelDouble x{std::numeric_limits::min()}; auto y = x.jsonClipped(); - CHECK(y.type() == Json::realValue); - CHECK(y == Json::Value{std::numeric_limits::min()}); + CHECK_EQ(y.type(), Json::realValue); + CHECK_EQ(y, Json::Value{std::numeric_limits::min()}); } SUBCASE("XRPAmount max") { XRPAmount x{std::numeric_limits::max()}; auto y = x.jsonClipped(); - CHECK(y.type() == Json::intValue); - CHECK(y == Json::Value{std::numeric_limits::max()}); + CHECK_EQ(y.type(), Json::intValue); + CHECK_EQ(y, Json::Value{std::numeric_limits::max()}); } SUBCASE("XRPAmount min") { XRPAmount x{std::numeric_limits::min()}; auto y = x.jsonClipped(); - CHECK(y.type() == Json::intValue); - CHECK(y == Json::Value{std::numeric_limits::min()}); + CHECK_EQ(y.type(), Json::intValue); + CHECK_EQ(y, Json::Value{std::numeric_limits::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"); } } diff --git a/src/doctest/basics/XRPAmount.cpp b/src/doctest/basics/XRPAmount.cpp index bc5bb31290..bdcc388a2a 100644 --- a/src/doctest/basics/XRPAmount.cpp +++ b/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(); - CHECK(testOther); - CHECK(*testOther == 200); + CHECK_UNARY(testOther); + CHECK_EQ(*testOther, 200); test = std::numeric_limits::max(); testOther = test.dropsAs(); - CHECK(!testOther); + CHECK_FALSE(testOther); test = -1; testOther = test.dropsAs(); - 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); } } diff --git a/src/doctest/basics/base58.cpp b/src/doctest/basics/base58.cpp index ac319ec9d0..e8f8dbbd3f 100644 --- a/src/doctest/basics/base58.cpp +++ b/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(bigInt.data(), bigInt.size()), d); auto const foundDiv = multiprecision_utils::toBoostMP(bigInt); - CHECK(refMod.convert_to() == mod); - CHECK(foundDiv == refDiv); + CHECK_EQ(refMod.convert_to(), 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(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(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(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(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, diff --git a/src/doctest/basics/base_uint.cpp b/src/doctest/basics/base_uint.cpp index a9027fb33d..b1b0335476 100644 --- a/src/doctest/basics/base_uint.cpp +++ b/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> 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(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); } } diff --git a/src/doctest/basics/join.cpp b/src/doctest/basics/join.cpp index 3f0bd457de..ce7950a370 100644 --- a/src/doctest/basics/join.cpp +++ b/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 diff --git a/src/doctest/beast/CurrentThreadName.cpp b/src/doctest/beast/CurrentThreadName.cpp index 13206db80d..e819b4fb67 100644 --- a/src/doctest/beast/CurrentThreadName.cpp +++ b/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(); diff --git a/src/doctest/beast/IPEndpoint.cpp b/src/doctest/beast/IPEndpoint.cpp index 9f47e3f45a..23f1a4ee47 100644 --- a/src/doctest/beast/IPEndpoint.cpp +++ b/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: diff --git a/src/doctest/beast/Journal.cpp b/src/doctest/beast/Journal.cpp index 70ce35f7dd..6d531ca0ba 100644 --- a/src/doctest/beast/Journal.cpp +++ b/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(); diff --git a/src/doctest/beast/LexicalCast.cpp b/src/doctest/beast/LexicalCast.cpp index e9ec13a972..40ba77cc98 100644 --- a/src/doctest/beast/LexicalCast.cpp +++ b/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 @@ -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(result); - CHECK(number == j); + CHECK_EQ(number, j); } i++; diff --git a/src/doctest/beast/PropertyStream.cpp b/src/doctest/beast/PropertyStream.cpp index 12847b2717..edf2a5e8b6 100644 --- a/src/doctest/beast/PropertyStream.cpp +++ b/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 diff --git a/src/doctest/beast/SemanticVersion.cpp b/src/doctest/beast/SemanticVersion.cpp index 65fc923982..14d4248f88 100644 --- a/src/doctest/beast/SemanticVersion.cpp +++ b/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 diff --git a/src/doctest/beast/aged_associative_container.cpp b/src/doctest/beast/aged_associative_container.cpp index 9c23d1565a..5d1723a932 100644 --- a/src/doctest/beast/aged_associative_container.cpp +++ b/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::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>) { - 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>) { - 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); } } diff --git a/src/doctest/beast/beast_Zero.cpp b/src/doctest/beast/beast_Zero.cpp index d5151be293..64d19d893d 100644 --- a/src/doctest/beast/beast_Zero.cpp +++ b/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(); diff --git a/src/doctest/beast/xxhasher.cpp b/src/doctest/beast/xxhasher.cpp index 1594916657..95664b0797 100644 --- a/src/doctest/beast/xxhasher.cpp +++ b/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(hasher) == 1865045178324729219ULL); + CHECK_EQ( + static_cast(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(hasher); auto xxhashResult2 = static_cast(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); } } diff --git a/src/doctest/core/Workers.cpp b/src/doctest/core/Workers.cpp index de8e3516d2..c619e51848 100644 --- a/src/doctest/core/Workers.cpp +++ b/src/doctest/core/Workers.cpp @@ -101,7 +101,7 @@ testThreads(int const tc1, int const tc2, int const tc3) std::unique_ptr perfLog = std::make_unique(); 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 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 diff --git a/src/doctest/csf/BasicNetwork.cpp b/src/doctest/csf/BasicNetwork.cpp index e2e5914cc5..fd48f487ab 100644 --- a/src/doctest/csf/BasicNetwork.cpp +++ b/src/doctest/csf/BasicNetwork.cpp @@ -70,31 +70,31 @@ TEST_CASE("BasicNetwork operations") pv.emplace_back(2); Scheduler scheduler; BasicNetwork 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({0, 2, 4})); - CHECK(pv[1].set == std::set({1, 3})); - CHECK(pv[2].set == std::set({2, 4})); + CHECK_EQ(pv[0].set, std::set({0, 2, 4})); + CHECK_EQ(pv[1].set, std::set({1, 3})); + CHECK_EQ(pv[2].set, std::set({2, 4})); } TEST_CASE("BasicNetwork disconnect") @@ -102,21 +102,21 @@ TEST_CASE("BasicNetwork disconnect") using namespace std::chrono_literals; Scheduler scheduler; BasicNetwork 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 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({1})); + CHECK_EQ(delivered, std::set({1})); } TEST_SUITE_END(); diff --git a/src/doctest/csf/Digraph.cpp b/src/doctest/csf/Digraph.cpp index 1f8adda30f..22f1e84143 100644 --- a/src/doctest/csf/Digraph.cpp +++ b/src/doctest/csf/Digraph.cpp @@ -15,21 +15,21 @@ TEST_CASE("Digraph basic operations") using Graph = Digraph; 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> edges; @@ -42,22 +42,22 @@ TEST_CASE("Digraph basic operations") std::vector> 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 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(); diff --git a/src/doctest/csf/Histogram.cpp b/src/doctest/csf/Histogram.cpp index 0ed423e3b2..34a77ce812 100644 --- a/src/doctest/csf/Histogram.cpp +++ b/src/doctest/csf/Histogram.cpp @@ -10,15 +10,15 @@ TEST_CASE("Histogram empty") { Histogram 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 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(); diff --git a/src/doctest/csf/Scheduler.cpp b/src/doctest/csf/Scheduler.cpp index c017b016b2..0d747c715c 100644 --- a/src/doctest/csf/Scheduler.cpp +++ b/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({1})); - CHECK(scheduler.now() == (start + 1s)); + CHECK_UNARY(seen.empty()); + CHECK_UNARY(scheduler.step_one()); + CHECK_EQ(seen, std::set({1})); + CHECK_EQ(scheduler.now(), start + 1s); // No processing if stepping until current time - CHECK(scheduler.step_until(scheduler.now())); - CHECK(seen == std::set({1})); - CHECK(scheduler.now() == (start + 1s)); + CHECK_UNARY(scheduler.step_until(scheduler.now())); + CHECK_EQ(seen, std::set({1})); + CHECK_EQ(scheduler.now(), start + 1s); // Process next event - CHECK(scheduler.step_for(1s)); - CHECK(seen == std::set({1, 2})); - CHECK(scheduler.now() == (start + 2s)); + CHECK_UNARY(scheduler.step_for(1s)); + CHECK_EQ(seen, std::set({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({1, 2})); - CHECK(scheduler.now() == (start + 3s)); + CHECK_UNARY(scheduler.step_for(1s)); + CHECK_EQ(seen, std::set({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({1, 2, 4})); - CHECK(scheduler.now() == (start + 4s)); + CHECK_UNARY(scheduler.step_while([&]() { return seen.size() < 3; })); + CHECK_EQ(seen, std::set({1, 2, 4})); + CHECK_EQ(scheduler.now(), start + 4s); // Process the rest - CHECK(scheduler.step()); - CHECK(seen == std::set({1, 2, 4, 8})); - CHECK(scheduler.now() == (start + 8s)); + CHECK_UNARY(scheduler.step()); + CHECK_EQ(seen, std::set({1, 2, 4, 8})); + CHECK_EQ(scheduler.now(), start + 8s); // Process the rest again doesn't advance - CHECK(!scheduler.step()); - CHECK(seen == std::set({1, 2, 4, 8})); - CHECK(scheduler.now() == (start + 8s)); + CHECK_FALSE(scheduler.step()); + CHECK_EQ(seen, std::set({1, 2, 4, 8})); + CHECK_EQ(scheduler.now(), start + 8s); } TEST_SUITE_END(); diff --git a/src/doctest/nodestore/varint.cpp b/src/doctest/nodestore/varint.cpp index 954d8dbab5..1d106ed624 100644 --- a/src/doctest/nodestore/varint.cpp +++ b/src/doctest/nodestore/varint.cpp @@ -34,12 +34,12 @@ TEST_CASE("encode, decode") { std::array::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); } } diff --git a/src/doctest/protocol/BuildInfo.cpp b/src/doctest/protocol/BuildInfo.cpp index 000b8c7cd5..835fe064d3 100644 --- a/src/doctest/protocol/BuildInfo.cpp +++ b/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); } } diff --git a/src/doctest/protocol/Issue.cpp b/src/doctest/protocol/Issue.cpp index f445cec8dd..4025c81887 100644 --- a/src/doctest/protocol/Issue.cpp +++ b/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 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 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 diff --git a/src/doctest/protocol/MultiApiJson.cpp b/src/doctest/protocol/MultiApiJson.cpp index 1c9c2f0798..0ae1070cdc 100644 --- a/src/doctest/protocol/MultiApiJson.cpp +++ b/src/doctest/protocol/MultiApiJson.cpp @@ -48,10 +48,10 @@ TEST_CASE("forApiVersions, forAllApiVersions") static_assert( std::is_same_v>); - CHECK(subject.val.size() == 3); - CHECK( - (subject.val == - std::array{jsonNull, jsonNull, jsonNull})); + CHECK_EQ(subject.val.size(), 3); + CHECK_EQ( + subject.val, + (std::array{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{})); + CHECK_EQ(y.val, (std::array{})); 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) {}); }; }(s1)); - CHECK( + CHECK_EQ( s1.visitor( s1, std::integral_constant{}, @@ -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{}, [](Json::Value&) {}); }; }(s1)); - CHECK( + CHECK_EQ( s1.visitor( s1, std::integral_constant{}, 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) {}); }; }(std::as_const(s1))); - CHECK( + CHECK_EQ( s1.visitor( std::as_const(s1), std::integral_constant{}, @@ -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{}, 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{}, // 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{}, // 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{}, - [](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{}, - [](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{}, @@ -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{}, @@ -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) {}); }; }(s1)); - CHECK( + CHECK_EQ( s1.visit( std::integral_constant{}, 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) {}); }; }(s1)); - CHECK( + CHECK_EQ( s1.visit()( std::integral_constant{}, 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{}, [](Json::Value&) {}); }; }(s1)); - CHECK( + CHECK_EQ( s1.visit( std::integral_constant{}, 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{}, [](Json::Value&) {}); }; }(s1)); - CHECK( + CHECK_EQ( s1.visit()( std::integral_constant{}, 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) {}); }; }(std::as_const(s1))); - CHECK( + CHECK_EQ( std::as_const(s1).visit( std::integral_constant{}, 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) {}); }; }(std::as_const(s1))); - CHECK( + CHECK_EQ( std::as_const(s1).visit()( std::integral_constant{}, 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{}, 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{}, 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) { diff --git a/src/doctest/protocol/PublicKey.cpp b/src/doctest/protocol/PublicKey.cpp index 683a6bdf43..d45df08d60 100644 --- a/src/doctest/protocol/PublicKey.cpp +++ b/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(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(); diff --git a/src/doctest/protocol/Quality.cpp b/src/doctest/protocol/Quality.cpp index 369fe2db98..03c9c0090f 100644 --- a/src/doctest/protocol/Quality.cpp +++ b/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 @@ -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(); diff --git a/src/doctest/protocol/STAccount.cpp b/src/doctest/protocol/STAccount.cpp index 2f87f42773..45d1636f4f 100644 --- a/src/doctest/protocol/STAccount.cpp +++ b/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(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(s)); + CHECK_FALSE(parseBase58(s)); } TEST_SUITE_END(); diff --git a/src/doctest/protocol/STInteger.cpp b/src/doctest/protocol/STInteger.cpp index bb3ba8e4ce..7feca3df8a 100644 --- a/src/doctest/protocol/STInteger.cpp +++ b/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); } } diff --git a/src/doctest/protocol/STNumber.cpp b/src/doctest/protocol/STNumber.cpp index 582a29cf53..12388096b7 100644 --- a/src/doctest/protocol/STNumber.cpp +++ b/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 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::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::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::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))); } diff --git a/src/doctest/protocol/SecretKey.cpp b/src/doctest/protocol/SecretKey.cpp index bf975baff5..cd4c9ec96f 100644 --- a/src/doctest/protocol/SecretKey.cpp +++ b/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(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(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(); diff --git a/src/doctest/protocol/Seed.cpp b/src/doctest/protocol/Seed.cpp index 344b90481f..2bf3f4602a 100644 --- a/src/doctest/protocol/Seed.cpp +++ b/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)); diff --git a/src/doctest/protocol/Serializer.cpp b/src/doctest/protocol/Serializer.cpp index 1fffbee68f..0f9646fe23 100644 --- a/src/doctest/protocol/Serializer.cpp +++ b/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); } } diff --git a/src/doctest/protocol/TER.cpp b/src/doctest/protocol/TER.cpp index dcb0b64ede..261257eccc 100644 --- a/src/doctest/protocol/TER.cpp +++ b/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