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

summaryrefslogtreecommitdiffhomepage
path: root/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
diff options
context:
space:
mode:
authorMartin Hořeňovský2020-12-26 23:09:51 +0100
committerMartin Hořeňovský2020-12-27 20:20:55 +0100
commit77643ce2e56233d7e9d3974b5efdb40b0e9149e1 (patch)
tree29c87f7e64ee52df8e65889164e7761ba88be64d /tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
parent552af8920df24e16738dbb1cb6b46dd52de7804c (diff)
downloadcatch3-77643ce2e56233d7e9d3974b5efdb40b0e9149e1.tar.gz
Add more comprehensive tests for the quantifier matchers
This includes * Testing both positive and negative path through the matchers * Testing them with types whose `begin` and `end` member functions require ADL * Testing them with types that return different types from `begin` and `end`
Diffstat (limited to 'tests/SelfTest/UsageTests/MatchersRanges.tests.cpp')
-rw-r--r--tests/SelfTest/UsageTests/MatchersRanges.tests.cpp353
1 files changed, 312 insertions, 41 deletions
diff --git a/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp b/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
index 13b546e3..912b5cdb 100644
--- a/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
+++ b/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
@@ -6,6 +6,7 @@
#include <catch2/matchers/catch_matchers_contains.hpp>
#include <catch2/matchers/catch_matchers_floating_point.hpp>
#include <catch2/matchers/catch_matchers_quantifiers.hpp>
+#include <catch2/matchers/catch_matchers_predicate.hpp>
#include <catch2/matchers/catch_matchers_string.hpp>
#include <array>
@@ -33,8 +34,143 @@ namespace unrelated {
}
};
} // end unrelated namespace
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+class has_different_begin_end_types {
+ std::array<int, 5> elements{ {1, 2, 3, 4, 5} };
+
+ // Different type for the "end" iterator
+ struct iterator_end {};
+ // Just a fake forward iterator, that only compares to a different
+ // type (so we can test two-type ranges).
+ struct iterator {
+ int const* start;
+ int const* end;
+
+ using iterator_category = std::forward_iterator_tag;
+ using difference_type = std::ptrdiff_t;
+ using value_type = int;
+ using reference = int const&;
+ using pointer = int const*;
+
+
+ friend bool operator==( iterator iter, iterator_end ) {
+ return iter.start == iter.end;
+ }
+ friend bool operator!=( iterator iter, iterator_end ) {
+ return iter.start != iter.end;
+ }
+ iterator& operator++() {
+ ++start;
+ return *this;
+ }
+ iterator operator++(int) {
+ auto tmp(*this);
+ ++start;
+ return tmp;
+ }
+ reference operator*() const {
+ return *start;
+ }
+ pointer operator->() const {
+ return start;
+ }
+ };
+
+
+public:
+ iterator begin() const {
+ return { elements.data(), elements.data() + elements.size() };
+ }
+
+ iterator_end end() const {
+ return {};
+ }
+};
+
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+
+
+struct with_mocked_iterator_access {
+ static constexpr size_t data_size = 5;
+ std::array<int, data_size> elements{ {1, 2, 3, 4, 5} };
+ std::array<bool, data_size> touched{};
+ std::array<bool, data_size> derefed{};
+
+ // We want to check which elements were touched when iterating, so
+ // we can check whether iterator-using code traverses range correctly
+ struct iterator {
+ with_mocked_iterator_access* m_origin;
+ size_t m_origin_idx;
+
+ using iterator_category = std::forward_iterator_tag;
+ using difference_type = std::ptrdiff_t;
+ using value_type = int;
+ using reference = int const&;
+ using pointer = int const*;
+
+ friend bool operator==(iterator lhs, iterator rhs) {
+ return lhs.m_origin == rhs.m_origin
+ && lhs.m_origin_idx == rhs.m_origin_idx;
+ }
+ friend bool operator!=(iterator lhs, iterator rhs) {
+ return !(lhs == rhs);
+ }
+ iterator& operator++() {
+ ++m_origin_idx;
+ assert(m_origin_idx < data_size + 1 && "Outside of valid alloc");
+ if (m_origin_idx < data_size) {
+ m_origin->touched[m_origin_idx] = true;
+ }
+ return *this;
+ }
+ iterator operator++(int) {
+ auto tmp(*this);
+ ++(*this);
+ return tmp;
+ }
+ reference operator*() const {
+ assert(m_origin_idx < data_size && "Attempted to deref invalid position");
+ m_origin->derefed[m_origin_idx] = true;
+ return m_origin->elements[m_origin_idx];
+ }
+ pointer operator->() const {
+ assert(m_origin_idx < data_size && "Attempted to deref invalid position");
+ return &m_origin->elements[m_origin_idx];
+ }
+
+ };
+
+ iterator begin() const {
+ // Const-cast away to avoid overcomplicating the iterators
+ // We should actually fix this over time
+ return { const_cast<with_mocked_iterator_access*>(this), 0 };
+ }
+ iterator end() const {
+ return { const_cast<with_mocked_iterator_access*>(this), data_size };
+ }
+
+};
+
} // end anon namespace
+namespace Catch {
+ template <>
+ struct StringMaker<with_mocked_iterator_access> {
+ static std::string convert(with_mocked_iterator_access const& access) {
+ // We have to avoid the type's iterators, because we check
+ // their use in tests
+ return ::Catch::Detail::stringify(access.elements);
+ }
+ };
+}
+
struct MoveOnlyTestElement {
int num = 0;
MoveOnlyTestElement(int n) :num(n) {}
@@ -220,55 +356,190 @@ TEST_CASE("Usage of the SizeIs range matcher", "[matchers][templated][size]") {
}
}
-TEST_CASE("Usage of the quantifiers matchers", "[matchers][templated][quantifiers]") {
+
+TEST_CASE("Usage of AllMatch range matcher", "[matchers][templated][quantifiers]") {
using Catch::Matchers::AllMatch;
- using Catch::Matchers::AnyMatch;
- using Catch::Matchers::Contains;
- using Catch::Matchers::EndsWith;
- using Catch::Matchers::IsEmpty;
- using Catch::Matchers::NoneMatch;
- using Catch::Matchers::SizeIs;
- using Catch::Matchers::StartsWith;
- std::array<std::array<int, 5>, 5> int_arr_arr{{
- {{ 0, 1, 2, 3, 5 }},
- {{ 4,-3,-2, 5, 0 }},
- {{ 0, 0, 0, 5, 0 }},
- {{ 0,-5, 0, 5, 0 }},
- {{ 1, 0, 0,-1, 5 }}
- }};
- std::vector<std::string> string_vector{ "Command+", "Catch2+", "CMake+", "C++", "Console+" };
- std::list<std::vector<int>> int_vectors_list{ { 1, 2 }, { 3, 4 }, { 5, 6 } };
-
- SECTION("Usage of the AllMatch range matcher") {
- REQUIRE_THAT(int_arr_arr, AllMatch(Contains(0)));
- REQUIRE_THAT(int_arr_arr, AllMatch(SizeIs(5)));
-
- REQUIRE_THAT(string_vector, AllMatch(StartsWith("C")));
- REQUIRE_THAT(string_vector, AllMatch(EndsWith("+")));
-
- REQUIRE_THAT(int_vectors_list, AllMatch(!IsEmpty()));
- REQUIRE_THAT(int_vectors_list, AllMatch(SizeIs(2)));
+ using Catch::Matchers::Predicate;
+
+ SECTION("Basic usage") {
+ using Catch::Matchers::Contains;
+ using Catch::Matchers::SizeIs;
+
+ std::array<std::array<int, 5>, 5> data{{
+ {{ 0, 1, 2, 3, 5 }},
+ {{ 4,-3,-2, 5, 0 }},
+ {{ 0, 0, 0, 5, 0 }},
+ {{ 0,-5, 0, 5, 0 }},
+ {{ 1, 0, 0,-1, 5 }}
+ }};
+
+ REQUIRE_THAT(data, AllMatch(SizeIs(5)));
+ REQUIRE_THAT(data, !AllMatch(Contains(0) && Contains(1)));
}
- SECTION("Usage of the AnyMatch range matcher") {
- REQUIRE_THAT(int_arr_arr, AnyMatch(Contains(-2)));
- REQUIRE_THAT(int_arr_arr, AnyMatch(SizeIs(5)));
+ SECTION("Type requires ADL found begin and end") {
+ unrelated::needs_ADL_begin needs_adl;
+ REQUIRE_THAT( needs_adl, AllMatch( Predicate<int>( []( int elem ) {
+ return elem < 6;
+ } ) ) );
+ }
+
+ SECTION("Shortcircuiting") {
+ with_mocked_iterator_access mocked;
+ SECTION("All are read") {
+ auto allMatch = AllMatch(Predicate<int>([](int elem) {
+ return elem < 10;
+ }));
+ REQUIRE_THAT(mocked, allMatch);
+ REQUIRE(mocked.derefed[0]);
+ REQUIRE(mocked.derefed[1]);
+ REQUIRE(mocked.derefed[2]);
+ REQUIRE(mocked.derefed[3]);
+ REQUIRE(mocked.derefed[4]);
+ }
+ SECTION("Short-circuited") {
+ auto allMatch = AllMatch(Predicate<int>([](int elem) {
+ return elem < 3;
+ }));
+ REQUIRE_THAT(mocked, !allMatch);
+ REQUIRE(mocked.derefed[0]);
+ REQUIRE(mocked.derefed[1]);
+ REQUIRE(mocked.derefed[2]);
+ REQUIRE_FALSE(mocked.derefed[3]);
+ REQUIRE_FALSE(mocked.derefed[4]);
+ }
+ }
+}
- REQUIRE_THAT(string_vector, AnyMatch(StartsWith("CMak")));
- REQUIRE_THAT(string_vector, AnyMatch(EndsWith("++")));
+TEST_CASE("Usage of AnyMatch range matcher", "[matchers][templated][quantifiers]") {
+ using Catch::Matchers::AnyMatch;
+ using Catch::Matchers::Predicate;
+
+ SECTION("Basic usage") {
+ using Catch::Matchers::Contains;
+ using Catch::Matchers::SizeIs;
+
+ std::array<std::array<int, 5>, 5> data{ {
+ {{ 0, 1, 2, 3, 5 }},
+ {{ 4,-3,-2, 5, 0 }},
+ {{ 0, 0, 0, 5, 0 }},
+ {{ 0,-5, 0, 5, 0 }},
+ {{ 1, 0, 0,-1, 5 }}
+ } };
+
+ REQUIRE_THAT(data, AnyMatch(SizeIs(5)));
+ REQUIRE_THAT(data, !AnyMatch(Contains(0) && Contains(10)));
+ }
+
+ SECTION("Type requires ADL found begin and end") {
+ unrelated::needs_ADL_begin needs_adl;
+ REQUIRE_THAT( needs_adl, AnyMatch( Predicate<int>( []( int elem ) {
+ return elem < 3;
+ } ) ) );
+ }
- REQUIRE_THAT(int_vectors_list, AnyMatch(Contains(4)));
- REQUIRE_THAT(int_vectors_list, AnyMatch(SizeIs(2)));
+ SECTION("Shortcircuiting") {
+ with_mocked_iterator_access mocked;
+ SECTION("All are read") {
+ auto anyMatch = AnyMatch(
+ Predicate<int>( []( int elem ) { return elem > 10; } ) );
+ REQUIRE_THAT( mocked, !anyMatch );
+ REQUIRE( mocked.derefed[0] );
+ REQUIRE( mocked.derefed[1] );
+ REQUIRE( mocked.derefed[2] );
+ REQUIRE( mocked.derefed[3] );
+ REQUIRE( mocked.derefed[4] );
+ }
+ SECTION("Short-circuited") {
+ auto anyMatch = AnyMatch(
+ Predicate<int>( []( int elem ) { return elem < 3; } ) );
+ REQUIRE_THAT( mocked, anyMatch );
+ REQUIRE( mocked.derefed[0] );
+ REQUIRE_FALSE( mocked.derefed[1] );
+ REQUIRE_FALSE( mocked.derefed[2] );
+ REQUIRE_FALSE( mocked.derefed[3] );
+ REQUIRE_FALSE( mocked.derefed[4] );
+ }
}
+}
- SECTION("Usage of the NoneMatch range matcher") {
- REQUIRE_THAT(int_arr_arr, NoneMatch(Contains(-6)));
- REQUIRE_THAT(int_arr_arr, NoneMatch(SizeIs(42)));
+TEST_CASE("Usage of NoneMatch range matcher", "[matchers][templated][quantifiers]") {
+ using Catch::Matchers::NoneMatch;
+ using Catch::Matchers::Predicate;
+
+ SECTION("Basic usage") {
+ using Catch::Matchers::Contains;
+ using Catch::Matchers::SizeIs;
+
+ std::array<std::array<int, 5>, 5> data{ {
+ {{ 0, 1, 2, 3, 5 }},
+ {{ 4,-3,-2, 5, 0 }},
+ {{ 0, 0, 0, 5, 0 }},
+ {{ 0,-5, 0, 5, 0 }},
+ {{ 1, 0, 0,-1, 5 }}
+ } };
+
+ REQUIRE_THAT(data, NoneMatch(SizeIs(6)));
+ REQUIRE_THAT(data, !NoneMatch(Contains(0) && Contains(1)));
+ }
- REQUIRE_THAT(string_vector, NoneMatch(StartsWith("abd")));
- REQUIRE_THAT(string_vector, NoneMatch(EndsWith("#!--")));
+ SECTION( "Type requires ADL found begin and end" ) {
+ unrelated::needs_ADL_begin needs_adl;
+ REQUIRE_THAT( needs_adl, NoneMatch( Predicate<int>( []( int elem ) {
+ return elem > 6;
+ } ) ) );
+ }
- REQUIRE_THAT(int_vectors_list, NoneMatch(IsEmpty()));
- REQUIRE_THAT(int_vectors_list, NoneMatch(SizeIs(3)));
+ SECTION("Shortcircuiting") {
+ with_mocked_iterator_access mocked;
+ SECTION("All are read") {
+ auto noneMatch = NoneMatch(
+ Predicate<int>([](int elem) { return elem > 10; }));
+ REQUIRE_THAT(mocked, noneMatch);
+ REQUIRE(mocked.derefed[0]);
+ REQUIRE(mocked.derefed[1]);
+ REQUIRE(mocked.derefed[2]);
+ REQUIRE(mocked.derefed[3]);
+ REQUIRE(mocked.derefed[4]);
+ }
+ SECTION("Short-circuited") {
+ auto noneMatch = NoneMatch(
+ Predicate<int>([](int elem) { return elem < 3; }));
+ REQUIRE_THAT(mocked, !noneMatch);
+ REQUIRE(mocked.derefed[0]);
+ REQUIRE_FALSE(mocked.derefed[1]);
+ REQUIRE_FALSE(mocked.derefed[2]);
+ REQUIRE_FALSE(mocked.derefed[3]);
+ REQUIRE_FALSE(mocked.derefed[4]);
+ }
}
}
+
+
+// This is a C++17 extension, and GCC refuses to compile such code
+// unless it is set to C++17 or later
+#if defined(CATCH_CPP17_OR_GREATER)
+
+TEST_CASE( "The quantifier range matchers support types with different types returned from begin and end",
+ "[matchers][templated][quantifiers][approvals]" ) {
+ using Catch::Matchers::AllMatch;
+ using Catch::Matchers::AnyMatch;
+ using Catch::Matchers::NoneMatch;
+
+ using Catch::Matchers::Predicate;
+
+ has_different_begin_end_types diff_types;
+ REQUIRE_THAT( diff_types, !AllMatch( Predicate<int>( []( int elem ) {
+ return elem < 3;
+ } ) ) );
+
+ REQUIRE_THAT( diff_types, AnyMatch( Predicate<int>( []( int elem ) {
+ return elem < 2;
+ } ) ) );
+
+ REQUIRE_THAT( diff_types, !NoneMatch( Predicate<int>( []( int elem ) {
+ return elem < 3;
+ } ) ) );
+}
+
+#endif