Remove the ill-conceived compilation perf tests using real tests

tests/SelfTest/UsageTests/Approx.tests.cpp

@@ -13,13 +13,9 @@
 
 using Catch::Approx;
 
-namespace { namespace ApproxTests {
-
-#ifndef APPROX_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
-#define APPROX_TEST_HELPERS_INCLUDED
-
-    inline double divide( double a, double b ) {
-        return a/b;
+namespace {
+    static double divide(double a, double b) {
+        return a / b;
     }
 
     class StrongDoubleTypedef {
@@ -30,11 +26,10 @@ namespace { namespace ApproxTests {
         explicit operator double() const { return d_; }
     };
 
-    inline std::ostream& operator<<( std::ostream& os, StrongDoubleTypedef td ) {
+    static std::ostream& operator<<(std::ostream& os, StrongDoubleTypedef td) {
         return os << "StrongDoubleTypedef(" << static_cast<double>(td) << ")";
     }
-
-#endif
+} // end unnamed namespace
 
 using namespace Catch::literals;
 
@@ -214,5 +209,3 @@ TEST_CASE( "Comparison with explicitly convertible types", "[Approx]" )
   REQUIRE(Approx(11.0) >= td);
 
 }
-
-}} // namespace ApproxTests

tests/SelfTest/UsageTests/BDD.tests.cpp

@@ -5,103 +5,99 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-namespace { namespace BDDTests {
+namespace {
 
-#ifndef BDD_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
-#define BDD_TEST_HELPERS_INCLUDED
+    static bool itDoesThis() { return true; }
 
-    inline bool itDoesThis() { return true; }
+    static bool itDoesThat() { return true; }
 
-    inline bool itDoesThat() { return true; }
+    // a trivial fixture example to support SCENARIO_METHOD tests
+    struct Fixture {
+        Fixture(): d_counter( 0 ) {}
 
-    namespace {
+        int counter() { return d_counter++; }
 
-// a trivial fixture example to support SCENARIO_METHOD tests
-        struct Fixture {
-            Fixture()
-                    : d_counter(0) {
-            }
+        int d_counter;
+    };
 
-            int counter() {
-                return d_counter++;
-            }
+}
 
-            int d_counter;
-        };
 
-    }
-#endif
-
-    SCENARIO("Do that thing with the thing", "[Tags]") {
-        GIVEN("This stuff exists") {
-            // make stuff exist
-            AND_GIVEN("And some assumption") {
-                // Validate assumption
-                WHEN("I do this") {
-                    // do this
-                    THEN("it should do this") {
-                        REQUIRE(itDoesThis());
-                        AND_THEN("do that")REQUIRE(itDoesThat());
+SCENARIO("Do that thing with the thing", "[Tags]") {
+    GIVEN("This stuff exists") {
+        // make stuff exist
+        AND_GIVEN("And some assumption") {
+            // Validate assumption
+            WHEN("I do this") {
+                // do this
+                THEN("it should do this") {
+                    REQUIRE(itDoesThis());
+                    AND_THEN("do that") {
+                        REQUIRE(itDoesThat());
                     }
                 }
             }
         }
     }
+}
 
-    SCENARIO("Vector resizing affects size and capacity", "[vector][bdd][size][capacity]") {
-        GIVEN("an empty vector") {
-            std::vector<int> v;
-            REQUIRE(v.size() == 0);
+SCENARIO( "Vector resizing affects size and capacity",
+          "[vector][bdd][size][capacity]" ) {
+    GIVEN( "an empty vector" ) {
+        std::vector<int> v;
+        REQUIRE( v.size() == 0 );
 
-            WHEN("it is made larger") {
-                v.resize(10);
-                THEN("the size and capacity go up") {
-                    REQUIRE(v.size() == 10);
-                    REQUIRE(v.capacity() >= 10);
+        WHEN( "it is made larger" ) {
+            v.resize( 10 );
+            THEN( "the size and capacity go up" ) {
+                REQUIRE( v.size() == 10 );
+                REQUIRE( v.capacity() >= 10 );
 
-                    AND_WHEN("it is made smaller again") {
-                        v.resize(5);
-                        THEN("the size goes down but the capacity stays the same") {
-                            REQUIRE(v.size() == 5);
-                            REQUIRE(v.capacity() >= 10);
-                        }
+                AND_WHEN( "it is made smaller again" ) {
+                    v.resize( 5 );
+                    THEN(
+                        "the size goes down but the capacity stays the same" ) {
+                        REQUIRE( v.size() == 5 );
+                        REQUIRE( v.capacity() >= 10 );
                     }
                 }
             }
+        }
 
-            WHEN("we reserve more space") {
-                v.reserve(10);
-                THEN("The capacity is increased but the size remains the same") {
-                    REQUIRE(v.capacity() >= 10);
-                    REQUIRE(v.size() == 0);
-                }
+        WHEN( "we reserve more space" ) {
+            v.reserve( 10 );
+            THEN( "The capacity is increased but the size remains the same" ) {
+                REQUIRE( v.capacity() >= 10 );
+                REQUIRE( v.size() == 0 );
             }
         }
     }
+}
 
-    SCENARIO("This is a really long scenario name to see how the list command deals with wrapping",
-             "[very long tags][lots][long][tags][verbose]"
-                     "[one very long tag name that should cause line wrapping writing out using the list command]"
-                     "[anotherReallyLongTagNameButThisOneHasNoObviousWrapPointsSoShouldSplitWithinAWordUsingADashCharacter]") {
-        GIVEN("A section name that is so long that it cannot fit in a single console width")WHEN(
-                    "The test headers are printed as part of the normal running of the scenario")THEN(
-                        "The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent")SUCCEED(
-                            "boo!");
-    }
-
-    SCENARIO_METHOD(Fixture,
-                    "BDD tests requiring Fixtures to provide commonly-accessed data or methods",
-                    "[bdd][fixtures]") {
-        const int before(counter());
-        GIVEN("No operations precede me") {
-            REQUIRE(before == 0);
-            WHEN("We get the count") {
-                const int after(counter());
-                THEN("Subsequently values are higher") {
-                    REQUIRE(after > before);
-                }
+SCENARIO("This is a really long scenario name to see how the list command deals with wrapping",
+         "[very long tags][lots][long][tags][verbose]"
+                 "[one very long tag name that should cause line wrapping writing out using the list command]"
+                 "[anotherReallyLongTagNameButThisOneHasNoObviousWrapPointsSoShouldSplitWithinAWordUsingADashCharacter]") {
+    GIVEN("A section name that is so long that it cannot fit in a single console width") {
+        WHEN("The test headers are printed as part of the normal running of the scenario") {
+            THEN("The, deliberately very long and overly verbose (you see what I did there?) section names must wrap, along with an indent") {
+                SUCCEED("boo!");
             }
         }
     }
+}
 
-}} // namespace BDDtests
+SCENARIO_METHOD(Fixture,
+                "BDD tests requiring Fixtures to provide commonly-accessed data or methods",
+                "[bdd][fixtures]") {
+    const int before(counter());
+    GIVEN("No operations precede me") {
+        REQUIRE(before == 0);
+        WHEN("We get the count") {
+            const int after(counter());
+            THEN("Subsequently values are higher") {
+                REQUIRE(after > before);
+            }
+        }
+    }
+}

tests/SelfTest/UsageTests/Class.tests.cpp

@@ -7,68 +7,47 @@
 #include <catch2/catch_template_test_macros.hpp>
 #include <array>
 
-namespace{ namespace ClassTests {
+namespace {
 
-#ifndef CLASS_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
-#define CLASS_TEST_HELPERS_INCLUDED
+    class TestClass {
+        std::string s;
 
-class TestClass
-{
-    std::string s;
+    public:
+        TestClass(): s( "hello" ) {}
 
-public:
-    TestClass()
-    : s( "hello" )
-    {}
+        void succeedingCase() { REQUIRE( s == "hello" ); }
+        void failingCase() { REQUIRE( s == "world" ); }
+    };
 
-    void succeedingCase()
-    {
-        REQUIRE( s == "hello" );
-    }
-    void failingCase()
-    {
-        REQUIRE( s == "world" );
-    }
-};
+    struct Fixture {
+        Fixture(): m_a( 1 ) {}
 
-struct Fixture
-{
-    Fixture() : m_a( 1 ) {}
+        int m_a;
+    };
 
-    int m_a;
-};
+    template <typename T> struct Template_Fixture {
+        Template_Fixture(): m_a( 1 ) {}
 
-template< typename T >
-struct Template_Fixture {
-    Template_Fixture(): m_a(1) {}
+        T m_a;
+    };
 
-    T m_a;
-};
+    template <typename T> struct Template_Fixture_2 {
+        Template_Fixture_2() {}
 
-template<typename T>
-struct Template_Fixture_2 {
-    Template_Fixture_2() {}
+        T m_a;
+    };
 
-    T m_a;
-};
+    template <typename T> struct Template_Foo {
+        size_t size() { return 0; }
+    };
 
-template< typename T>
-struct Template_Foo {
-    size_t size() { return 0; }
-};
-
-template< typename T, size_t V>
-struct Template_Foo_2 {
-    size_t size() { return V; }
-};
-
-template <int V>
-struct Nttp_Fixture{
-    int value = V;
-};
-#endif
+    template <typename T, size_t V> struct Template_Foo_2 {
+        size_t size() { return V; }
+    };
 
+    template <int V> struct Nttp_Fixture { int value = V; };
 
+} // end unnamed namespace
 
 METHOD_AS_TEST_CASE( TestClass::succeedingCase, "A METHOD_AS_TEST_CASE based test run that succeeds", "[class]" )
 METHOD_AS_TEST_CASE( TestClass::failingCase, "A METHOD_AS_TEST_CASE based test run that fails", "[.][class][failing]" )
@@ -129,7 +108,3 @@ namespace Inner
         REQUIRE(Template_Fixture_2<TestType>{}.m_a.size() < 2);
     }
 }
-
-
-
-}} // namespace ClassTests

tests/SelfTest/UsageTests/Compilation.tests.cpp

@@ -33,60 +33,44 @@ std::ostream& operator<<(std::ostream& out, foo::helper_1403 const&) {
 
 #include <cstring>
 
-namespace { namespace CompilationTests {
-
-#ifndef COMPILATION_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
-#define COMPILATION_TEST_HELPERS_INCLUDED
-
-    // Comparison operators can return non-booleans.
-    // This is unusual, but should be supported.
-    struct logic_t {
-        logic_t operator< (logic_t) const { return {}; }
-        logic_t operator<=(logic_t) const { return {}; }
-        logic_t operator> (logic_t) const { return {}; }
-        logic_t operator>=(logic_t) const { return {}; }
-        logic_t operator==(logic_t) const { return {}; }
-        logic_t operator!=(logic_t) const { return {}; }
-        explicit operator bool() const { return true; }
-    };
+// Comparison operators can return non-booleans.
+// This is unusual, but should be supported.
+struct logic_t {
+    logic_t operator< (logic_t) const { return {}; }
+    logic_t operator<=(logic_t) const { return {}; }
+    logic_t operator> (logic_t) const { return {}; }
+    logic_t operator>=(logic_t) const { return {}; }
+    logic_t operator==(logic_t) const { return {}; }
+    logic_t operator!=(logic_t) const { return {}; }
+    explicit operator bool() const { return true; }
+};
 
 
-// This is a minimal example for an issue we have found in 1.7.0
-    struct foo {
-        int i;
-    };
-
-    template<typename T>
-    bool operator==(const T &val, foo f) {
-        return val == f.i;
+void throws_int(bool b) {
+    if (b) {
+        throw 1;
     }
+}
 
-    void throws_int(bool b) {
-        if (b) {
-            throw 1;
-        }
-    }
+template<typename T>
+bool templated_tests(T t) {
+    int a = 3;
+    REQUIRE(a == t);
+    CHECK(a == t);
+    REQUIRE_THROWS(throws_int(true));
+    CHECK_THROWS_AS(throws_int(true), int);
+    REQUIRE_NOTHROW(throws_int(false));
+    REQUIRE_THAT("aaa", Catch::Matchers::EndsWith("aaa"));
+    return true;
+}
 
-    template<typename T>
-    bool templated_tests(T t) {
-        int a = 3;
-        REQUIRE(a == t);
-        CHECK(a == t);
-        REQUIRE_THROWS(throws_int(true));
-        CHECK_THROWS_AS(throws_int(true), int);
-        REQUIRE_NOTHROW(throws_int(false));
-        REQUIRE_THAT("aaa", Catch::Matchers::EndsWith("aaa"));
-        return true;
-    }
+struct A {};
 
-    struct A {
-    };
+std::ostream &operator<<(std::ostream &o, const A &) { return o << 0; }
 
-    std::ostream &operator<<(std::ostream &o, const A &) { return o << 0; }
-
-    struct B : private A {
-        bool operator==(int) const { return true; }
-    };
+struct B : private A {
+    bool operator==(int) const { return true; }
+};
 
 #ifdef __clang__
 #pragma clang diagnostic push
@@ -98,24 +82,32 @@ namespace { namespace CompilationTests {
 #pragma GCC diagnostic ignored "-Wunused-function"
 #endif
 
-    B f();
+B f();
 
-    std::ostream g();
+std::ostream g();
 
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
 
-    template <typename, typename>
-    struct Fixture_1245 {};
+template <typename, typename>
+struct Fixture_1245 {};
 
-#endif
+// This is a minimal example for an issue we have found in 1.7.0
+struct dummy_809 {
+    int i;
+};
 
-    TEST_CASE("#809") {
-        foo f;
-        f.i = 42;
-        REQUIRE(42 == f);
-    }
+template<typename T>
+bool operator==(const T& val, dummy_809 f) {
+    return val == f.i;
+}
+
+TEST_CASE("#809") {
+    dummy_809 f;
+    f.i = 42;
+    REQUIRE(42 == f);
+}
 
 
 // ------------------------------------------------------------------
@@ -129,65 +121,63 @@ namespace { namespace CompilationTests {
 
 
 // Test containing example where original stream insertable check breaks compilation
+TEST_CASE("#872") {
+    A dummy;
+    CAPTURE(dummy);
+    B x;
+    REQUIRE (x == 4);
+}
 
+TEST_CASE("#1027: Bitfields can be captured") {
+    struct Y {
+        uint32_t v : 1;
+    };
+    Y y{ 0 };
+    REQUIRE(y.v == 0);
+    REQUIRE(0 == y.v);
+}
 
-    TEST_CASE("#872") {
-        A dummy;
-        CAPTURE(dummy);
-        B x;
-        REQUIRE (x == 4);
-    }
+// Comparison operators can return non-booleans.
+// This is unusual, but should be supported.
+TEST_CASE("#1147") {
+    logic_t t1, t2;
+    REQUIRE(t1 == t2);
+    REQUIRE(t1 != t2);
+    REQUIRE(t1 <  t2);
+    REQUIRE(t1 >  t2);
+    REQUIRE(t1 <= t2);
+    REQUIRE(t1 >= t2);
+}
 
-    TEST_CASE("#1027: Bitfields can be captured") {
-        struct Y {
-            uint32_t v : 1;
-        };
-        Y y{ 0 };
-        REQUIRE(y.v == 0);
-        REQUIRE(0 == y.v);
-    }
+// unsigned array
+TEST_CASE("#1238") {
+    unsigned char uarr[] = "123";
+    CAPTURE(uarr);
+    signed char sarr[] = "456";
+    CAPTURE(sarr);
 
-    // Comparison operators can return non-booleans.
-    // This is unusual, but should be supported.
-    TEST_CASE("#1147") {
-        logic_t t1, t2;
-        REQUIRE(t1 == t2);
-        REQUIRE(t1 != t2);
-        REQUIRE(t1 <  t2);
-        REQUIRE(t1 >  t2);
-        REQUIRE(t1 <= t2);
-        REQUIRE(t1 >= t2);
-    }
+    REQUIRE(std::memcmp(uarr, "123", sizeof(uarr)) == 0);
+    REQUIRE(std::memcmp(sarr, "456", sizeof(sarr)) == 0);
+}
 
-    // unsigned array
-    TEST_CASE("#1238") {
-        unsigned char uarr[] = "123";
-        CAPTURE(uarr);
-        signed char sarr[] = "456";
-        CAPTURE(sarr);
+TEST_CASE_METHOD((Fixture_1245<int, int>), "#1245", "[compilation]") {
+    SUCCEED();
+}
 
-        REQUIRE(std::memcmp(uarr, "123", sizeof(uarr)) == 0);
-        REQUIRE(std::memcmp(sarr, "456", sizeof(sarr)) == 0);
-    }
+TEST_CASE("#1403", "[compilation]") {
+    ::foo::helper_1403 h1, h2;
+    REQUIRE(h1 == h2);
+}
 
-    TEST_CASE_METHOD((Fixture_1245<int, int>), "#1245", "[compilation]") {
-        SUCCEED();
-    }
+TEST_CASE("Optionally static assertions", "[compilation]") {
+    STATIC_REQUIRE( std::is_void<void>::value );
+    STATIC_REQUIRE_FALSE( std::is_void<int>::value );
+}
 
-    TEST_CASE("#1403", "[compilation]") {
-        ::foo::helper_1403 h1, h2;
-        REQUIRE(h1 == h2);
-    }
-
-    TEST_CASE("Optionally static assertions", "[compilation]") {
-        STATIC_REQUIRE( std::is_void<void>::value );
-        STATIC_REQUIRE_FALSE( std::is_void<int>::value );
-    }
-
-    TEST_CASE("#1548", "[compilation]") {
-        using namespace bar;
-        REQUIRE(std::is_same<TypeList<int>, TypeList<int>>::value);
-    }
+TEST_CASE("#1548", "[compilation]") {
+    using namespace bar;
+    REQUIRE(std::is_same<TypeList<int>, TypeList<int>>::value);
+}
 
     // #925
     using signal_t = void (*) (void*);
@@ -214,17 +204,16 @@ namespace { namespace CompilationTests {
 #pragma warning(pop)
 #endif
 
-    TEST_CASE("#1319: Sections can have description (even if it is not saved", "[compilation]") {
-        SECTION("SectionName", "This is a long form section description") {
-            SUCCEED();
-        }
+TEST_CASE( "#1319: Sections can have description (even if it is not saved",
+               "[compilation]" ) {
+    SECTION( "SectionName", "This is a long form section description" ) {
+        SUCCEED();
     }
+}
 
-    TEST_CASE("Lambdas in assertions") {
-        REQUIRE([]() { return true; }());
-    }
-
-}} // namespace CompilationTests
+TEST_CASE("Lambdas in assertions") {
+    REQUIRE([]() { return true; }());
+}
 
 namespace {
     struct HasBitOperators {

tests/SelfTest/UsageTests/Condition.tests.cpp

@@ -20,31 +20,28 @@ using Catch::Approx;
 #include <limits>
 #include <cstdint>
 
-namespace { namespace ConditionTests {
+namespace {
 
-#ifndef CONDITION_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
-#define CONDITION_TEST_HELPERS_INCLUDED
+    struct TestData {
+        int int_seven = 7;
+        std::string str_hello = "hello";
+        float float_nine_point_one = 9.1f;
+        double double_pi = 3.1415926535;
+    };
 
-struct TestData {
-    int int_seven = 7;
-    std::string str_hello = "hello";
-    float float_nine_point_one = 9.1f;
-    double double_pi = 3.1415926535;
-};
+    struct TestDef {
+        TestDef& operator + (const std::string&) {
+            return *this;
+        }
+        TestDef& operator[](const std::string&) {
+            return *this;
+        }
+    };
 
-struct TestDef {
-    TestDef& operator + ( const std::string& ) {
-        return *this;
-    }
-    TestDef& operator[]( const std::string& ) {
-        return *this;
-    }
-};
+    static const char* returnsConstNull() { return nullptr; }
+    static char* returnsNull() { return nullptr; }
 
-inline const char* returnsConstNull(){ return nullptr; }
-inline char* returnsNull(){ return nullptr; }
-
-#endif
+} // end unnamed namespace
 
 // The "failing" tests all use the CHECK macro, which continues if the specific test fails.
 // This allows us to see all results, even if an earlier check fails
@@ -330,5 +327,3 @@ TEST_CASE( "'Not' checks that should fail", "[.][failing]" )
     CHECK( !(1 == 1) );
     CHECK_FALSE( 1 == 1 );
 }
-
-}} // namespace ConditionTests

tests/SelfTest/UsageTests/Exception.tests.cpp

@@ -20,55 +20,50 @@
 #pragma clang diagnostic ignored "-Wunreachable-code"
 #endif
 
-namespace { namespace ExceptionTests {
+namespace {
 
-#ifndef EXCEPTION_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
-#define EXCEPTION_TEST_HELPERS_INCLUDED
-
-int thisThrows() {
-    throw std::domain_error( "expected exception" );
-    return 1;
-}
-
-int thisDoesntThrow() {
-    return 0;
-}
-
-class CustomException {
-public:
-    explicit CustomException( const std::string& msg )
-    : m_msg( msg )
-    {}
-
-    std::string getMessage() const {
-        return m_msg;
+    int thisThrows() {
+        throw std::domain_error("expected exception");
+        return 1;
     }
 
-private:
-    std::string m_msg;
-};
-
-class CustomStdException : public std::exception {
-public:
-    explicit CustomStdException( const std::string& msg )
-    : m_msg( msg )
-    {}
-    ~CustomStdException() noexcept override {}
-
-    std::string getMessage() const {
-        return m_msg;
+    int thisDoesntThrow() {
+        return 0;
     }
 
-private:
-    std::string m_msg;
-};
+    class CustomException {
+    public:
+        explicit CustomException(const std::string& msg)
+            : m_msg(msg) {}
+
+        std::string getMessage() const {
+            return m_msg;
+        }
+
+    private:
+        std::string m_msg;
+    };
+
+    class CustomStdException : public std::exception {
+    public:
+        explicit CustomStdException(const std::string& msg)
+            : m_msg(msg) {}
+        ~CustomStdException() noexcept override {}
+
+        std::string getMessage() const {
+            return m_msg;
+        }
+
+    private:
+        std::string m_msg;
+    };
+
+    [[noreturn]] void throwCustom() {
+        throw CustomException("custom exception - not std");
+    }
 
-[[noreturn]] void throwCustom() {
-    throw CustomException( "custom exception - not std" );
 }
 
-#endif
-
 TEST_CASE( "When checked exceptions are thrown they can be expected or unexpected", "[!throws]" ) {
     REQUIRE_THROWS_AS( thisThrows(), std::domain_error );
     REQUIRE_NOTHROW( thisDoesntThrow() );
@@ -198,8 +193,6 @@ TEST_CASE( "#748 - captures with unexpected exceptions", "[.][failing][!throws][
     }
 }
 
-}} // namespace ExceptionTests
-
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif

tests/SelfTest/UsageTests/Misc.tests.cpp

@@ -19,60 +19,58 @@
 #include <array>
 #include <tuple>
 
-namespace { namespace MiscTests {
+namespace {
 
-#ifndef MISC_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU
-#define MISC_TEST_HELPERS_INCLUDED
-
-inline const char* makeString( bool makeNull ) {
-    return makeNull ? nullptr : "valid string";
-}
-inline bool testCheckedIf( bool flag )  {
-    CHECKED_IF( flag )
-        return true;
-    else
-        return false;
-}
-inline bool testCheckedElse( bool flag ) {
-    CHECKED_ELSE( flag )
-        return false;
-
-    return true;
-}
-
-inline unsigned int Factorial( unsigned int number )  {
-    return number > 1 ? Factorial(number-1)*number : 1;
-}
-
-static int f() {
-    return 1;
-}
-
-inline void manuallyRegisteredTestFunction() {
-    SUCCEED( "was called" );
-}
-
-struct AutoTestReg {
-    AutoTestReg() {
-        REGISTER_TEST_CASE( manuallyRegisteredTestFunction, "ManuallyRegistered" );
+    static const char* makeString(bool makeNull) {
+        return makeNull ? nullptr : "valid string";
     }
-};
+    static bool testCheckedIf(bool flag) {
+        CHECKED_IF(flag)
+            return true;
+    else
+    return false;
+    }
+    static bool testCheckedElse(bool flag) {
+        CHECKED_ELSE(flag)
+            return false;
 
-CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
-CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-static AutoTestReg autoTestReg;
-CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+        return true;
+    }
 
-template<typename T>
-struct Foo {
-    size_t size() { return 0; }
-};
+    static unsigned int Factorial(unsigned int number) {
+        return number > 1 ? Factorial(number - 1) * number : 1;
+    }
 
-template<typename T, size_t S>
-struct Bar {
-    size_t size() { return S; }
-};
-#endif
+    static int f() {
+        return 1;
+    }
+
+    static void manuallyRegisteredTestFunction() {
+        SUCCEED("was called");
+    }
+
+    struct AutoTestReg {
+        AutoTestReg() {
+            REGISTER_TEST_CASE(manuallyRegisteredTestFunction, "ManuallyRegistered");
+        }
+    };
+
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+    static AutoTestReg autoTestReg;
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+        template<typename T>
+    struct Foo {
+        size_t size() { return 0; }
+    };
+
+    template<typename T, size_t S>
+    struct Bar {
+        size_t size() { return S; }
+    };
+
+}
 
 TEST_CASE( "random SECTION tests", "[.][sections][failing]" ) {
     int a = 1;
@@ -521,5 +519,3 @@ TEMPLATE_TEST_CASE_SIG("#1954 - 7 arg template test case sig compiles", "[regres
                        (1, 1, 1, 1, 1, 0, 0), (5, 1, 1, 1, 1, 0, 0), (5, 3, 1, 1, 1, 0, 0)) {
     SUCCEED();
 }
-
-}} // namespace MiscTests