Read-only mirrors. Development, issues and pull requests are on GitHub.

summaryrefslogtreecommitdiffhomepage
path: root/src/catch2
diff options
context:
space:
mode:
authorMartin Hořeňovský2020-03-28 15:17:12 +0100
committerMartin Hořeňovský2020-03-28 15:17:12 +0100
commitca5af2e85b864ef15e584bc010581491f6be57a7 (patch)
treec0ea5e6bbffa4800a8910820b637d20053fb52aa /src/catch2
parent904c47a63467ddd4a343a0f5492710ba1e29c9f9 (diff)
downloadcatch3-ca5af2e85b864ef15e584bc010581491f6be57a7.tar.gz
Cleanup vector matchers
Once again, added doxygen comments and removed the inner-most namespace.
Diffstat (limited to 'src/catch2')
-rw-r--r--src/catch2/matchers/catch_matchers_vector.hpp240
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