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

summaryrefslogtreecommitdiffhomepage
path: root/tests/SelfTest/UsageTests
diff options
context:
space:
mode:
authorMartin Hořeňovský2020-03-09 11:13:07 +0100
committerMartin Hořeňovský2020-03-27 10:24:08 +0100
commit3a3efebd163f19dc8b9d8bbed4ab5309fc752867 (patch)
treeffc252431075ae2357b53d75caf2b27f96d03fbb /tests/SelfTest/UsageTests
parentf52a58e857967124bedf5370b5b03f799c1db0b2 (diff)
downloadcatch3-3a3efebd163f19dc8b9d8bbed4ab5309fc752867.tar.gz
Add IsEmpty and SizeIs matchers for ranges/containers
`SizeIs` can accept both `size_t` and a matcher. In the first case, it checks whether the size of the range is equal to specified size. In the second case, it checks whether the provided matcher accepts the size of the range.
Diffstat (limited to 'tests/SelfTest/UsageTests')
-rw-r--r--tests/SelfTest/UsageTests/MatchersRanges.tests.cpp112
1 files changed, 112 insertions, 0 deletions
diff --git a/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp b/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
index 7cf5590b..d958ac86 100644
--- a/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
+++ b/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
@@ -2,14 +2,17 @@
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_container_properties.hpp>
#include <catch2/matchers/catch_matchers_contains.hpp>
#include <catch2/matchers/catch_matchers_floating.hpp>
#include <array>
#include <cmath>
#include <list>
+#include <map>
#include <vector>
+namespace {
namespace unrelated {
class needs_ADL_begin {
std::array<int, 5> elements{ {1, 2, 3, 4, 5} };
@@ -27,6 +30,7 @@ namespace unrelated {
return rhs.End();
}
};
+} // end unrelated namespace
} // end anon namespace
struct MoveOnlyTestElement {
@@ -105,3 +109,111 @@ TEST_CASE("Basic use of the Contains range matcher", "[matchers][templated][cont
REQUIRE_THAT(in, Contains(Catch::Matchers::WithinAbs(0.5, 0.5)));
}
}
+
+namespace {
+
+ struct has_empty {
+ bool empty() const { return false; }
+ };
+
+namespace unrelated {
+ struct ADL_empty {
+ bool Empty() const { return true; }
+
+ friend bool empty(ADL_empty e) {
+ return e.Empty();
+ }
+ };
+
+} // end namespace unrelated
+} // end unnamed namespace
+
+TEST_CASE("Basic use of the Empty range matcher", "[matchers][templated][empty]") {
+ using Catch::Matchers::IsEmpty;
+ SECTION("Simple, std-provided containers") {
+ std::array<int, 0> empty_array{};
+ std::array<double, 1> non_empty_array{};
+ REQUIRE_THAT(empty_array, IsEmpty());
+ REQUIRE_THAT(non_empty_array, !IsEmpty());
+
+ std::vector<std::string> empty_vec;
+ std::vector<char> non_empty_vec{ 'a', 'b', 'c' };
+ REQUIRE_THAT(empty_vec, IsEmpty());
+ REQUIRE_THAT(non_empty_vec, !IsEmpty());
+
+ std::list<std::list<std::list<int>>> inner_lists_are_empty;
+ inner_lists_are_empty.push_back({});
+ REQUIRE_THAT(inner_lists_are_empty, !IsEmpty());
+ REQUIRE_THAT(inner_lists_are_empty.front(), IsEmpty());
+ }
+ SECTION("Type with empty") {
+ REQUIRE_THAT(has_empty{}, !IsEmpty());
+ }
+ SECTION("Type requires ADL found empty free function") {
+ REQUIRE_THAT(unrelated::ADL_empty{}, IsEmpty());
+ }
+}
+
+namespace {
+ class LessThanMatcher final : public Catch::Matchers::MatcherBase<size_t> {
+ size_t m_target;
+ public:
+ explicit LessThanMatcher(size_t target):
+ m_target(target)
+ {}
+
+ bool match(size_t const& size) const override {
+ return size < m_target;
+ }
+
+ std::string describe() const override {
+ return "is less than " + std::to_string(m_target);
+ }
+ };
+
+ LessThanMatcher Lt(size_t sz) {
+ return LessThanMatcher{ sz };
+ }
+
+ namespace unrelated {
+ struct ADL_size {
+ size_t sz() const {
+ return 12;
+ }
+ friend size_t size(ADL_size s) {
+ return s.sz();
+ }
+ };
+ } // end namespace unrelated
+
+ struct has_size {
+ size_t size() const {
+ return 13;
+ }
+ };
+
+} // end unnamed namespace
+
+TEST_CASE("Usage of the SizeIs range matcher", "[matchers][templated][size]") {
+ using Catch::Matchers::SizeIs;
+ SECTION("Some with stdlib containers") {
+ std::vector<int> empty_vec;
+ REQUIRE_THAT(empty_vec, SizeIs(0));
+ REQUIRE_THAT(empty_vec, !SizeIs(2));
+ REQUIRE_THAT(empty_vec, SizeIs(Lt(2)));
+
+ std::array<int, 2> arr{};
+ REQUIRE_THAT(arr, SizeIs(2));
+ REQUIRE_THAT(arr, SizeIs( Lt(3)));
+ REQUIRE_THAT(arr, !SizeIs(!Lt(3)));
+
+ std::map<int, int> map{ {1, 1}, {2, 2}, {3, 3} };
+ REQUIRE_THAT(map, SizeIs(3));
+ }
+ SECTION("Type requires ADL found size free function") {
+ REQUIRE_THAT(unrelated::ADL_size{}, SizeIs(12));
+ }
+ SECTION("Type has size member") {
+ REQUIRE_THAT(has_size{}, SizeIs(13));
+ }
+}