使用C++ Catch测试浮点数std::vector

Question

在Catch C++单元测试框架中，有没有可能比较基于浮点类型的std::vectors？我知道我可以比较两个容器的大小和每个元素（使用Approx），但这很混乱。

整数类型向量的比较可以正常工作。

现在，我必须使用这样的结构

REQUIRE(computed.size() == expected.size());
for (size_t i = 0; i < computed.size(); ++i)
    REQUIRE(computed[i] == Approx(expected[i]));

但我想使用一行代码（它适用于整数类型）：

REQUIRE(computed == expected);

- miqelm

---

精确比较有什么问题？ - n. m.

舍入误差 - miqelm

如果你的舍入误差在不同运行之间不一致，那么你的单元测试最好报告这一点。 - n. m.

是的，但正如我所说的，std::equal 可以帮助你摆脱所有混乱，除了实际不可避免的近似值问题： REQUIRE(std::equal(computed.begin(),computed.end(),expected.begin(),expected.end(), [](float x, float y)->bool { return x==Approx(y); })); - Ap31

希望有一天我们能拥有标准范围:) 至于lambda，最好是在某个地方定义一个通用函数，然后将其传递给std::equal，这样还可以节省一些空间。 - Ap31

Answer 1

下面的代码是由Catch2自己提供的，不需要自己编写。

 REQUIRE_THAT( computed, Catch::Approx(expected).epsilon(1.e-5) );

- Etuka Onono

Answer 2

你可以书写

CHECK_THAT(actual, EqualsApprox(expected));

使用这个自定义匹配器：

#include <vector>
#include <functional>

#include <catch.hpp>

template<typename T, typename Compare>
struct CompareMatcher
        : Catch::Matchers::Impl::MatcherBase<std::vector<T>, std::vector<T> > {

    CompareMatcher(const std::vector<T> &comparator, const Compare &compare)
            : m_comparator(comparator),
              m_compare(compare) {}

    bool match(const std::vector<T> &v) const CATCH_OVERRIDE {
        if (m_comparator.size() != v.size()) {
            return false;
        }
        for (size_t i = 0; i < v.size(); ++i) {
            if (!m_compare(m_comparator[i], v[i])) {
                return false;
            }
        }
        return true;
    }

    virtual std::string describe() const CATCH_OVERRIDE {
        return "Equals: " + Catch::toString(m_comparator);
    }

    const std::vector<T> &m_comparator;
    Compare const &m_compare;
};

template<typename T, typename C>
CompareMatcher<T, C>
Compare(const std::vector<T> &comparator, const C &compare) {
    return CompareMatcher<T, C>(comparator, compare);
}

auto EqualsApprox(const std::vector<double> &comparator) {
    return Compare(comparator, [=](double actual, double expected) {
        return actual == Approx(expected);
    });
}

TEST_CASE("example", "[]") {
    SECTION("passes") {
        std::vector<double> actual {0, 1.00001};
        std::vector<double> expected {0, 1};
        CHECK_THAT(actual, EqualsApprox(expected));
    }
    SECTION("fails") {
        std::vector<double> actual {0, 1.0001};
        std::vector<double> expected {0, 1};
        CHECK_THAT(actual, EqualsApprox(expected));
    }
}

- maiermic

---

为什么最终的 EqualsApprox 不也是一个模板？ - aschepler

Approx is using double . - maiermic

Answer 3

我有同样的需求，所以我决定使用简单的宏：

#define CHECK_VEC_EQUAL(x, y) \
    REQUIRE(x.size() == y.size()); \
    for (size_t i = 0; i < x.size(); ++i) { \
            if (x[i] != Approx(y[i])) { \
                    REQUIRE(x[i] == Approx(y[i])); \
            } \
    }

这个宏可以用作一行代码，并且每次成功的比较仅计算为单个断言。

- DzedCPT

---

谢谢，上面的自定义比较匹配器很好，但说实话，我更喜欢你的宏选项。 - Conrad Jones