Kiểm tra điểm nổi std :: vector với C++ Catch

Question

Có khả năng nào trong khung kiểm tra Đơn vị C++ để so sánh std :: vectơ là kiểu dấu phẩy động không? Tôi biết rằng tôi có thể so sánh kích thước của cả hai container và mỗi phần tử (sử dụng Approx) nhưng điều này là lộn xộn.

So sánh các loại tích phân hoạt động đúng cách.

Bây giờ, tôi phải sử dụng xây dựng như

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

Nhưng tôi muốn sử dụng một liner (nó hoạt động với nhiều loại không thể thiếu):

REQUIRE(computed == expected); 

Answer 1

Bạn có thể viết

CHECK_THAT(actual, EqualsApprox(expected)); 

sử dụng công cụ so khớp tùy chỉnh này:

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