Provide some easy way to compare structs containing float/doubles

[obfuscated]

I have Vector3, Color3 and similar classes that I need to test.
They look like:

struct A { float x, y, z; };

I want to be able to use something like the Floating point comparisons to do per component comparisons.
So I want to be able to do:

TEST_CASE("bla") {
   A a(...);
   A b(...);
   CHECK(a==doctest::Approx(b).epsilon(1e-6));
}

The added benefit is that the values of a and b will be visible when the test fails. At the moment I can only do this with a function returning a bool value.

[chambm]

Have you tried writing a function like:

void checkA(const A& lhs, const B& rhs) {
    CHECK(lhs.x==Approx(rhs.x));
    CHECK(lhs.y==Approx(rhs.y));
    CHECK(lhs.z==Approx(rhs.z));
}

[obfuscated]

@chambm: It doesn't work, because if the macro fails the error won't be on the line calling checkA, but inside checkA, so it will be really hard to debug this problem only looking at the log.

[chambm]

How about a macro then?

#define checkA(lhs, rhs) do { \
    CHECK((lhs).x==Approx((rhs).x)); \
    CHECK((lhs).y==Approx((rhs).y)); \
    CHECK((lhs).z==Approx((rhs).z)); \
    } while(false)

[onqtam]

I don't see a way for doctest to solve this for user types in a generic way out of the box - I'd recommend using a macro like @chambm suggests.

[madeso]

Sorry for necroing, but in catch2, that has the same construction, I implemented a custom templated version of Approx, that's basically calling a global approx_equal function: approx_equal(lhs, rhs, settings); This function has overloads for doubles and floats (the meat of the catch2 Approx implementation), and while I have to overload this function for my custom types like

bool approx_equal(const V& lhs, const V& rhs, const ApproxSettings& s) {
    return approx_equal(lhs.x, rhs.x, s)
        && approx_equal(lhs.y, rhs.y, s)
        && approx_equal(lhs.z, rhs.z, s);
}

it is less macros and I can use the standard CHECK macros and Approx api as usual. Also scales well for compound types that are based on other compound types.

Not sure if doctest support less/greater than operators for Approx like catch2 but I don't use them so they are excluded from my version.