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

summaryrefslogtreecommitdiffhomepage
path: root/tests/SelfTest/UsageTests
diff options
context:
space:
mode:
authorMartin Hořeňovský2021-06-20 16:25:57 +0200
committerMartin Hořeňovský2021-06-20 19:15:02 +0200
commitbf61a418cbc4d3b430e3d258c5287780944ad505 (patch)
treef93f4136d7b2a14cc4fdecc8a90ad9415ead4c17 /tests/SelfTest/UsageTests
parent849002aec0271b0a8356162134ea78731e84454a (diff)
downloadcatch3-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.cpp17
-rw-r--r--tests/SelfTest/UsageTests/BDD.tests.cpp148
-rw-r--r--tests/SelfTest/UsageTests/Class.tests.cpp81
-rw-r--r--tests/SelfTest/UsageTests/Compilation.tests.cpp223
-rw-r--r--tests/SelfTest/UsageTests/Condition.tests.cpp47
-rw-r--r--tests/SelfTest/UsageTests/Exception.tests.cpp71
-rw-r--r--tests/SelfTest/UsageTests/Matchers.tests.cpp1784
-rw-r--r--tests/SelfTest/UsageTests/Misc.tests.cpp86
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