Comparison expression creation fix
## Description
Why.
This PR fixes the issue that user-defined operators can be a better match than the ones used to create Catch2 expression (defined in `Decomposer` and `ExprLhs`).

What.
- Overload with forwarding reference is added for all the comparison operators used in expressions.
- This overload doesn't compile for bit field non-const reference, so another overload that takes all arithmetic types by value is added. It replaces `bool` overload where it existed before.
- Operators are now defined as hidden friends to fix compilation on GCC.

## GitHub Issues
Closes #2121

## Note
I'm sorry for not fully reading the contribution guidelines. I just have a problem and propose a solution. Feel free to edit my code.
{"label": "catchorg:devel", "ref": "devel", "sha": "65c9a1d31a338f28ef93cd61c475efc40f6cc42e"}
**Describe the bug**
The test doesn't compile when the user provides a more general `operator ==` overload than `ExprLhs`.
`operator ==` in the code sample below is a better match when r-value reference is passed because it accepts forwarding reference (`U&&`) and `ExprLhs` accepts only const reference (`RhsT const& rhs`) https://github.com/catchorg/Catch2/blob/devel/src/catch2/internal/catch_decomposer.hpp#L187
```
        template<typename RhsT>
        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
            return { compareEqual( m_lhs, rhs ), m_lhs, "=="_sr, rhs };
        }
```

**Expected behavior**
The test should compile.

**Reproduction steps**
```
namespace adl {

struct activate_adl {};

struct equality_expression {
    operator bool() const { return true; }
};

template <class T, class U>
constexpr auto operator == (T&&, U&&) {
    return equality_expression{};
}

}

TEST_CASE("User provided equality operator", "[compilation]") {
    REQUIRE(0 == adl::activate_adl{});
}
```
error: no matching member function for call to 'handleExpr' REQUIRE(0 == adl::activate_adl{});

**Fix**
My first attempt was to change the `operator == ` definition (and similarly all other operators) to
```
        template<typename RhsT>
        auto operator == ( RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
            return { compareEqual( m_lhs, rhs ), m_lhs, "=="_sr, rhs };
        }
```
However, this broke a test for bitfields
error: non-const reference cannot bind to bit-field 'v' REQUIRE(0 == y.v);

This can be resolved by two not so clean overloads, maybe you know a better way:
```
        template<typename RhsT>
        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
            return { compareEqual( m_lhs, rhs ), m_lhs, "=="_sr, rhs };
        }
        template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::decay_t<RhsT>>::value, int> = 0>
        auto operator == ( RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
            return { compareEqual( m_lhs, rhs ), m_lhs, "=="_sr, rhs };
        }
```

**Unrelated note**
I don't think const reference here prolongs the lifetime of rhs, because it's not local but stored in a class: `BinaryExpr<LhsT, RhsT const&>`. Not sure if it's a problem.
Problem with user provided operator == (with proposed fix)
diff --git a/src/catch2/internal/catch_decomposer.hpp b/src/catch2/internal/catch_decomposer.hpp
index 9af5c19f70..a747c34cd6 100644
--- a/src/catch2/internal/catch_decomposer.hpp
+++ b/src/catch2/internal/catch_decomposer.hpp
@@ -183,60 +183,53 @@ namespace Catch {
     public:
         explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
 
-        template<typename RhsT>
-        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareEqual( m_lhs, rhs ), m_lhs, "=="_sr, rhs };
+        template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0>
+        friend auto operator == ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> {
+            return { compareEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "=="_sr, rhs };
         }
-        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs == rhs, m_lhs, "=="_sr, rhs };
+        template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0>
+        friend auto operator == ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> {
+            return { compareEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "=="_sr, rhs };
         }
 
-        template<typename RhsT>
-        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!="_sr, rhs };
+        template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0>
+        friend auto operator != ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> {
+            return { compareNotEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "!="_sr, rhs };
         }
-        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
-            return { m_lhs != rhs, m_lhs, "!="_sr, rhs };
+        template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0>
+        friend auto operator != ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> {
+            return { compareNotEqual( lhs.m_lhs, rhs ), lhs.m_lhs, "!="_sr, rhs };
         }
 
-        template<typename RhsT>
-        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">"_sr, rhs };
-        }
-        template<typename RhsT>
-        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<"_sr, rhs };
-        }
-        template<typename RhsT>
-        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">="_sr, rhs };
-        }
-        template<typename RhsT>
-        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<="_sr, rhs };
-        }
-        template <typename RhsT>
-        auto operator | (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs | rhs), m_lhs, "|"_sr, rhs };
-        }
-        template <typename RhsT>
-        auto operator & (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs & rhs), m_lhs, "&"_sr, rhs };
-        }
-        template <typename RhsT>
-        auto operator ^ (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
-            return { static_cast<bool>(m_lhs ^ rhs), m_lhs, "^"_sr, rhs };
+    #define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(op) \
+        template<typename RhsT, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<RhsT>>::value, int> = 0> \
+        friend auto operator op ( ExprLhs && lhs, RhsT && rhs ) -> BinaryExpr<LhsT, RhsT const&> { \
+            return { static_cast<bool>(lhs.m_lhs op rhs), lhs.m_lhs, #op##_sr, rhs }; \
+        } \
+        template<typename RhsT, std::enable_if_t<std::is_arithmetic<RhsT>::value, int> = 0> \
+        friend auto operator op ( ExprLhs && lhs, RhsT rhs ) -> BinaryExpr<LhsT, RhsT> { \
+            return { static_cast<bool>(lhs.m_lhs op rhs), lhs.m_lhs, #op##_sr, rhs }; \
         }
 
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(<)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(>)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(<=)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(>=)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&)
+        CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^)
+
+    #undef CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR
+
         template<typename RhsT>
-        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+        friend auto operator && ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
             static_assert(always_false<RhsT>::value,
             "operator&& is not supported inside assertions, "
             "wrap the expression inside parentheses, or decompose it");
         }
 
         template<typename RhsT>
-        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+        friend auto operator || ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
             static_assert(always_false<RhsT>::value,
             "operator|| is not supported inside assertions, "
             "wrap the expression inside parentheses, or decompose it");
@@ -247,21 +240,15 @@ namespace Catch {
         }
     };
 
-    void handleExpression( ITransientExpression const& expr );
-
-    template<typename T>
-    void handleExpression( ExprLhs<T> const& expr ) {
-        handleExpression( expr.makeUnaryExpr() );
-    }
-
     struct Decomposer {
-        template<typename T>
-        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
-            return ExprLhs<T const&>{ lhs };
+        template<typename T, std::enable_if_t<!std::is_arithmetic<std::remove_reference_t<T>>::value, int> = 0>
+        friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
+            return ExprLhs<const T&>{ lhs };
         }
 
-        auto operator <=( bool value ) -> ExprLhs<bool> {
-            return ExprLhs<bool>{ value };
+        template<typename T, std::enable_if_t<std::is_arithmetic<T>::value, int> = 0>
+        friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs<T> {
+            return ExprLhs<T>{ value };
         }
     };
 

diff --git a/tests/SelfTest/UsageTests/Compilation.tests.cpp b/tests/SelfTest/UsageTests/Compilation.tests.cpp
index 5f8c82a38a..cce190f2cb 100644
--- a/tests/SelfTest/UsageTests/Compilation.tests.cpp
+++ b/tests/SelfTest/UsageTests/Compilation.tests.cpp
@@ -277,3 +277,42 @@ namespace {
 TEST_CASE("Immovable types are supported in basic assertions", "[compilation][.approvals]") {
     REQUIRE(ImmovableType{} == ImmovableType{});
 }
+
+namespace adl {
+
+struct always_true {
+    explicit operator bool() const { return true; }
+};
+
+#define COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(op) \
+template <class T, class U> \
+auto operator op (T&&, U&&) { \
+    return always_true{}; \
+}
+
+COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(==)
+COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(!=)
+COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(<)
+COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(>)
+COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(<=)
+COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(>=)
+COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(|)
+COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(&)
+COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR(^)
+
+#undef COMPILATION_TEST_DEFINE_UNIVERSAL_OPERATOR
+
+}
+
+TEST_CASE("ADL universal operators don't hijack expression deconstruction", "[compilation][.approvals]") {
+    REQUIRE(adl::always_true{});
+    REQUIRE(0 == adl::always_true{});
+    REQUIRE(0 != adl::always_true{});
+    REQUIRE(0 < adl::always_true{});
+    REQUIRE(0 > adl::always_true{});
+    REQUIRE(0 <= adl::always_true{});
+    REQUIRE(0 >= adl::always_true{});
+    REQUIRE(0 | adl::always_true{});
+    REQUIRE(0 & adl::always_true{});
+    REQUIRE(0 ^ adl::always_true{});
+}

{"randomtestordering": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::reporters::output": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "libidentitytest": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "unmatchedoutputfilter": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "checkconvenienceheaders": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tags::output": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tests::xmloutput": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tags::exitcode": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filenameastagsmatching": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "notest": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tests::output": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "approvaltests": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "escapespecialcharactersintestnames": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "testsinfile::invalidtestnames-2": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "noassertions": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "negativespecnohiddentests": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filteredsection::generatorsdontcauseinfiniteloop-2": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "versioncheck": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tests::exitcode": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "warnaboutnotests": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tests::quiet": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "runtests": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "testsinfile::simplespecs": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "regressioncheck-1670": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "testsinfile::escapespecialcharacters": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tags::xmloutput": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filteredsection-2": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::reporters::exitcode": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filenameastagstest": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "testsinfile::invalidtestnames-1": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filteredsection-1": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "tagalias": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::reporters::xmloutput": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filteredsection::generatorsdontcauseinfiniteloop-1": {"run": "PASS", "test": "NONE", "fix": "PASS"}}
{"have_flag_-wmisleading-indentation": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wdeprecated": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wunreachable-code": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wshadow": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wextra": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wunused-function": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wmissing-noreturn": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wmissing-braces": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wpedantic": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wparentheses": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wall": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wold-style-cast": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wvla": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wundef": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wunused-parameter": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wmissing-declarations": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wstrict-aliasing": {"run": "PASS", "test": "PASS", "fix": "PASS"}, "have_flag_-wsuggest-override": {"run": "PASS", "test": "PASS", "fix": "PASS"}}
{"randomtestordering": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::reporters::output": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "libidentitytest": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "unmatchedoutputfilter": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "checkconvenienceheaders": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tags::output": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tests::xmloutput": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tags::exitcode": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filenameastagsmatching": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "notest": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tests::output": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "approvaltests": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "escapespecialcharactersintestnames": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "testsinfile::invalidtestnames-2": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "noassertions": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "negativespecnohiddentests": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filteredsection::generatorsdontcauseinfiniteloop-2": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "versioncheck": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tests::exitcode": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "warnaboutnotests": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tests::quiet": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "runtests": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "testsinfile::simplespecs": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "regressioncheck-1670": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "testsinfile::escapespecialcharacters": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::tags::xmloutput": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filteredsection-2": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::reporters::exitcode": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filenameastagstest": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "testsinfile::invalidtestnames-1": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filteredsection-1": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "tagalias": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "list::reporters::xmloutput": {"run": "PASS", "test": "NONE", "fix": "PASS"}, "filteredsection::generatorsdontcauseinfiniteloop-1": {"run": "PASS", "test": "NONE", "fix": "PASS"}}
{"passed_count": 52, "failed_count": 9, "skipped_count": 0, "passed_tests": ["randomtestordering", "list::reporters::output", "libidentitytest", "unmatchedoutputfilter", "checkconvenienceheaders", "have_flag_-wmisleading-indentation", "list::tags::output", "list::tests::xmloutput", "list::tags::exitcode", "list::reporters::xmloutput", "filenameastagsmatching", "notest", "have_flag_-wdeprecated", "list::tests::output", "approvaltests", "escapespecialcharactersintestnames", "testsinfile::invalidtestnames-2", "have_flag_-wunreachable-code", "noassertions", "negativespecnohiddentests", "have_flag_-wshadow", "filteredsection::generatorsdontcauseinfiniteloop-2", "versioncheck", "have_flag_-wextra", "list::tests::exitcode", "warnaboutnotests", "have_flag_-wmissing-noreturn", "list::tests::quiet", "have_flag_-wmissing-braces", "runtests", "have_flag_-wpedantic", "testsinfile::simplespecs", "regressioncheck-1670", "have_flag_-wparentheses", "have_flag_-wall", "testsinfile::escapespecialcharacters", "have_flag_-wold-style-cast", "list::tags::xmloutput", "filteredsection-2", "list::reporters::exitcode", "filenameastagstest", "testsinfile::invalidtestnames-1", "have_flag_-wvla", "have_flag_-wundef", "have_flag_-wunused-parameter", "filteredsection-1", "have_flag_-wmissing-declarations", "tagalias", "have_flag_-wunused-function", "have_flag_-wstrict-aliasing", "have_flag_-wsuggest-override", "filteredsection::generatorsdontcauseinfiniteloop-1"], "failed_tests": ["have_flag_-wglobal-constructors", "have_flag_-wreturn-std-move", "have_flag_-wcall-to-pure-virtual-from-ctor-dtor", "have_flag_-wweak-vtables", "have_flag_-wdeprecated-register", "have_flag_-wexit-time-destructors", "have_flag_-wabsolute-value", "have_flag_-wextra-semi-stmt", "have_flag_-wcatch-value"], "skipped_tests": []}
{"passed_count": 18, "failed_count": 9, "skipped_count": 0, "passed_tests": ["have_flag_-wold-style-cast", "have_flag_-wextra", "have_flag_-wshadow", "have_flag_-wvla", "have_flag_-wunused-function", "have_flag_-wmissing-noreturn", "have_flag_-wdeprecated", "have_flag_-wunreachable-code", "have_flag_-wmisleading-indentation", "have_flag_-wmissing-braces", "have_flag_-wundef", "have_flag_-wpedantic", "have_flag_-wunused-parameter", "have_flag_-wmissing-declarations", "have_flag_-wparentheses", "have_flag_-wall", "have_flag_-wstrict-aliasing", "have_flag_-wsuggest-override"], "failed_tests": ["have_flag_-wglobal-constructors", "have_flag_-wreturn-std-move", "have_flag_-wcall-to-pure-virtual-from-ctor-dtor", "have_flag_-wweak-vtables", "have_flag_-wdeprecated-register", "have_flag_-wexit-time-destructors", "have_flag_-wabsolute-value", "have_flag_-wextra-semi-stmt", "have_flag_-wcatch-value"], "skipped_tests": []}
{"passed_count": 52, "failed_count": 9, "skipped_count": 0, "passed_tests": ["randomtestordering", "list::reporters::output", "libidentitytest", "unmatchedoutputfilter", "checkconvenienceheaders", "have_flag_-wmisleading-indentation", "list::tags::output", "list::tests::xmloutput", "list::tags::exitcode", "list::reporters::xmloutput", "filenameastagsmatching", "notest", "have_flag_-wdeprecated", "list::tests::output", "approvaltests", "escapespecialcharactersintestnames", "testsinfile::invalidtestnames-2", "have_flag_-wunreachable-code", "noassertions", "negativespecnohiddentests", "have_flag_-wshadow", "filteredsection::generatorsdontcauseinfiniteloop-2", "versioncheck", "have_flag_-wextra", "list::tests::exitcode", "warnaboutnotests", "have_flag_-wmissing-noreturn", "list::tests::quiet", "have_flag_-wmissing-braces", "runtests", "have_flag_-wpedantic", "testsinfile::simplespecs", "regressioncheck-1670", "have_flag_-wparentheses", "have_flag_-wall", "testsinfile::escapespecialcharacters", "have_flag_-wold-style-cast", "list::tags::xmloutput", "filteredsection-2", "list::reporters::exitcode", "filenameastagstest", "testsinfile::invalidtestnames-1", "have_flag_-wvla", "have_flag_-wundef", "have_flag_-wunused-parameter", "filteredsection-1", "have_flag_-wmissing-declarations", "tagalias", "have_flag_-wunused-function", "have_flag_-wstrict-aliasing", "have_flag_-wsuggest-override", "filteredsection::generatorsdontcauseinfiniteloop-1"], "failed_tests": ["have_flag_-wglobal-constructors", "have_flag_-wreturn-std-move", "have_flag_-wcall-to-pure-virtual-from-ctor-dtor", "have_flag_-wweak-vtables", "have_flag_-wdeprecated-register", "have_flag_-wexit-time-destructors", "have_flag_-wabsolute-value", "have_flag_-wextra-semi-stmt", "have_flag_-wcatch-value"], "skipped_tests": []}