diff options
| author | Martin Hořeňovský | 2021-06-20 16:25:57 +0200 |
|---|---|---|
| committer | Martin Hořeňovský | 2021-06-20 19:15:02 +0200 |
| commit | bf61a418cbc4d3b430e3d258c5287780944ad505 (patch) | |
| tree | f93f4136d7b2a14cc4fdecc8a90ad9415ead4c17 /tests/SelfTest/UsageTests | |
| parent | 849002aec0271b0a8356162134ea78731e84454a (diff) | |
| download | catch3-bf61a418cbc4d3b430e3d258c5287780944ad505.tar.gz | |
Remove the ill-conceived compilation perf tests using real tests
Diffstat (limited to 'tests/SelfTest/UsageTests')
| -rw-r--r-- | tests/SelfTest/UsageTests/Approx.tests.cpp | 17 | ||||
| -rw-r--r-- | tests/SelfTest/UsageTests/BDD.tests.cpp | 148 | ||||
| -rw-r--r-- | tests/SelfTest/UsageTests/Class.tests.cpp | 81 | ||||
| -rw-r--r-- | tests/SelfTest/UsageTests/Compilation.tests.cpp | 223 | ||||
| -rw-r--r-- | tests/SelfTest/UsageTests/Condition.tests.cpp | 47 | ||||
| -rw-r--r-- | tests/SelfTest/UsageTests/Exception.tests.cpp | 71 | ||||
| -rw-r--r-- | tests/SelfTest/UsageTests/Matchers.tests.cpp | 1784 | ||||
| -rw-r--r-- | tests/SelfTest/UsageTests/Misc.tests.cpp | 86 |
8 files changed, 1225 insertions, 1232 deletions
diff --git a/tests/SelfTest/UsageTests/Approx.tests.cpp b/tests/SelfTest/UsageTests/Approx.tests.cpp index f0d8919c..96f9706d 100644 --- a/tests/SelfTest/UsageTests/Approx.tests.cpp +++ b/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 diff --git a/tests/SelfTest/UsageTests/BDD.tests.cpp b/tests/SelfTest/UsageTests/BDD.tests.cpp index 131340fa..eba58d38 100644 --- a/tests/SelfTest/UsageTests/BDD.tests.cpp +++ b/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); - - 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); - } +} + +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 ); + + 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("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_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); } } } - -}} // namespace BDDtests +} diff --git a/tests/SelfTest/UsageTests/Class.tests.cpp b/tests/SelfTest/UsageTests/Class.tests.cpp index b6009e0b..94e83051 100644 --- a/tests/SelfTest/UsageTests/Class.tests.cpp +++ b/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 diff --git a/tests/SelfTest/UsageTests/Compilation.tests.cpp b/tests/SelfTest/UsageTests/Compilation.tests.cpp index cce190f2..c40c09f8 100644 --- a/tests/SelfTest/UsageTests/Compilation.tests.cpp +++ b/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; } - }; - - -// This is a minimal example for an issue we have found in 1.7.0 - struct foo { - int i; - }; +// 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; } +}; - 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); - } - - TEST_CASE("#1027: Bitfields can be captured") { - struct Y { - uint32_t v : 1; - }; - Y y{ 0 }; - REQUIRE(y.v == 0); - REQUIRE(0 == y.v); - } - - // 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); - } +// 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); +} - // unsigned array - TEST_CASE("#1238") { - unsigned char uarr[] = "123"; - CAPTURE(uarr); - signed char sarr[] = "456"; - CAPTURE(sarr); +// unsigned array +TEST_CASE("#1238") { + unsigned char uarr[] = "123"; + CAPTURE(uarr); + signed char sarr[] = "456"; + CAPTURE(sarr); - REQUIRE(std::memcmp(uarr, "123", sizeof(uarr)) == 0); - REQUIRE(std::memcmp(sarr, "456", sizeof(sarr)) == 0); - } + REQUIRE(std::memcmp(uarr, "123", sizeof(uarr)) == 0); + REQUIRE(std::memcmp(sarr, "456", sizeof(sarr)) == 0); +} - TEST_CASE_METHOD((Fixture_1245<int, int>), "#1245", "[compilation]") { - SUCCEED(); - } +TEST_CASE_METHOD((Fixture_1245<int, int>), "#1245", "[compilation]") { + SUCCEED(); +} - TEST_CASE("#1403", "[compilation]") { - ::foo::helper_1403 h1, h2; - REQUIRE(h1 == h2); - } +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("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("Lambdas in assertions") { - REQUIRE([]() { return true; }()); +TEST_CASE( "#1319: Sections can have description (even if it is not saved", + "[compilation]" ) { + SECTION( "SectionName", "This is a long form section description" ) { + SUCCEED(); } +} -}} // namespace CompilationTests +TEST_CASE("Lambdas in assertions") { + REQUIRE([]() { return true; }()); +} namespace { struct HasBitOperators { diff --git a/tests/SelfTest/UsageTests/Condition.tests.cpp b/tests/SelfTest/UsageTests/Condition.tests.cpp index 7c6a1d73..167752e1 100644 --- a/tests/SelfTest/UsageTests/Condition.tests.cpp +++ b/tests/SelfTest/UsageTests/Condition.tests.cpp @@ -20,31 +20,28 @@ using Catch::Approx; #include <limits> #include <cstdint> -namespace { namespace ConditionTests { - -#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 TestDef { - TestDef& operator + ( const std::string& ) { - return *this; - } - TestDef& operator[]( const std::string& ) { - return *this; - } -}; - -inline const char* returnsConstNull(){ return nullptr; } -inline char* returnsNull(){ return nullptr; } +namespace { -#endif + 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; + } + }; + + static const char* returnsConstNull() { return nullptr; } + static char* returnsNull() { return nullptr; } + +} // 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 diff --git a/tests/SelfTest/UsageTests/Exception.tests.cpp b/tests/SelfTest/UsageTests/Exception.tests.cpp index 1f6b4fa2..206bd9c8 100644 --- a/tests/SelfTest/UsageTests/Exception.tests.cpp +++ b/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 thisThrows() { - throw std::domain_error( "expected exception" ); - return 1; -} + int thisDoesntThrow() { + return 0; + } -int thisDoesntThrow() { - return 0; -} + class CustomException { + public: + explicit CustomException(const std::string& msg) + : m_msg(msg) {} -class CustomException { -public: - explicit CustomException( const std::string& msg ) - : m_msg( msg ) - {} + std::string getMessage() const { + return m_msg; + } - std::string getMessage() const { - return m_msg; - } + private: + std::string 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 {} -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; + } - std::string getMessage() const { - return m_msg; - } + private: + std::string 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 diff --git a/tests/SelfTest/UsageTests/Matchers.tests.cpp b/tests/SelfTest/UsageTests/Matchers.tests.cpp index cf6f3ce7..36bab396 100644 --- a/tests/SelfTest/UsageTests/Matchers.tests.cpp +++ b/tests/SelfTest/UsageTests/Matchers.tests.cpp @@ -12,41 +12,37 @@ #include <catch2/matchers/catch_matchers_templated.hpp> #include <algorithm> +#include <exception> #include <cmath> #include <list> #include <sstream> #ifdef __clang__ -#pragma clang diagnostic push -#pragma clang diagnostic ignored "-Wweak-vtables" -#pragma clang diagnostic ignored "-Wpadded" +# pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wweak-vtables" +# pragma clang diagnostic ignored "-Wpadded" #endif -namespace { namespace MatchersTests { - -#ifndef MATCHERS_TEST_HELPERS_INCLUDED // Don't compile this more than once per TU -#define MATCHERS_TEST_HELPERS_INCLUDED +namespace { - inline const char *testStringForMatching() { + static const char* testStringForMatching() { return "this string contains 'abc' as a substring"; } - inline const char *testStringForMatching2() { + static const char* testStringForMatching2() { return "some completely different text that contains one common word"; } - inline bool alwaysTrue(int) { return true; } - inline bool alwaysFalse(int) { return false; } - + static bool alwaysTrue( int ) { return true; } + static bool alwaysFalse( int ) { return false; } #ifdef _MSC_VER -#pragma warning(disable:4702) // Unreachable code -- MSVC 19 (VS 2015) sees right through the indirection +# pragma warning( disable : 4702 ) // Unreachable code -- MSVC 19 (VS 2015) + // sees right through the indirection #endif -#include <exception> - struct SpecialException : std::exception { - SpecialException(int i_) : i(i_) {} + SpecialException( int i_ ): i( i_ ) {} char const* what() const noexcept override { return "SpecialException::what"; @@ -61,29 +57,26 @@ namespace { namespace MatchersTests { } }; - void doesNotThrow() {} + static void doesNotThrow() {} - [[noreturn]] - void throwsSpecialException(int i) { - throw SpecialException{i}; + [[noreturn]] static void throwsSpecialException( int i ) { + throw SpecialException{ i }; } - [[noreturn]] - void throwsAsInt(int i) { - throw i; - } + [[noreturn]] static void throwsAsInt( int i ) { throw i; } - [[noreturn]] - void throwsDerivedException() { + [[noreturn]] static void throwsDerivedException() { throw DerivedException{}; } - class ExceptionMatcher : public Catch::Matchers::MatcherBase<SpecialException> { + class ExceptionMatcher + : public Catch::Matchers::MatcherBase<SpecialException> { int m_expected; + public: - ExceptionMatcher(int i) : m_expected(i) {} + ExceptionMatcher( int i ): m_expected( i ) {} - bool match(SpecialException const &se) const override { + bool match( SpecialException const& se ) const override { return se.i == m_expected; } @@ -94,934 +87,997 @@ namespace { namespace MatchersTests { } }; -#endif - using namespace Catch::Matchers; #ifdef __DJGPP__ - float nextafter(float from, float to) - { - return ::nextafterf(from, to); + static float nextafter( float from, float to ) { + return ::nextafterf( from, to ); } - double nextafter(double from, double to) - { - return ::nextafter(from, to); + static double nextafter( double from, double to ) { + return ::nextafter( from, to ); } #else using std::nextafter; #endif - TEST_CASE("String matchers", "[matchers]") { - REQUIRE_THAT(testStringForMatching(), Contains("string")); - REQUIRE_THAT(testStringForMatching(), Contains("string", Catch::CaseSensitive::No)); - CHECK_THAT(testStringForMatching(), Contains("abc")); - CHECK_THAT(testStringForMatching(), Contains("aBC", Catch::CaseSensitive::No)); - - CHECK_THAT(testStringForMatching(), StartsWith("this")); - CHECK_THAT(testStringForMatching(), StartsWith("THIS", Catch::CaseSensitive::No)); - CHECK_THAT(testStringForMatching(), EndsWith("substring")); - CHECK_THAT(testStringForMatching(), EndsWith(" SuBsTrInG", Catch::CaseSensitive::No)); - } - - TEST_CASE("Contains string matcher", "[.][failing][matchers]") { - CHECK_THAT(testStringForMatching(), Contains("not there", Catch::CaseSensitive::No)); - CHECK_THAT(testStringForMatching(), Contains("STRING")); - } - - TEST_CASE("StartsWith string matcher", "[.][failing][matchers]") { - CHECK_THAT(testStringForMatching(), StartsWith("This String")); - CHECK_THAT(testStringForMatching(), StartsWith("string", Catch::CaseSensitive::No)); - } +} // end unnamed namespace + +TEST_CASE( "String matchers", "[matchers]" ) { + REQUIRE_THAT( testStringForMatching(), Contains( "string" ) ); + REQUIRE_THAT( testStringForMatching(), + Contains( "string", Catch::CaseSensitive::No ) ); + CHECK_THAT( testStringForMatching(), Contains( "abc" ) ); + CHECK_THAT( testStringForMatching(), + Contains( "aBC", Catch::CaseSensitive::No ) ); + + CHECK_THAT( testStringForMatching(), StartsWith( "this" ) ); + CHECK_THAT( testStringForMatching(), + StartsWith( "THIS", Catch::CaseSensitive::No ) ); + CHECK_THAT( testStringForMatching(), EndsWith( "substring" ) ); + CHECK_THAT( testStringForMatchin |