diff options
| author | Martin Hořeňovský | 2020-12-26 23:09:51 +0100 |
|---|---|---|
| committer | Martin Hořeňovský | 2020-12-27 20:20:55 +0100 |
| commit | 77643ce2e56233d7e9d3974b5efdb40b0e9149e1 (patch) | |
| tree | 29c87f7e64ee52df8e65889164e7761ba88be64d /tests/SelfTest/UsageTests/MatchersRanges.tests.cpp | |
| parent | 552af8920df24e16738dbb1cb6b46dd52de7804c (diff) | |
| download | catch3-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.cpp | 353 |
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 |