diff options
| author | Martin Hořeňovský | 2020-03-28 15:17:12 +0100 |
|---|---|---|
| committer | Martin Hořeňovský | 2020-03-28 15:17:12 +0100 |
| commit | ca5af2e85b864ef15e584bc010581491f6be57a7 (patch) | |
| tree | c0ea5e6bbffa4800a8910820b637d20053fb52aa /src | |
| parent | 904c47a63467ddd4a343a0f5492710ba1e29c9f9 (diff) | |
| download | catch3-ca5af2e85b864ef15e584bc010581491f6be57a7.tar.gz | |
Cleanup vector matchers
Once again, added doxygen comments and removed the inner-most namespace.
Diffstat (limited to 'src')
| -rw-r--r-- | src/catch2/matchers/catch_matchers_vector.hpp | 240 |
1 files changed, 124 insertions, 116 deletions
diff --git a/src/catch2/matchers/catch_matchers_vector.hpp b/src/catch2/matchers/catch_matchers_vector.hpp index e5d68949..cd506292 100644 --- a/src/catch2/matchers/catch_matchers_vector.hpp +++ b/src/catch2/matchers/catch_matchers_vector.hpp @@ -16,164 +16,172 @@ namespace Catch { namespace Matchers { - namespace Vector { - template<typename T> - struct ContainsElementMatcher final : MatcherBase<std::vector<T>> { + template<typename T> + struct ContainsElementMatcher final : MatcherBase<std::vector<T>> { - ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {} + ContainsElementMatcher(T const& comparator): + m_comparator(comparator) + {} - bool match(std::vector<T> const &v) const override { - for (auto const& el : v) { - if (el == m_comparator) { - return true; - } + bool match(std::vector<T> const& v) const override { + for (auto const& el : v) { + if (el == m_comparator) { + return true; } - return false; } + return false; + } - std::string describe() const override { - return "Contains: " + ::Catch::Detail::stringify( m_comparator ); - } + std::string describe() const override { + return "Contains: " + ::Catch::Detail::stringify( m_comparator ); + } - T const& m_comparator; - }; + T const& m_comparator; + }; - template<typename T> - struct ContainsMatcher final : MatcherBase<std::vector<T>> { + template<typename T> + struct ContainsMatcher final : MatcherBase<std::vector<T>> { - ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {} + ContainsMatcher(std::vector<T> const& comparator): + m_comparator(comparator) + {} - bool match(std::vector<T> const &v) const override { - // !TBD: see note in EqualsMatcher - if (m_comparator.size() > v.size()) - return false; - for (auto const& comparator : m_comparator) { - auto present = false; - for (const auto& el : v) { - if (el == comparator) { - present = true; - break; - } - } - if (!present) { - return false; + bool match(std::vector<T> const& v) const override { + // !TBD: see note in EqualsMatcher + if (m_comparator.size() > v.size()) + return false; + for (auto const& comparator : m_comparator) { + auto present = false; + for (const auto& el : v) { + if (el == comparator) { + present = true; + break; } } - return true; - } - std::string describe() const override { - return "Contains: " + ::Catch::Detail::stringify( m_comparator ); + if (!present) { + return false; + } } + return true; + } + std::string describe() const override { + return "Contains: " + ::Catch::Detail::stringify( m_comparator ); + } - std::vector<T> const& m_comparator; - }; + std::vector<T> const& m_comparator; + }; - template<typename T> - struct EqualsMatcher final : MatcherBase<std::vector<T>> { + template<typename T> + struct EqualsMatcher final : MatcherBase<std::vector<T>> { - EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {} + EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {} - bool match(std::vector<T> const &v) const override { - // !TBD: This currently works if all elements can be compared using != - // - a more general approach would be via a compare template that defaults - // to using !=. but could be specialised for, e.g. std::vector<T> etc - // - then just call that directly - if (m_comparator.size() != v.size()) + bool match(std::vector<T> const &v) const override { + // !TBD: This currently works if all elements can be compared using != + // - a more general approach would be via a compare template that defaults + // to using !=. but could be specialised for, e.g. std::vector<T> etc + // - then just call that directly + if (m_comparator.size() != v.size()) + return false; + for (std::size_t i = 0; i < v.size(); ++i) + if (m_comparator[i] != v[i]) return false; - for (std::size_t i = 0; i < v.size(); ++i) - if (m_comparator[i] != v[i]) - return false; - return true; - } - std::string describe() const override { - return "Equals: " + ::Catch::Detail::stringify( m_comparator ); - } - std::vector<T> const& m_comparator; - }; + return true; + } + std::string describe() const override { + return "Equals: " + ::Catch::Detail::stringify( m_comparator ); + } + std::vector<T> const& m_comparator; + }; - template<typename T> - struct ApproxMatcher final : MatcherBase<std::vector<T>> { + template<typename T> + struct ApproxMatcher final : MatcherBase<std::vector<T>> { - ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {} + ApproxMatcher(std::vector<T> const& comparator) : m_comparator( comparator ) {} - bool match(std::vector<T> const &v) const override { - if (m_comparator.size() != v.size()) + bool match(std::vector<T> const &v) const override { + if (m_comparator.size() != v.size()) + return false; + for (std::size_t i = 0; i < v.size(); ++i) + if (m_comparator[i] != approx(v[i])) return false; - for (std::size_t i = 0; i < v.size(); ++i) - if (m_comparator[i] != approx(v[i])) - return false; - return true; - } - std::string describe() const override { - return "is approx: " + ::Catch::Detail::stringify( m_comparator ); - } - template <typename = std::enable_if_t<std::is_constructible<double, T>::value>> - ApproxMatcher& epsilon( T const& newEpsilon ) { - approx.epsilon(newEpsilon); - return *this; - } - template <typename = std::enable_if_t<std::is_constructible<double, T>::value>> - ApproxMatcher& margin( T const& newMargin ) { - approx.margin(newMargin); - return *this; - } - template <typename = std::enable_if_t<std::is_constructible<double, T>::value>> - ApproxMatcher& scale( T const& newScale ) { - approx.scale(newScale); - return *this; - } + return true; + } + std::string describe() const override { + return "is approx: " + ::Catch::Detail::stringify( m_comparator ); + } + template <typename = std::enable_if_t<std::is_constructible<double, T>::value>> + ApproxMatcher& epsilon( T const& newEpsilon ) { + approx.epsilon(newEpsilon); + return *this; + } + template <typename = std::enable_if_t<std::is_constructible<double, T>::value>> + ApproxMatcher& margin( T const& newMargin ) { + approx.margin(newMargin); + return *this; + } + template <typename = std::enable_if_t<std::is_constructible<double, T>::value>> + ApproxMatcher& scale( T const& newScale ) { + approx.scale(newScale); + return *this; + } + + std::vector<T> const& m_comparator; + mutable Catch::Approx approx = Catch::Approx::custom(); + }; - std::vector<T> const& m_comparator; - mutable Catch::Approx approx = Catch::Approx::custom(); - }; - - template<typename T> - struct UnorderedEqualsMatcher final : MatcherBase<std::vector<T>> { - UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {} - bool match(std::vector<T> const& vec) const override { - // Note: This is a reimplementation of std::is_permutation, - // because I don't want to include <algorithm> inside the common path - if (m_target.size() != vec.size()) { - return false; - } - return std::is_permutation(m_target.begin(), m_target.end(), vec.begin()); + template<typename T> + struct UnorderedEqualsMatcher final : MatcherBase<std::vector<T>> { + UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {} + bool match(std::vector<T> const& vec) const override { + // Note: This is a reimplementation of std::is_permutation, + // because I don't want to include <algorithm> inside the common path + if (m_target.size() != vec.size()) { + return false; } + return std::is_permutation(m_target.begin(), m_target.end(), vec.begin()); + } - std::string describe() const override { - return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target); - } - private: - std::vector<T> const& m_target; - }; + std::string describe() const override { + return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target); + } + private: + std::vector<T> const& m_target; + }; - } // namespace Vector // The following functions create the actual matcher objects. // This allows the types to be inferred + + //! Creates a matcher that matches vectors that contain all elements in `comparator` template<typename T> - Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) { - return Vector::ContainsMatcher<T>( comparator ); + ContainsMatcher<T> Contains( std::vector<T> const& comparator ) { + return ContainsMatcher<T>( comparator ); } + //! Creates a matcher that matches vectors that contain `comparator` as an element template<typename T> - Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) { - return Vector::ContainsElementMatcher<T>( comparator ); + ContainsElementMatcher<T> VectorContains( T const& comparator ) { + return ContainsElementMatcher<T>( comparator ); } + //! Creates a matcher that matches vectors that are exactly equal to `comparator` template<typename T> - Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) { - return Vector::EqualsMatcher<T>( comparator ); + EqualsMatcher<T> Equals( std::vector<T> const& comparator ) { + return EqualsMatcher<T>( comparator ); } + //! Creates a matcher that matches vectors that `comparator` as an element template<typename T> - Vector::ApproxMatcher<T> Approx( std::vector<T> const& comparator ) { - return Vector::ApproxMatcher<T>( comparator ); + ApproxMatcher<T> Approx( std::vector<T> const& comparator ) { + return ApproxMatcher<T>( comparator ); } + //! Creates a matcher that matches vectors that is equal to `target` modulo permutation template<typename T> - Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) { - return Vector::UnorderedEqualsMatcher<T>(target); + UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) { + return UnorderedEqualsMatcher<T>(target); } } // namespace Matchers |