Progmasoft Git

catch3

Progmasoft Catch3: an independently maintained C++17 test framework with a parallel runner, property checks, snapshots and structured results.

Clonegit clone https://git.progmasoft.com/catch3

Add AllTrue, AnyTrue, NoneTrue matchers

Commit
1bd233866c5ba1d94fbea34b260685b4b4ecb796
Author
Raphael Schaller ·
Committer
Martin Hořeňovský
Parents
f993b702c694

Files · Download .tar.gz

Changes

 docs/matchers.md                                   |  14 +
 src/CMakeLists.txt                                 |   1 +
 src/catch2/matchers/catch_matchers_quantifiers.cpp |  24 +
 src/catch2/matchers/catch_matchers_quantifiers.hpp |  59 +-
 tests/SelfTest/Baselines/automake.sw.approved.txt  |   3 +
 .../Baselines/automake.sw.multi.approved.txt       |   3 +
 tests/SelfTest/Baselines/compact.sw.approved.txt   |  57 ++
 .../Baselines/compact.sw.multi.approved.txt        |  57 ++
 tests/SelfTest/Baselines/console.std.approved.txt  |   4 +-
 tests/SelfTest/Baselines/console.sw.approved.txt   | 505 +++++++++++++++-
 .../Baselines/console.sw.multi.approved.txt        | 505 +++++++++++++++-
 tests/SelfTest/Baselines/junit.sw.approved.txt     |  29 +-
 .../SelfTest/Baselines/junit.sw.multi.approved.txt |  29 +-
 tests/SelfTest/Baselines/sonarqube.sw.approved.txt |  27 +
 .../Baselines/sonarqube.sw.multi.approved.txt      |  27 +
 tests/SelfTest/Baselines/tap.sw.approved.txt       | 116 +++-
 tests/SelfTest/Baselines/tap.sw.multi.approved.txt | 116 +++-
 tests/SelfTest/Baselines/teamcity.sw.approved.txt  |   6 +
 .../Baselines/teamcity.sw.multi.approved.txt       |   6 +
 tests/SelfTest/Baselines/xml.sw.approved.txt       | 669 ++++++++++++++++++++-
 tests/SelfTest/Baselines/xml.sw.multi.approved.txt | 669 ++++++++++++++++++++-
 tests/SelfTest/UsageTests/MatchersRanges.tests.cpp | 281 ++++++++-
 22 files changed, 3142 insertions(+), 65 deletions(-)

diff --git a/docs/matchers.md b/docs/matchers.md
index 3d0f8f11..0060bfd1 100644
--- a/docs/matchers.md
+++ b/docs/matchers.md
@@ -258,6 +258,12 @@ definitions to handle generic range-like types. These are:
 * `SizeIs(Matcher size_matcher)`
 * `Contains(T&& target_element, Comparator = std::equal_to<>{})`
 * `Contains(Matcher element_matcher)`
+* `AllMatch(Matcher element_matcher)`
+* `NoneMatch(Matcher element_matcher)`
+* `AnyMatch(Matcher element_matcher)`
+* `AllTrue()`
+* `NoneTrue()`
+* `AnyTrue()`
 
 `IsEmpty` should be self-explanatory. It successfully matches objects
 that are empty according to either `std::empty`, or ADL-found `empty`
@@ -275,6 +281,14 @@ the target element. The other variant is constructed from a matcher,
 in which case a range is accepted if any of its elements is accepted
 by the provided matcher.
 
+`AllMatch`, `NoneMatch`, and `AnyMatch` match ranges for which either
+all, none, or any of the contained elements matches the given matcher, 
+respectively.
+
+`AllTrue`, `NoneTrue`, and `AnyTrue` match ranges for which either
+all, none, or any of the contained elements are `true`, respectively. 
+It works for ranges of `bool`s and ranges of elements (explicitly) 
+convertible to `bool`.
 
 ## Writing custom matchers (old style)
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 2aa67b8f..b3dc5570 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -187,6 +187,7 @@ set(IMPL_SOURCES
     ${SOURCES_DIR}/interfaces/catch_interfaces_reporter.cpp
     ${SOURCES_DIR}/internal/catch_list.cpp
     ${SOURCES_DIR}/matchers/catch_matchers_floating_point.cpp
+    ${SOURCES_DIR}/matchers/catch_matchers_quantifiers.cpp
     ${SOURCES_DIR}/matchers/catch_matchers_string.cpp
     ${SOURCES_DIR}/matchers/catch_matchers_templated.cpp
     ${SOURCES_DIR}/catch_message.cpp
diff --git a/src/catch2/matchers/catch_matchers_quantifiers.cpp b/src/catch2/matchers/catch_matchers_quantifiers.cpp
new file mode 100644
index 00000000..1f2e48d8
--- /dev/null
+++ b/src/catch2/matchers/catch_matchers_quantifiers.cpp
@@ -0,0 +1,24 @@
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+#include <catch2/matchers/catch_matchers_quantifiers.hpp>
+
+namespace Catch {
+    namespace Matchers {
+        std::string AllTrueMatcher::describe() const { return "contains only true"; }
+
+        AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
+
+        std::string NoneTrueMatcher::describe() const { return "contains no true"; }
+
+        NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
+
+        std::string AnyTrueMatcher::describe() const { return "contains at least one true"; }
+
+        AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
+    } // namespace Matchers
+} // namespace Catch
diff --git a/src/catch2/matchers/catch_matchers_quantifiers.hpp b/src/catch2/matchers/catch_matchers_quantifiers.hpp
index e0e1a62d..8833440f 100644
--- a/src/catch2/matchers/catch_matchers_quantifiers.hpp
+++ b/src/catch2/matchers/catch_matchers_quantifiers.hpp
@@ -85,7 +85,55 @@ namespace Catch {
             }
         };
 
-        // Creates a matcher that checks whether a range contains element matching a matcher
+        // Matcher for checking that all elements in range are true.
+        class AllTrueMatcher final : public MatcherGenericBase {
+        public:
+            std::string describe() const override;
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (!elem) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        };
+
+        // Matcher for checking that no element in range is true.
+        class NoneTrueMatcher final : public MatcherGenericBase {
+        public:
+            std::string describe() const override;
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (elem) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        };
+
+        // Matcher for checking that any element in range is true.
+        class AnyTrueMatcher final : public MatcherGenericBase {
+        public:
+            std::string describe() const override;
+
+            template <typename RangeLike>
+            bool match(RangeLike&& rng) const {
+                for (auto&& elem : rng) {
+                    if (elem) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        };
+
+        // Creates a matcher that checks whether all elements in a range match a matcher
         template <typename Matcher>
         AllMatchMatcher<Matcher> AllMatch(Matcher&& matcher) {
             return { CATCH_FORWARD(matcher) };
@@ -102,6 +150,15 @@ namespace Catch {
         AnyMatchMatcher<Matcher> AnyMatch(Matcher&& matcher) {
             return { CATCH_FORWARD(matcher) };
         }
+
+        // Creates a matcher that checks whether all elements in a range are true
+        AllTrueMatcher AllTrue();
+
+        // Creates a matcher that checks whether no element in a range is true
+        NoneTrueMatcher NoneTrue();
+
+        // Creates a matcher that checks whether any element in a range is true
+        AnyTrueMatcher AnyTrue();
     }
 }
 
diff --git a/tests/SelfTest/Baselines/automake.sw.approved.txt b/tests/SelfTest/Baselines/automake.sw.approved.txt
index a0e83826..b8b59566 100644
--- a/tests/SelfTest/Baselines/automake.sw.approved.txt
+++ b/tests/SelfTest/Baselines/automake.sw.approved.txt
@@ -271,8 +271,11 @@ Message from section two
 :test-result: FAIL Unexpected exceptions can be translated
 :test-result: PASS Upcasting special member functions
 :test-result: PASS Usage of AllMatch range matcher
+:test-result: PASS Usage of AllTrue range matcher
 :test-result: PASS Usage of AnyMatch range matcher
+:test-result: PASS Usage of AnyTrue range matcher
 :test-result: PASS Usage of NoneMatch range matcher
+:test-result: PASS Usage of NoneTrue range matcher
 :test-result: PASS Usage of the SizeIs range matcher
 :test-result: PASS Use a custom approx
 :test-result: PASS Variadic macros
diff --git a/tests/SelfTest/Baselines/automake.sw.multi.approved.txt b/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
index a1dd3ffc..2afd308b 100644
--- a/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/automake.sw.multi.approved.txt
@@ -264,8 +264,11 @@
 :test-result: FAIL Unexpected exceptions can be translated
 :test-result: PASS Upcasting special member functions
 :test-result: PASS Usage of AllMatch range matcher
+:test-result: PASS Usage of AllTrue range matcher
 :test-result: PASS Usage of AnyMatch range matcher
+:test-result: PASS Usage of AnyTrue range matcher
 :test-result: PASS Usage of NoneMatch range matcher
+:test-result: PASS Usage of NoneTrue range matcher
 :test-result: PASS Usage of the SizeIs range matcher
 :test-result: PASS Use a custom approx
 :test-result: PASS Variadic macros
diff --git a/tests/SelfTest/Baselines/compact.sw.approved.txt b/tests/SelfTest/Baselines/compact.sw.approved.txt
index 1d2bf38b..6d23d01d 100644
--- a/tests/SelfTest/Baselines/compact.sw.approved.txt
+++ b/tests/SelfTest/Baselines/compact.sw.approved.txt
@@ -2013,6 +2013,25 @@ MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
 MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: data, AllTrue() for: { true, true, true, true, true } contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, AllTrue() for: {  } contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AllTrue() for: { true, true, false, true, true } not contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AllTrue() for: { false, false, false, false, false } not contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, AllTrue() for: { true, true, true, true, true } contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AllTrue() for: { true, true, false, true, true } not contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AllTrue() for: { false, false, false, false, false } not contains only true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, AllTrue() for: { true, true, true, true, true } contains only true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[4] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, !AllTrue() for: { true, true, false, true, true } not contains only true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: data, AnyMatch(SizeIs(5)) for: { { 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 } } any match has size == 5
 MatchersRanges.tests.cpp:<line number>: passed: data, !AnyMatch(Contains(0) && Contains(10)) for: { { 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 } } not any match ( contains element 0 and contains element 10 )
 MatchersRanges.tests.cpp:<line number>: passed: needs_adl, AnyMatch( Predicate<int>( []( int elem ) { return elem < 3; } ) ) for: { 1, 2, 3, 4, 5 } any match matches undescribed predicate
@@ -2028,6 +2047,25 @@ MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[1]) for: !fal
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[2]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: data, AnyTrue() for: { true, true, true, true, true } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AnyTrue() for: {  } not contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, AnyTrue() for: { false, false, true, false, false } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AnyTrue() for: { false, false, false, false, false } not contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, AnyTrue() for: { true, true, true, true, true } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, AnyTrue() for: { false, false, true, false, false } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AnyTrue() for: { false, false, false, false, false } not contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, AnyTrue() for: { false, false, false, false, true } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[4] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, AnyTrue() for: { false, false, true, true, true } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: data, NoneMatch(SizeIs(6)) for: { { 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 } } none match has size == 6
 MatchersRanges.tests.cpp:<line number>: passed: data, !NoneMatch(Contains(0) && Contains(1)) for: { { 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 } } not none match ( contains element 0 and contains element 1 )
 MatchersRanges.tests.cpp:<line number>: passed: needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) ) for: { 1, 2, 3, 4, 5 } none match matches undescribed predicate
@@ -2043,6 +2081,25 @@ MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[1]) for: !fal
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[2]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: data, !NoneTrue() for: { true, true, true, true, true } not contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, NoneTrue() for: {  } contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, !NoneTrue() for: { false, false, true, false, false } not contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, NoneTrue() for: { false, false, false, false, false } contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, !NoneTrue() for: { true, true, true, true, true } not contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, !NoneTrue() for: { false, false, true, false, false } not contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, NoneTrue() for: { false, false, false, false, false } contains no true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, NoneTrue() for: { false, false, false, false, false } contains no true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[4] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, !NoneTrue() for: { false, false, true, true, true } not contains no true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(0) for: {  } has size == 0
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, !SizeIs(2) for: {  } not has size == 2
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(Lt(2)) for: {  } size matches is less than 2
diff --git a/tests/SelfTest/Baselines/compact.sw.multi.approved.txt b/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
index fbce2de2..a3500a35 100644
--- a/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/compact.sw.multi.approved.txt
@@ -2006,6 +2006,25 @@ MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
 MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: data, AllTrue() for: { true, true, true, true, true } contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, AllTrue() for: {  } contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AllTrue() for: { true, true, false, true, true } not contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AllTrue() for: { false, false, false, false, false } not contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, AllTrue() for: { true, true, true, true, true } contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AllTrue() for: { true, true, false, true, true } not contains only true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AllTrue() for: { false, false, false, false, false } not contains only true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, AllTrue() for: { true, true, true, true, true } contains only true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[4] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, !AllTrue() for: { true, true, false, true, true } not contains only true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: data, AnyMatch(SizeIs(5)) for: { { 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 } } any match has size == 5
 MatchersRanges.tests.cpp:<line number>: passed: data, !AnyMatch(Contains(0) && Contains(10)) for: { { 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 } } not any match ( contains element 0 and contains element 10 )
 MatchersRanges.tests.cpp:<line number>: passed: needs_adl, AnyMatch( Predicate<int>( []( int elem ) { return elem < 3; } ) ) for: { 1, 2, 3, 4, 5 } any match matches undescribed predicate
@@ -2021,6 +2040,25 @@ MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[1]) for: !fal
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[2]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: data, AnyTrue() for: { true, true, true, true, true } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AnyTrue() for: {  } not contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, AnyTrue() for: { false, false, true, false, false } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AnyTrue() for: { false, false, false, false, false } not contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, AnyTrue() for: { true, true, true, true, true } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, AnyTrue() for: { false, false, true, false, false } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: data, !AnyTrue() for: { false, false, false, false, false } not contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, AnyTrue() for: { false, false, false, false, true } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[4] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, AnyTrue() for: { false, false, true, true, true } contains at least one true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: data, NoneMatch(SizeIs(6)) for: { { 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 } } none match has size == 6
 MatchersRanges.tests.cpp:<line number>: passed: data, !NoneMatch(Contains(0) && Contains(1)) for: { { 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 } } not none match ( contains element 0 and contains element 1 )
 MatchersRanges.tests.cpp:<line number>: passed: needs_adl, NoneMatch( Predicate<int>( []( int elem ) { return elem > 6; } ) ) for: { 1, 2, 3, 4, 5 } none match matches undescribed predicate
@@ -2036,6 +2074,25 @@ MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[1]) for: !fal
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[2]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: data, !NoneTrue() for: { true, true, true, true, true } not contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, NoneTrue() for: {  } contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, !NoneTrue() for: { false, false, true, false, false } not contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, NoneTrue() for: { false, false, false, false, false } contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, !NoneTrue() for: { true, true, true, true, true } not contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, !NoneTrue() for: { false, false, true, false, false } not contains no true
+MatchersRanges.tests.cpp:<line number>: passed: data, NoneTrue() for: { false, false, false, false, false } contains no true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, NoneTrue() for: { false, false, false, false, false } contains no true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[3] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[4] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked, !NoneTrue() for: { false, false, true, true, true } not contains no true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[0] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[1] for: true
+MatchersRanges.tests.cpp:<line number>: passed: mocked.m_derefed[2] for: true
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[3]) for: !false
+MatchersRanges.tests.cpp:<line number>: passed: !(mocked.m_derefed[4]) for: !false
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(0) for: {  } has size == 0
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, !SizeIs(2) for: {  } not has size == 2
 MatchersRanges.tests.cpp:<line number>: passed: empty_vec, SizeIs(Lt(2)) for: {  } size matches is less than 2
diff --git a/tests/SelfTest/Baselines/console.std.approved.txt b/tests/SelfTest/Baselines/console.std.approved.txt
index 0ad308be..6962e508 100644
--- a/tests/SelfTest/Baselines/console.std.approved.txt
+++ b/tests/SelfTest/Baselines/console.std.approved.txt
@@ -1394,6 +1394,6 @@ due to unexpected exception with message:
   Why would you throw a std::string?
 
 ===============================================================================
-test cases:  391 |  315 passed |  69 failed |  7 failed as expected
-assertions: 2227 | 2072 passed | 128 failed | 27 failed as expected
+test cases:  394 |  318 passed |  69 failed |  7 failed as expected
+assertions: 2284 | 2129 passed | 128 failed | 27 failed as expected
 
diff --git a/tests/SelfTest/Baselines/console.sw.approved.txt b/tests/SelfTest/Baselines/console.sw.approved.txt
index ae8af438..63dd231e 100644
--- a/tests/SelfTest/Baselines/console.sw.approved.txt
+++ b/tests/SelfTest/Baselines/console.sw.approved.txt
@@ -14146,6 +14146,173 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
 with expansion:
   !false
 
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Basic usage
+  All true evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AllTrue() )
+with expansion:
+  { true, true, true, true, true } contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Basic usage
+  Empty evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AllTrue() )
+with expansion:
+  {  } contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Basic usage
+  One false evalutes to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AllTrue() )
+with expansion:
+  { true, true, false, true, true } not contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Basic usage
+  All false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AllTrue() )
+with expansion:
+  { false, false, false, false, false } not contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Contained type is convertible to bool
+  All true evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AllTrue() )
+with expansion:
+  { true, true, true, true, true } contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Contained type is convertible to bool
+  One false evalutes to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AllTrue() )
+with expansion:
+  { true, true, false, true, true } not contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Contained type is convertible to bool
+  All false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AllTrue() )
+with expansion:
+  { false, false, false, false, false } not contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Shortcircuiting
+  All are read
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, AllTrue() )
+with expansion:
+  { true, true, true, true, true } contains only true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[3] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[4] )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Shortcircuiting
+  Short-circuited
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, !AllTrue() )
+with expansion:
+  { true, true, false, true, true } not contains only true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[3] )
+with expansion:
+  !false
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[4] )
+with expansion:
+  !false
+
 -------------------------------------------------------------------------------
 Usage of AnyMatch range matcher
   Basic usage
@@ -14254,6 +14421,173 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
 with expansion:
   !false
 
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Basic usage
+  All true evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AnyTrue() )
+with expansion:
+  { true, true, true, true, true } contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Basic usage
+  Empty evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AnyTrue() )
+with expansion:
+  {  } not contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Basic usage
+  One true evalutes to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AnyTrue() )
+with expansion:
+  { false, false, true, false, false } contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Basic usage
+  All false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AnyTrue() )
+with expansion:
+  { false, false, false, false, false } not contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Contained type is convertible to bool
+  All true evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AnyTrue() )
+with expansion:
+  { true, true, true, true, true } contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Contained type is convertible to bool
+  One true evalutes to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AnyTrue() )
+with expansion:
+  { false, false, true, false, false } contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Contained type is convertible to bool
+  All false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AnyTrue() )
+with expansion:
+  { false, false, false, false, false } not contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Shortcircuiting
+  All are read
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, AnyTrue() )
+with expansion:
+  { false, false, false, false, true } contains at least one true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[3] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[4] )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Shortcircuiting
+  Short-circuited
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, AnyTrue() )
+with expansion:
+  { false, false, true, true, true } contains at least one true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[3] )
+with expansion:
+  !false
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[4] )
+with expansion:
+  !false
+
 -------------------------------------------------------------------------------
 Usage of NoneMatch range matcher
   Basic usage
@@ -14362,6 +14696,173 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
 with expansion:
   !false
 
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Basic usage
+  All true evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !NoneTrue() )
+with expansion:
+  { true, true, true, true, true } not contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Basic usage
+  Empty evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, NoneTrue() )
+with expansion:
+  {  } contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Basic usage
+  One true evalutes to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !NoneTrue() )
+with expansion:
+  { false, false, true, false, false } not contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Basic usage
+  All false evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, NoneTrue() )
+with expansion:
+  { false, false, false, false, false } contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Contained type is convertible to bool
+  All true evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !NoneTrue() )
+with expansion:
+  { true, true, true, true, true } not contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Contained type is convertible to bool
+  One true evalutes to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !NoneTrue() )
+with expansion:
+  { false, false, true, false, false } not contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Contained type is convertible to bool
+  All false evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, NoneTrue() )
+with expansion:
+  { false, false, false, false, false } contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Shortcircuiting
+  All are read
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, NoneTrue() )
+with expansion:
+  { false, false, false, false, false } contains no true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[3] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[4] )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Shortcircuiting
+  Short-circuited
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, !NoneTrue() )
+with expansion:
+  { false, false, true, true, true } not contains no true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[3] )
+with expansion:
+  !false
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[4] )
+with expansion:
+  !false
+
 -------------------------------------------------------------------------------
 Usage of the SizeIs range matcher
   Some with stdlib containers
@@ -17949,6 +18450,6 @@ Misc.tests.cpp:<line number>
 Misc.tests.cpp:<line number>: PASSED:
 
 ===============================================================================
-test cases:  391 |  301 passed |  83 failed |  7 failed as expected
-assertions: 2242 | 2072 passed | 143 failed | 27 failed as expected
+test cases:  394 |  304 passed |  83 failed |  7 failed as expected
+assertions: 2299 | 2129 passed | 143 failed | 27 failed as expected
 
diff --git a/tests/SelfTest/Baselines/console.sw.multi.approved.txt b/tests/SelfTest/Baselines/console.sw.multi.approved.txt
index 3ae6d321..9cba323d 100644
--- a/tests/SelfTest/Baselines/console.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/console.sw.multi.approved.txt
@@ -14139,6 +14139,173 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
 with expansion:
   !false
 
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Basic usage
+  All true evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AllTrue() )
+with expansion:
+  { true, true, true, true, true } contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Basic usage
+  Empty evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AllTrue() )
+with expansion:
+  {  } contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Basic usage
+  One false evalutes to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AllTrue() )
+with expansion:
+  { true, true, false, true, true } not contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Basic usage
+  All false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AllTrue() )
+with expansion:
+  { false, false, false, false, false } not contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Contained type is convertible to bool
+  All true evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AllTrue() )
+with expansion:
+  { true, true, true, true, true } contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Contained type is convertible to bool
+  One false evalutes to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AllTrue() )
+with expansion:
+  { true, true, false, true, true } not contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Contained type is convertible to bool
+  All false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AllTrue() )
+with expansion:
+  { false, false, false, false, false } not contains only true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Shortcircuiting
+  All are read
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, AllTrue() )
+with expansion:
+  { true, true, true, true, true } contains only true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[3] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[4] )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Usage of AllTrue range matcher
+  Shortcircuiting
+  Short-circuited
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, !AllTrue() )
+with expansion:
+  { true, true, false, true, true } not contains only true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[3] )
+with expansion:
+  !false
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[4] )
+with expansion:
+  !false
+
 -------------------------------------------------------------------------------
 Usage of AnyMatch range matcher
   Basic usage
@@ -14247,6 +14414,173 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
 with expansion:
   !false
 
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Basic usage
+  All true evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AnyTrue() )
+with expansion:
+  { true, true, true, true, true } contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Basic usage
+  Empty evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AnyTrue() )
+with expansion:
+  {  } not contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Basic usage
+  One true evalutes to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AnyTrue() )
+with expansion:
+  { false, false, true, false, false } contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Basic usage
+  All false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AnyTrue() )
+with expansion:
+  { false, false, false, false, false } not contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Contained type is convertible to bool
+  All true evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AnyTrue() )
+with expansion:
+  { true, true, true, true, true } contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Contained type is convertible to bool
+  One true evalutes to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, AnyTrue() )
+with expansion:
+  { false, false, true, false, false } contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Contained type is convertible to bool
+  All false evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !AnyTrue() )
+with expansion:
+  { false, false, false, false, false } not contains at least one true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Shortcircuiting
+  All are read
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, AnyTrue() )
+with expansion:
+  { false, false, false, false, true } contains at least one true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[3] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[4] )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Usage of AnyTrue range matcher
+  Shortcircuiting
+  Short-circuited
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, AnyTrue() )
+with expansion:
+  { false, false, true, true, true } contains at least one true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[3] )
+with expansion:
+  !false
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[4] )
+with expansion:
+  !false
+
 -------------------------------------------------------------------------------
 Usage of NoneMatch range matcher
   Basic usage
@@ -14355,6 +14689,173 @@ MatchersRanges.tests.cpp:<line number>: PASSED:
 with expansion:
   !false
 
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Basic usage
+  All true evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !NoneTrue() )
+with expansion:
+  { true, true, true, true, true } not contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Basic usage
+  Empty evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, NoneTrue() )
+with expansion:
+  {  } contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Basic usage
+  One true evalutes to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !NoneTrue() )
+with expansion:
+  { false, false, true, false, false } not contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Basic usage
+  All false evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, NoneTrue() )
+with expansion:
+  { false, false, false, false, false } contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Contained type is convertible to bool
+  All true evaluates to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !NoneTrue() )
+with expansion:
+  { true, true, true, true, true } not contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Contained type is convertible to bool
+  One true evalutes to false
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, !NoneTrue() )
+with expansion:
+  { false, false, true, false, false } not contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Contained type is convertible to bool
+  All false evaluates to true
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( data, NoneTrue() )
+with expansion:
+  { false, false, false, false, false } contains no true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Shortcircuiting
+  All are read
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, NoneTrue() )
+with expansion:
+  { false, false, false, false, false } contains no true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[3] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[4] )
+with expansion:
+  true
+
+-------------------------------------------------------------------------------
+Usage of NoneTrue range matcher
+  Shortcircuiting
+  Short-circuited
+-------------------------------------------------------------------------------
+MatchersRanges.tests.cpp:<line number>
+...............................................................................
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_THAT( mocked, !NoneTrue() )
+with expansion:
+  { false, false, true, true, true } not contains no true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[0] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[1] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE( mocked.m_derefed[2] )
+with expansion:
+  true
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[3] )
+with expansion:
+  !false
+
+MatchersRanges.tests.cpp:<line number>: PASSED:
+  REQUIRE_FALSE( mocked.m_derefed[4] )
+with expansion:
+  !false
+
 -------------------------------------------------------------------------------
 Usage of the SizeIs range matcher
   Some with stdlib containers
@@ -17941,6 +18442,6 @@ Misc.tests.cpp:<line number>
 Misc.tests.cpp:<line number>: PASSED:
 
 ===============================================================================
-test cases:  391 |  301 passed |  83 failed |  7 failed as expected
-assertions: 2242 | 2072 passed | 143 failed | 27 failed as expected
+test cases:  394 |  304 passed |  83 failed |  7 failed as expected
+assertions: 2299 | 2129 passed | 143 failed | 27 failed as expected
 
diff --git a/tests/SelfTest/Baselines/junit.sw.approved.txt b/tests/SelfTest/Baselines/junit.sw.approved.txt
index e37a94ce..f7411501 100644
--- a/tests/SelfTest/Baselines/junit.sw.approved.txt
+++ b/tests/SelfTest/Baselines/junit.sw.approved.txt
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuitesloose text artifact
 >
-  <testsuite name="<exe-name>" errors="17" failures="126" tests="2242" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="17" failures="126" tests="2299" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
     <properties>
       <property name="random-seed" value="1"/>
       <property name="filters" value="~[!nonportable]~[!benchmark]~[approvals] *"/>
@@ -1412,14 +1412,41 @@ Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/One false evalutes to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evalutes to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/One true evalutes to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evalutes to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/One true evalutes to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evalutes to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Some with stdlib containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type requires ADL found size free function" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type has size member" time="{duration}" status="run"/>
diff --git a/tests/SelfTest/Baselines/junit.sw.multi.approved.txt b/tests/SelfTest/Baselines/junit.sw.multi.approved.txt
index 07614974..aa0860a3 100644
--- a/tests/SelfTest/Baselines/junit.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/junit.sw.multi.approved.txt
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <testsuites>
-  <testsuite name="<exe-name>" errors="17" failures="126" tests="2242" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
+  <testsuite name="<exe-name>" errors="17" failures="126" tests="2299" hostname="tbd" time="{duration}" timestamp="{iso8601-timestamp}">
     <properties>
       <property name="random-seed" value="1"/>
       <property name="filters" value="~[!nonportable]~[!benchmark]~[approvals] *"/>
@@ -1411,14 +1411,41 @@ Exception.tests.cpp:<line number>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/One false evalutes to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evalutes to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/One true evalutes to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evalutes to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Basic usage" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Type requires ADL found begin and end" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/One true evalutes to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evalutes to false" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" time="{duration}" status="run"/>
+    <testcase classname="<exe-name>.global" name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Some with stdlib containers" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type requires ADL found size free function" time="{duration}" status="run"/>
     <testcase classname="<exe-name>.global" name="Usage of the SizeIs range matcher/Type has size member" time="{duration}" status="run"/>
diff --git a/tests/SelfTest/Baselines/sonarqube.sw.approved.txt b/tests/SelfTest/Baselines/sonarqube.sw.approved.txt
index 6e88a61f..a9319a62 100644
--- a/tests/SelfTest/Baselines/sonarqube.sw.approved.txt
+++ b/tests/SelfTest/Baselines/sonarqube.sw.approved.txt
@@ -1397,14 +1397,41 @@ Matchers.tests.cpp:<line number>
     <testCase name="Usage of AllMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Basic usage/One false evalutes to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evalutes to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Basic usage/One true evalutes to true" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evalutes to true" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Basic usage/One true evalutes to false" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evalutes to false" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Some with stdlib containers" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Type requires ADL found size free function" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Type has size member" duration="{duration}"/>
diff --git a/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt b/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
index 6756a626..97b2d988 100644
--- a/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/sonarqube.sw.multi.approved.txt
@@ -1396,14 +1396,41 @@ Matchers.tests.cpp:<line number>
     <testCase name="Usage of AllMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AllMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Basic usage/One false evalutes to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/One false evalutes to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
+    <testCase name="Usage of AllTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of AnyMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Basic usage/All true evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Basic usage/Empty evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Basic usage/One true evalutes to true" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Basic usage/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All true evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/One true evalutes to true" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Contained type is convertible to bool/All false evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
+    <testCase name="Usage of AnyTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Basic usage" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Type requires ADL found begin and end" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Shortcircuiting/All are read" duration="{duration}"/>
     <testCase name="Usage of NoneMatch range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Basic usage/All true evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Basic usage/Empty evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Basic usage/One true evalutes to false" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Basic usage/All false evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All true evaluates to false" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/One true evalutes to false" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Contained type is convertible to bool/All false evaluates to true" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Shortcircuiting/All are read" duration="{duration}"/>
+    <testCase name="Usage of NoneTrue range matcher/Shortcircuiting/Short-circuited" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Some with stdlib containers" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Type requires ADL found size free function" duration="{duration}"/>
     <testCase name="Usage of the SizeIs range matcher/Type has size member" duration="{duration}"/>
diff --git a/tests/SelfTest/Baselines/tap.sw.approved.txt b/tests/SelfTest/Baselines/tap.sw.approved.txt
index b032e98a..2c7adae5 100644
--- a/tests/SelfTest/Baselines/tap.sw.approved.txt
+++ b/tests/SelfTest/Baselines/tap.sw.approved.txt
@@ -3530,6 +3530,44 @@ ok {test-number} - mocked.m_derefed[2] for: true
 ok {test-number} - !(mocked.m_derefed[3]) for: !false
 # Usage of AllMatch range matcher
 ok {test-number} - !(mocked.m_derefed[4]) for: !false
+# Usage of AllTrue range matcher
+ok {test-number} - data, AllTrue() for: { true, true, true, true, true } contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, AllTrue() for: {  } contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, !AllTrue() for: { true, true, false, true, true } not contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, !AllTrue() for: { false, false, false, false, false } not contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, AllTrue() for: { true, true, true, true, true } contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, !AllTrue() for: { true, true, false, true, true } not contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, !AllTrue() for: { false, false, false, false, false } not contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked, AllTrue() for: { true, true, true, true, true } contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[3] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[4] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked, !AllTrue() for: { true, true, false, true, true } not contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - !(mocked.m_derefed[3]) for: !false
+# Usage of AllTrue range matcher
+ok {test-number} - !(mocked.m_derefed[4]) for: !false
 # Usage of AnyMatch range matcher
 ok {test-number} - data, AnyMatch(SizeIs(5)) for: { { 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 } } any match has size == 5
 # Usage of AnyMatch range matcher
@@ -3560,6 +3598,44 @@ ok {test-number} - !(mocked.m_derefed[2]) for: !false
 ok {test-number} - !(mocked.m_derefed[3]) for: !false
 # Usage of AnyMatch range matcher
 ok {test-number} - !(mocked.m_derefed[4]) for: !false
+# Usage of AnyTrue range matcher
+ok {test-number} - data, AnyTrue() for: { true, true, true, true, true } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, !AnyTrue() for: {  } not contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, AnyTrue() for: { false, false, true, false, false } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, !AnyTrue() for: { false, false, false, false, false } not contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, AnyTrue() for: { true, true, true, true, true } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, AnyTrue() for: { false, false, true, false, false } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, !AnyTrue() for: { false, false, false, false, false } not contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked, AnyTrue() for: { false, false, false, false, true } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[3] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[4] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked, AnyTrue() for: { false, false, true, true, true } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - !(mocked.m_derefed[3]) for: !false
+# Usage of AnyTrue range matcher
+ok {test-number} - !(mocked.m_derefed[4]) for: !false
 # Usage of NoneMatch range matcher
 ok {test-number} - data, NoneMatch(SizeIs(6)) for: { { 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 } } none match has size == 6
 # Usage of NoneMatch range matcher
@@ -3590,6 +3666,44 @@ ok {test-number} - !(mocked.m_derefed[2]) for: !false
 ok {test-number} - !(mocked.m_derefed[3]) for: !false
 # Usage of NoneMatch range matcher
 ok {test-number} - !(mocked.m_derefed[4]) for: !false
+# Usage of NoneTrue range matcher
+ok {test-number} - data, !NoneTrue() for: { true, true, true, true, true } not contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, NoneTrue() for: {  } contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, !NoneTrue() for: { false, false, true, false, false } not contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, NoneTrue() for: { false, false, false, false, false } contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, !NoneTrue() for: { true, true, true, true, true } not contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, !NoneTrue() for: { false, false, true, false, false } not contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, NoneTrue() for: { false, false, false, false, false } contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked, NoneTrue() for: { false, false, false, false, false } contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[3] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[4] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked, !NoneTrue() for: { false, false, true, true, true } not contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - !(mocked.m_derefed[3]) for: !false
+# Usage of NoneTrue range matcher
+ok {test-number} - !(mocked.m_derefed[4]) for: !false
 # Usage of the SizeIs range matcher
 ok {test-number} - empty_vec, SizeIs(0) for: {  } has size == 0
 # Usage of the SizeIs range matcher
@@ -4487,5 +4601,5 @@ ok {test-number} - q3 == 23. for: 23.0 == 23.0
 ok {test-number} -
 # xmlentitycheck
 ok {test-number} -
-1..2242
+1..2299
 
diff --git a/tests/SelfTest/Baselines/tap.sw.multi.approved.txt b/tests/SelfTest/Baselines/tap.sw.multi.approved.txt
index 6118bddc..d13b493c 100644
--- a/tests/SelfTest/Baselines/tap.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/tap.sw.multi.approved.txt
@@ -3523,6 +3523,44 @@ ok {test-number} - mocked.m_derefed[2] for: true
 ok {test-number} - !(mocked.m_derefed[3]) for: !false
 # Usage of AllMatch range matcher
 ok {test-number} - !(mocked.m_derefed[4]) for: !false
+# Usage of AllTrue range matcher
+ok {test-number} - data, AllTrue() for: { true, true, true, true, true } contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, AllTrue() for: {  } contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, !AllTrue() for: { true, true, false, true, true } not contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, !AllTrue() for: { false, false, false, false, false } not contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, AllTrue() for: { true, true, true, true, true } contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, !AllTrue() for: { true, true, false, true, true } not contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - data, !AllTrue() for: { false, false, false, false, false } not contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked, AllTrue() for: { true, true, true, true, true } contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[3] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[4] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked, !AllTrue() for: { true, true, false, true, true } not contains only true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of AllTrue range matcher
+ok {test-number} - !(mocked.m_derefed[3]) for: !false
+# Usage of AllTrue range matcher
+ok {test-number} - !(mocked.m_derefed[4]) for: !false
 # Usage of AnyMatch range matcher
 ok {test-number} - data, AnyMatch(SizeIs(5)) for: { { 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 } } any match has size == 5
 # Usage of AnyMatch range matcher
@@ -3553,6 +3591,44 @@ ok {test-number} - !(mocked.m_derefed[2]) for: !false
 ok {test-number} - !(mocked.m_derefed[3]) for: !false
 # Usage of AnyMatch range matcher
 ok {test-number} - !(mocked.m_derefed[4]) for: !false
+# Usage of AnyTrue range matcher
+ok {test-number} - data, AnyTrue() for: { true, true, true, true, true } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, !AnyTrue() for: {  } not contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, AnyTrue() for: { false, false, true, false, false } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, !AnyTrue() for: { false, false, false, false, false } not contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, AnyTrue() for: { true, true, true, true, true } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, AnyTrue() for: { false, false, true, false, false } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - data, !AnyTrue() for: { false, false, false, false, false } not contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked, AnyTrue() for: { false, false, false, false, true } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[3] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[4] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked, AnyTrue() for: { false, false, true, true, true } contains at least one true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of AnyTrue range matcher
+ok {test-number} - !(mocked.m_derefed[3]) for: !false
+# Usage of AnyTrue range matcher
+ok {test-number} - !(mocked.m_derefed[4]) for: !false
 # Usage of NoneMatch range matcher
 ok {test-number} - data, NoneMatch(SizeIs(6)) for: { { 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 } } none match has size == 6
 # Usage of NoneMatch range matcher
@@ -3583,6 +3659,44 @@ ok {test-number} - !(mocked.m_derefed[2]) for: !false
 ok {test-number} - !(mocked.m_derefed[3]) for: !false
 # Usage of NoneMatch range matcher
 ok {test-number} - !(mocked.m_derefed[4]) for: !false
+# Usage of NoneTrue range matcher
+ok {test-number} - data, !NoneTrue() for: { true, true, true, true, true } not contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, NoneTrue() for: {  } contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, !NoneTrue() for: { false, false, true, false, false } not contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, NoneTrue() for: { false, false, false, false, false } contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, !NoneTrue() for: { true, true, true, true, true } not contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, !NoneTrue() for: { false, false, true, false, false } not contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - data, NoneTrue() for: { false, false, false, false, false } contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked, NoneTrue() for: { false, false, false, false, false } contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[3] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[4] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked, !NoneTrue() for: { false, false, true, true, true } not contains no true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[0] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[1] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - mocked.m_derefed[2] for: true
+# Usage of NoneTrue range matcher
+ok {test-number} - !(mocked.m_derefed[3]) for: !false
+# Usage of NoneTrue range matcher
+ok {test-number} - !(mocked.m_derefed[4]) for: !false
 # Usage of the SizeIs range matcher
 ok {test-number} - empty_vec, SizeIs(0) for: {  } has size == 0
 # Usage of the SizeIs range matcher
@@ -4479,5 +4593,5 @@ ok {test-number} - q3 == 23. for: 23.0 == 23.0
 ok {test-number} -
 # xmlentitycheck
 ok {test-number} -
-1..2242
+1..2299
 
diff --git a/tests/SelfTest/Baselines/teamcity.sw.approved.txt b/tests/SelfTest/Baselines/teamcity.sw.approved.txt
index c028b21a..526f00a9 100644
--- a/tests/SelfTest/Baselines/teamcity.sw.approved.txt
+++ b/tests/SelfTest/Baselines/teamcity.sw.approved.txt
@@ -651,10 +651,16 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "3.14"'
 ##teamcity[testFinished name='Upcasting special member functions' duration="{duration}"]
 ##teamcity[testStarted name='Usage of AllMatch range matcher']
 ##teamcity[testFinished name='Usage of AllMatch range matcher' duration="{duration}"]
+##teamcity[testStarted name='Usage of AllTrue range matcher']
+##teamcity[testFinished name='Usage of AllTrue range matcher' duration="{duration}"]
 ##teamcity[testStarted name='Usage of AnyMatch range matcher']
 ##teamcity[testFinished name='Usage of AnyMatch range matcher' duration="{duration}"]
+##teamcity[testStarted name='Usage of AnyTrue range matcher']
+##teamcity[testFinished name='Usage of AnyTrue range matcher' duration="{duration}"]
 ##teamcity[testStarted name='Usage of NoneMatch range matcher']
 ##teamcity[testFinished name='Usage of NoneMatch range matcher' duration="{duration}"]
+##teamcity[testStarted name='Usage of NoneTrue range matcher']
+##teamcity[testFinished name='Usage of NoneTrue range matcher' duration="{duration}"]
 ##teamcity[testStarted name='Usage of the SizeIs range matcher']
 ##teamcity[testFinished name='Usage of the SizeIs range matcher' duration="{duration}"]
 ##teamcity[testStarted name='Use a custom approx']
diff --git a/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt b/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
index 9f534639..2b791446 100644
--- a/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/teamcity.sw.multi.approved.txt
@@ -651,10 +651,16 @@ Exception.tests.cpp:<line number>|nunexpected exception with message:|n  "3.14"'
 ##teamcity[testFinished name='Upcasting special member functions' duration="{duration}"]
 ##teamcity[testStarted name='Usage of AllMatch range matcher']
 ##teamcity[testFinished name='Usage of AllMatch range matcher' duration="{duration}"]
+##teamcity[testStarted name='Usage of AllTrue range matcher']
+##teamcity[testFinished name='Usage of AllTrue range matcher' duration="{duration}"]
 ##teamcity[testStarted name='Usage of AnyMatch range matcher']
 ##teamcity[testFinished name='Usage of AnyMatch range matcher' duration="{duration}"]
+##teamcity[testStarted name='Usage of AnyTrue range matcher']
+##teamcity[testFinished name='Usage of AnyTrue range matcher' duration="{duration}"]
 ##teamcity[testStarted name='Usage of NoneMatch range matcher']
 ##teamcity[testFinished name='Usage of NoneMatch range matcher' duration="{duration}"]
+##teamcity[testStarted name='Usage of NoneTrue range matcher']
+##teamcity[testFinished name='Usage of NoneTrue range matcher' duration="{duration}"]
 ##teamcity[testStarted name='Usage of the SizeIs range matcher']
 ##teamcity[testFinished name='Usage of the SizeIs range matcher' duration="{duration}"]
 ##teamcity[testStarted name='Use a custom approx']
diff --git a/tests/SelfTest/Baselines/xml.sw.approved.txt b/tests/SelfTest/Baselines/xml.sw.approved.txt
index c541226a..0167e59c 100644
--- a/tests/SelfTest/Baselines/xml.sw.approved.txt
+++ b/tests/SelfTest/Baselines/xml.sw.approved.txt
@@ -16609,6 +16609,215 @@ There is no extra whitespace here
     </Section>
     <OverallResult success="true"/>
   </TestCase>
+  <TestCase name="Usage of AllTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Empty evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AllTrue()
+          </Original>
+          <Expanded>
+            {  } contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One false evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, false, true, true } not contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AllTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } not contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One false evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, false, true, true } not contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AllTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } not contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } contains only true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[1]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[2]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[3]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[4]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, !AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, false, true, true } not contains only true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[1]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[2]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[3])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[4])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <OverallResult success="true"/>
+  </TestCase>
   <TestCase name="Usage of AnyMatch range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
     <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
       <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16629,25 +16838,234 @@ There is no extra whitespace here
       </Expression>
       <OverallResults successes="2" failures="0" expectedFailures="0"/>
     </Section>
-    <Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
-      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
-        <Original>
-          needs_adl, AnyMatch( Predicate&lt;int>( []( int elem ) { return elem &lt; 3; } ) )
-        </Original>
-        <Expanded>
-          { 1, 2, 3, 4, 5 } any match matches undescribed predicate
-        </Expanded>
-      </Expression>
+    <Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Original>
+          needs_adl, AnyMatch( Predicate&lt;int>( []( int elem ) { return elem &lt; 3; } ) )
+        </Original>
+        <Expanded>
+          { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+        </Expanded>
+      </Expression>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, !anyMatch
+          </Original>
+          <Expanded>
+            { 1, 2, 3, 4, 5 } not any match matches undescribed predicate
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[1]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[2]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[3]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[4]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, anyMatch
+          </Original>
+          <Expanded>
+            { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[1])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[2])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[3])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[4])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <OverallResult success="true"/>
+  </TestCase>
+  <TestCase name="Usage of AnyTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AnyTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Empty evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AnyTrue()
+          </Original>
+          <Expanded>
+            {  } not contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One true evalutes to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AnyTrue()
+          </Original>
+          <Expanded>
+            { false, false, true, false, false } contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AnyTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } not contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AnyTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One true evalutes to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AnyTrue()
+          </Original>
+          <Expanded>
+            { false, false, true, false, false } contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AnyTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } not contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
       <OverallResults successes="1" failures="0" expectedFailures="0"/>
     </Section>
     <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
       <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
         <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
           <Original>
-            mocked, !anyMatch
+            mocked, AnyTrue()
           </Original>
           <Expanded>
-            { 1, 2, 3, 4, 5 } not any match matches undescribed predicate
+            { false, false, false, false, true } contains at least one true
           </Expanded>
         </Expression>
         <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16698,10 +17116,10 @@ There is no extra whitespace here
       <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
         <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
           <Original>
-            mocked, anyMatch
+            mocked, AnyTrue()
           </Original>
           <Expanded>
-            { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+            { false, false, true, true, true } contains at least one true
           </Expanded>
         </Expression>
         <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16712,20 +17130,20 @@ There is no extra whitespace here
             true
           </Expanded>
         </Expression>
-        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
           <Original>
-            !(mocked.m_derefed[1])
+            mocked.m_derefed[1]
           </Original>
           <Expanded>
-            !false
+            true
           </Expanded>
         </Expression>
-        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
           <Original>
-            !(mocked.m_derefed[2])
+            mocked.m_derefed[2]
           </Original>
           <Expanded>
-            !false
+            true
           </Expanded>
         </Expression>
         <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16891,6 +17309,215 @@ There is no extra whitespace here
     </Section>
     <OverallResult success="true"/>
   </TestCase>
+  <TestCase name="Usage of NoneTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !NoneTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } not contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Empty evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, NoneTrue()
+          </Original>
+          <Expanded>
+            {  } contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One true evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, true, false, false } not contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !NoneTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } not contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One true evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, true, false, false } not contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } contains no true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[1]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[2]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[3]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[4]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, !NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, true, true, true } not contains no true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[1]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[2]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[3])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[4])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <OverallResult success="true"/>
+  </TestCase>
   <TestCase name="Usage of the SizeIs range matcher" tags="[matchers][size][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
     <Section name="Some with stdlib containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
       <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -21075,6 +21702,6 @@ loose text artifact
     </Section>
     <OverallResult success="true"/>
   </TestCase>
-  <OverallResults successes="2072" failures="143" expectedFailures="27"/>
-  <OverallResultsCases successes="301" failures="83" expectedFailures="7"/>
+  <OverallResults successes="2129" failures="143" expectedFailures="27"/>
+  <OverallResultsCases successes="304" failures="83" expectedFailures="7"/>
 </Catch2TestRun>
diff --git a/tests/SelfTest/Baselines/xml.sw.multi.approved.txt b/tests/SelfTest/Baselines/xml.sw.multi.approved.txt
index 29222820..7a88f7de 100644
--- a/tests/SelfTest/Baselines/xml.sw.multi.approved.txt
+++ b/tests/SelfTest/Baselines/xml.sw.multi.approved.txt
@@ -16609,6 +16609,215 @@ There is no extra whitespace here
     </Section>
     <OverallResult success="true"/>
   </TestCase>
+  <TestCase name="Usage of AllTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Empty evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AllTrue()
+          </Original>
+          <Expanded>
+            {  } contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One false evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, false, true, true } not contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AllTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } not contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One false evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, false, true, true } not contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AllTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } not contains only true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } contains only true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[1]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[2]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[3]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[4]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, !AllTrue()
+          </Original>
+          <Expanded>
+            { true, true, false, true, true } not contains only true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[1]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[2]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[3])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[4])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <OverallResult success="true"/>
+  </TestCase>
   <TestCase name="Usage of AnyMatch range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
     <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
       <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16629,25 +16838,234 @@ There is no extra whitespace here
       </Expression>
       <OverallResults successes="2" failures="0" expectedFailures="0"/>
     </Section>
-    <Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
-      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
-        <Original>
-          needs_adl, AnyMatch( Predicate&lt;int>( []( int elem ) { return elem &lt; 3; } ) )
-        </Original>
-        <Expanded>
-          { 1, 2, 3, 4, 5 } any match matches undescribed predicate
-        </Expanded>
-      </Expression>
+    <Section name="Type requires ADL found begin and end" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Original>
+          needs_adl, AnyMatch( Predicate&lt;int>( []( int elem ) { return elem &lt; 3; } ) )
+        </Original>
+        <Expanded>
+          { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+        </Expanded>
+      </Expression>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, !anyMatch
+          </Original>
+          <Expanded>
+            { 1, 2, 3, 4, 5 } not any match matches undescribed predicate
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[1]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[2]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[3]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[4]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, anyMatch
+          </Original>
+          <Expanded>
+            { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[1])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[2])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[3])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[4])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <OverallResult success="true"/>
+  </TestCase>
+  <TestCase name="Usage of AnyTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AnyTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Empty evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AnyTrue()
+          </Original>
+          <Expanded>
+            {  } not contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One true evalutes to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AnyTrue()
+          </Original>
+          <Expanded>
+            { false, false, true, false, false } contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AnyTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } not contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AnyTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One true evalutes to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, AnyTrue()
+          </Original>
+          <Expanded>
+            { false, false, true, false, false } contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !AnyTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } not contains at least one true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
       <OverallResults successes="1" failures="0" expectedFailures="0"/>
     </Section>
     <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
       <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
         <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
           <Original>
-            mocked, !anyMatch
+            mocked, AnyTrue()
           </Original>
           <Expanded>
-            { 1, 2, 3, 4, 5 } not any match matches undescribed predicate
+            { false, false, false, false, true } contains at least one true
           </Expanded>
         </Expression>
         <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16698,10 +17116,10 @@ There is no extra whitespace here
       <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
         <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
           <Original>
-            mocked, anyMatch
+            mocked, AnyTrue()
           </Original>
           <Expanded>
-            { 1, 2, 3, 4, 5 } any match matches undescribed predicate
+            { false, false, true, true, true } contains at least one true
           </Expanded>
         </Expression>
         <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16712,20 +17130,20 @@ There is no extra whitespace here
             true
           </Expanded>
         </Expression>
-        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
           <Original>
-            !(mocked.m_derefed[1])
+            mocked.m_derefed[1]
           </Original>
           <Expanded>
-            !false
+            true
           </Expanded>
         </Expression>
-        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
           <Original>
-            !(mocked.m_derefed[2])
+            mocked.m_derefed[2]
           </Original>
           <Expanded>
-            !false
+            true
           </Expanded>
         </Expression>
         <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -16891,6 +17309,215 @@ There is no extra whitespace here
     </Section>
     <OverallResult success="true"/>
   </TestCase>
+  <TestCase name="Usage of NoneTrue range matcher" tags="[matchers][quantifiers][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !NoneTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } not contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Empty evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, NoneTrue()
+          </Original>
+          <Expanded>
+            {  } contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One true evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, true, false, false } not contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Basic usage" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All true evaluates to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !NoneTrue()
+          </Original>
+          <Expanded>
+            { true, true, true, true, true } not contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="One true evalutes to false" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, !NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, true, false, false } not contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Contained type is convertible to bool" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All false evaluates to true" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            data, NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } contains no true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="1" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="1" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="All are read" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, false, false, false } contains no true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[1]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[2]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[3]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[4]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <Section name="Shortcircuiting" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+      <Section name="Short-circuited" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+        <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked, !NoneTrue()
+          </Original>
+          <Expanded>
+            { false, false, true, true, true } not contains no true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[0]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[1]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            mocked.m_derefed[2]
+          </Original>
+          <Expanded>
+            true
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[3])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <Expression success="true" type="REQUIRE_FALSE" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
+          <Original>
+            !(mocked.m_derefed[4])
+          </Original>
+          <Expanded>
+            !false
+          </Expanded>
+        </Expression>
+        <OverallResults successes="6" failures="0" expectedFailures="0"/>
+      </Section>
+      <OverallResults successes="6" failures="0" expectedFailures="0"/>
+    </Section>
+    <OverallResult success="true"/>
+  </TestCase>
   <TestCase name="Usage of the SizeIs range matcher" tags="[matchers][size][templated]" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
     <Section name="Some with stdlib containers" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
       <Expression success="true" type="REQUIRE_THAT" filename="tests/<exe-name>/UsageTests/MatchersRanges.tests.cpp" >
@@ -21074,6 +21701,6 @@ There is no extra whitespace here
     </Section>
     <OverallResult success="true"/>
   </TestCase>
-  <OverallResults successes="2072" failures="143" expectedFailures="27"/>
-  <OverallResultsCases successes="301" failures="83" expectedFailures="7"/>
+  <OverallResults successes="2129" failures="143" expectedFailures="27"/>
+  <OverallResultsCases successes="304" failures="83" expectedFailures="7"/>
 </Catch2TestRun>
diff --git a/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp b/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
index f8ff7e13..1201581c 100644
--- a/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
+++ b/tests/SelfTest/UsageTests/MatchersRanges.tests.cpp
@@ -547,31 +547,288 @@ TEST_CASE("Usage of NoneMatch range matcher", "[matchers][templated][quantifiers
     }
 }
 
+namespace {
+    struct ConvertibleToBool
+    {
+        bool v;
+
+        explicit operator bool() const
+        {
+            return v;
+        }
+    };
+}
+
+namespace Catch {
+    template <>
+    struct StringMaker<ConvertibleToBool> {
+        static std::string
+        convert( ConvertibleToBool const& convertible_to_bool ) {
+            return ::Catch::Detail::stringify( convertible_to_bool.v );
+        }
+    };
+} // namespace Catch
+
+TEST_CASE("Usage of AllTrue range matcher", "[matchers][templated][quantifiers]") {
+    using Catch::Matchers::AllTrue;
+
+    SECTION( "Basic usage" ) {
+        SECTION( "All true evaluates to true" ) {
+            std::array<bool, 5> const data{ { true, true, true, true, true } };
+            REQUIRE_THAT( data, AllTrue() );
+        }
+        SECTION( "Empty evaluates to true" ) {
+            std::array<bool, 0> const data{};
+            REQUIRE_THAT( data, AllTrue() );
+        }
+        SECTION( "One false evalutes to false" ) {
+            std::array<bool, 5> const data{ { true, true, false, true, true } };
+            REQUIRE_THAT( data, !AllTrue() );
+        }
+        SECTION( "All false evaluates to false" ) {
+            std::array<bool, 5> const data{
+                { false, false, false, false, false } };
+            REQUIRE_THAT( data, !AllTrue() );
+        }
+    }
+
+    SECTION( "Contained type is convertible to bool" ) {
+        SECTION( "All true evaluates to true" ) {
+            std::array<ConvertibleToBool, 5> const data{
+                { { true }, { true }, { true }, { true }, { true } } };
+            REQUIRE_THAT( data, AllTrue() );
+        }
+        SECTION( "One false evalutes to false" ) {
+            std::array<ConvertibleToBool, 5> const data{
+                { { true }, { true }, { false }, { true }, { true } } };
+            REQUIRE_THAT( data, !AllTrue() );
+        }
+        SECTION( "All false evaluates to false" ) {
+            std::array<ConvertibleToBool, 5> const data{
+                { { false }, { false }, { false }, { false }, { false } } };
+            REQUIRE_THAT( data, !AllTrue() );
+        }
+    }
+
+    SECTION( "Shortcircuiting" ) {
+        SECTION( "All are read" ) {
+            with_mocked_iterator_access<bool> const mocked{
+                true, true, true, true, true };
+            REQUIRE_THAT( mocked, AllTrue() );
+            REQUIRE( mocked.m_derefed[0] );
+            REQUIRE( mocked.m_derefed[1] );
+            REQUIRE( mocked.m_derefed[2] );
+            REQUIRE( mocked.m_derefed[3] );
+            REQUIRE( mocked.m_derefed[4] );
+        }
+        SECTION( "Short-circuited" ) {
+            with_mocked_iterator_access<bool> const mocked{
+                true, true, false, true, true };
+            REQUIRE_THAT( mocked, !AllTrue() );
+            REQUIRE( mocked.m_derefed[0] );
+            REQUIRE( mocked.m_derefed[1] );
+            REQUIRE( mocked.m_derefed[2] );
+            REQUIRE_FALSE( mocked.m_derefed[3] );
+            REQUIRE_FALSE( mocked.m_derefed[4] );
+        }
+    }
+}
+
+TEST_CASE( "Usage of NoneTrue range matcher", "[matchers][templated][quantifiers]" ) {
+    using Catch::Matchers::NoneTrue;
+
+    SECTION( "Basic usage" ) {
+        SECTION( "All true evaluates to false" ) {
+            std::array<bool, 5> const data{ { true, true, true, true, true } };
+            REQUIRE_THAT( data, !NoneTrue() );
+        }
+        SECTION( "Empty evaluates to true" ) {
+            std::array<bool, 0> const data{};
+            REQUIRE_THAT( data, NoneTrue() );
+        }
+        SECTION( "One true evalutes to false" ) {
+            std::array<bool, 5> const data{
+                { false, false, true, false, false } };
+            REQUIRE_THAT( data, !NoneTrue() );
+        }
+        SECTION( "All false evaluates to true" ) {
+            std::array<bool, 5> const data{
+                { false, false, false, false, false } };
+            REQUIRE_THAT( data, NoneTrue() );
+        }
+    }
+
+    SECTION( "Contained type is convertible to bool" ) {
+        SECTION( "All true evaluates to false" ) {
+            std::array<ConvertibleToBool, 5> const data{
+                { { true }, { true }, { true }, { true }, { true } } };
+            REQUIRE_THAT( data, !NoneTrue() );
+        }
+        SECTION( "One true evalutes to false" ) {
+            std::array<ConvertibleToBool, 5> const data{
+                { { false }, { false }, { true }, { false }, { false } } };
+            REQUIRE_THAT( data, !NoneTrue() );
+        }
+        SECTION( "All false evaluates to true" ) {
+            std::array<ConvertibleToBool, 5> const data{
+                { { false }, { false }, { false }, { false }, { false } } };
+            REQUIRE_THAT( data, NoneTrue() );
+        }
+    }
+
+    SECTION( "Shortcircuiting" ) {
+        SECTION( "All are read" ) {
+            with_mocked_iterator_access<bool> const mocked{
+                false, false, false, false, false };
+            REQUIRE_THAT( mocked, NoneTrue() );
+            REQUIRE( mocked.m_derefed[0] );
+            REQUIRE( mocked.m_derefed[1] );
+            REQUIRE( mocked.m_derefed[2] );
+            REQUIRE( mocked.m_derefed[3] );
+            REQUIRE( mocked.m_derefed[4] );
+        }
+        SECTION( "Short-circuited" ) {
+            with_mocked_iterator_access<bool> const mocked{
+                false, false, true, true, true };
+            REQUIRE_THAT( mocked, !NoneTrue() );
+            REQUIRE( mocked.m_derefed[0] );
+            REQUIRE( mocked.m_derefed[1] );
+            REQUIRE( mocked.m_derefed[2] );
+            REQUIRE_FALSE( mocked.m_derefed[3] );
+            REQUIRE_FALSE( mocked.m_derefed[4] );
+        }
+    }
+}
+
+TEST_CASE( "Usage of AnyTrue range matcher", "[matchers][templated][quantifiers]" ) {
+    using Catch::Matchers::AnyTrue;
+
+    SECTION( "Basic usage" ) {
+        SECTION( "All true evaluates to true" ) {
+            std::array<bool, 5> const data{ { true, true, true, true, true } };
+            REQUIRE_THAT( data, AnyTrue() );
+        }
+        SECTION( "Empty evaluates to false" ) {
+            std::array<bool, 0> const data{};
+            REQUIRE_THAT( data, !AnyTrue() );
+        }
+        SECTION( "One true evalutes to true" ) {
+            std::array<bool, 5> const data{
+                { false, false, true, false, false } };
+            REQUIRE_THAT( data, AnyTrue() );
+        }
+        SECTION( "All false evaluates to false" ) {
+            std::array<bool, 5> const data{
+                { false, false, false, false, false } };
+            REQUIRE_THAT( data, !AnyTrue() );
+        }
+    }
+
+    SECTION( "Contained type is convertible to bool" ) {
+        SECTION( "All true evaluates to true" ) {
+            std::array<ConvertibleToBool, 5> const data{
+                { { true }, { true }, { true }, { true }, { true } } };
+            REQUIRE_THAT( data, AnyTrue() );
+        }
+        SECTION( "One true evalutes to true" ) {
+            std::array<ConvertibleToBool, 5> const data{
+                { { false }, { false }, { true }, { false }, { false } } };
+            REQUIRE_THAT( data, AnyTrue() );
+        }
+        SECTION( "All false evaluates to false" ) {
+            std::array<ConvertibleToBool, 5> const data{
+                { { false }, { false }, { false }, { false }, { false } } };
+            REQUIRE_THAT( data, !AnyTrue() );
+        }
+    }
+
+    SECTION( "Shortcircuiting" ) {
+        SECTION( "All are read" ) {
+            with_mocked_iterator_access<bool> const mocked{
+                false, false, false, false, true };
+            REQUIRE_THAT( mocked, AnyTrue() );
+            REQUIRE( mocked.m_derefed[0] );
+            REQUIRE( mocked.m_derefed[1] );
+            REQUIRE( mocked.m_derefed[2] );
+            REQUIRE( mocked.m_derefed[3] );
+            REQUIRE( mocked.m_derefed[4] );
+        }
+        SECTION( "Short-circuited" ) {
+            with_mocked_iterator_access<bool> const mocked{
+                false, false, true, true, true };
+            REQUIRE_THAT( mocked, AnyTrue() );
+            REQUIRE( mocked.m_derefed[0] );
+            REQUIRE( mocked.m_derefed[1] );
+            REQUIRE( mocked.m_derefed[2] );
+            REQUIRE_FALSE( mocked.m_derefed[3] );
+            REQUIRE_FALSE( mocked.m_derefed[4] );
+        }
+    }
+}
+
+TEST_CASE("All/Any/None True matchers support types with ADL begin",
+          "[approvals][matchers][quantifiers][templated]") {
+    using Catch::Matchers::AllTrue;
+    using Catch::Matchers::NoneTrue;
+    using Catch::Matchers::AnyTrue;
+
+
+    SECTION( "Type requires ADL found begin and end" ) {
+        unrelated::needs_ADL_begin<bool> const needs_adl{
+            true, true, true, true, true };
+        REQUIRE_THAT( needs_adl, AllTrue() );
+    }
+
+    SECTION( "Type requires ADL found begin and end" ) {
+        unrelated::needs_ADL_begin<bool> const needs_adl{
+            false, false, false, false, false };
+        REQUIRE_THAT( needs_adl, NoneTrue() );
+    }
 
-// This is a C++17 extension, and GCC refuses to compile such code
-// unless it is set to C++17 or later
+    SECTION( "Type requires ADL found begin and end" ) {
+        unrelated::needs_ADL_begin<bool> const needs_adl{
+            false, false, true, false, false };
+        REQUIRE_THAT( needs_adl, AnyTrue() );
+    }
+}
+
+// Range loop iterating over range with different types for begin and end is a
+// C++17 feature, and GCC refuses to compile such code unless the lang mode 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::AllTrue;
     using Catch::Matchers::AnyMatch;
+    using Catch::Matchers::AnyTrue;
     using Catch::Matchers::NoneMatch;
+    using Catch::Matchers::NoneTrue;
 
     using Catch::Matchers::Predicate;
 
-    has_different_begin_end_types<int> diff_types{1, 2, 3, 4, 5};
-    REQUIRE_THAT( diff_types, !AllMatch( Predicate<int>( []( int elem ) {
-                      return elem < 3;
-                  } ) ) );
+    SECTION( "AllAnyNoneMatch" ) {
+        has_different_begin_end_types<int> diff_types{ 1, 2, 3, 4, 5 };
+        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, AnyMatch( Predicate<int>( []( int elem ) {
-                      return elem < 2;
-                  } ) ) );
+        REQUIRE_THAT( diff_types, !NoneMatch( Predicate<int>( []( int elem ) {
+                          return elem < 3;
+                      } ) ) );
+    }
+    SECTION( "AllAnyNoneTrue" ) {
+        has_different_begin_end_types<bool> diff_types{ false, false, true, false, false };
 
-    REQUIRE_THAT( diff_types, !NoneMatch( Predicate<int>( []( int elem ) {
-                      return elem < 3;
-                  } ) ) );
+        REQUIRE_THAT( diff_types, !AllTrue() );
+        REQUIRE_THAT( diff_types, AnyTrue() );
+        REQUIRE_THAT( diff_types, !NoneTrue() );
+    }
 }
 
 #endif