c ++ 11 — тестирование плавающей запятой std :: vector с C ++ Catch

Есть ли возможность в рамках модульного теста Catch C ++ сравнивать std :: vectors, основанные на типах с плавающей запятой? Я знаю, что могу сравнить размер обоих контейнеров и каждого элемента (используя Приблизительно), но это грязно.

Сравнение вектора интегральных типов работает корректно.

Теперь я должен использовать такую ​​конструкцию

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

Но я хотел бы использовать один лайнер (он работает для целочисленных типов):

REQUIRE(computed == expected);

8

Решение

Ты можешь написать

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));
}
}
2

Другие решения

У меня была такая же потребность, и я решил использовать простой макрос:

#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])); \
} \
}

Этот макрос можно использовать как однострочник, и каждое успешное сравнение считается только как одно утверждение.

0

По вопросам рекламы ammmcru@yandex.ru
Adblock
detector