3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2024-11-23 05:46:11 +01:00
Code Issues Packages Projects Releases Wiki Activity
d17d94e45d
catch2/include/catch.hpp

233 lines
13 KiB
C++
Raw Normal View History

First commit for GitHub
2010-11-10 00:24:00 +01:00
/*
* Created by Phil on 22/10/2010.
* Copyright 2010 Two Blue Cubes Ltd
*
* Distributed under the Boost Software License, Version 1.0. (See accompanying
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef TWOBLUECUBES_CATCH_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_HPP_INCLUDED
Moved catch_interfaces_runner.hpp out of conditionally compiled section
2012-06-03 00:12:42 +02:00
suppressed some more warnings
2015-05-21 07:15:53 +02:00
#ifdef __clang__
# pragma clang system_header
#elif defined __GNUC__
# pragma GCC system_header
#endif
Suppressed a load of warnings
2014-05-19 19:57:14 +02:00
#include "internal/catch_suppress_warnings.h"
Builds almost completely cleanly with -WEverything in LLVM
2012-08-13 08:46:10 +02:00
First commit of (in progress) TeamCity reporter Should run but is not complete
2014-12-19 18:52:33 +01:00
#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
# define CATCH_IMPL
Fixed instance of Clara::_ placeholder when using CATCH_CONFIG_RUNNER
2014-03-10 19:02:18 +01:00
#endif
First commit of (in progress) TeamCity reporter Should run but is not complete
2014-12-19 18:52:33 +01:00
#ifdef CATCH_IMPL
Fix problem (hopefully) with single source definitions from Clara - define CLARA_CONFIG_MAIN in the right place
2014-03-06 22:53:34 +01:00
# ifndef CLARA_CONFIG_MAIN
# define CLARA_CONFIG_MAIN_NOT_DEFINED
# define CLARA_CONFIG_MAIN
# endif
#endif
First cut of StaticRegistries - separate from Context
2012-08-06 21:16:53 +02:00
#include "internal/catch_notimplemented_exception.h"
renamed hub -> context (also did some reformatting)
2012-05-10 08:58:48 +02:00
#include "internal/catch_context.h"
More project refactoring
2011-01-05 22:16:54 +01:00
#include "internal/catch_test_registry.hpp"
First commit for GitHub
2010-11-10 00:24:00 +01:00
#include "internal/catch_capture.hpp"
Refactored a lot of code from headers into impl headers only compiled into one TU - also added noimpl option to single header script - which only generates the non impl code
2013-12-03 19:52:41 +01:00
#include "internal/catch_section.h"
Multiple generators working and factored out a bit better
2011-01-27 23:29:36 +01:00
#include "internal/catch_generators.hpp"
First cut of custom exception support
2011-04-20 16:40:40 +02:00
#include "internal/catch_interfaces_exception.h"
Factored Approx out into own file
2011-04-28 09:03:28 +02:00
#include "internal/catch_approx.hpp"
Extracted string matchers impl into cpp that is only compiled into main TU
2017-02-08 16:14:51 +01:00
#include "internal/catch_matchers_string.h"
Added first vector matchers (Contains and Equals)
2017-02-21 17:05:04 +01:00
#include "internal/catch_matchers_vector.h"
Compiler capabilities clean-up - renamed CATCH_SFINAE -> CATCH_CONFIG_SFINAE - moved variadic macros detection into catch_compiler_capabilities.h
2013-04-22 09:19:17 +02:00
#include "internal/catch_compiler_capabilities.h"
Tag aliases feature
2014-06-30 08:33:17 +02:00
#include "internal/catch_interfaces_tag_alias_registry.h"
First commit for GitHub
2010-11-10 00:24:00 +01:00
Moved catch_interfaces_runner.hpp out of conditionally compiled section
2012-06-03 00:12:42 +02:00
// These files are included here so the single_include script doesn't put them
// in the conditionally compiled sections
Split imll from TestCaseInfo
2012-08-14 20:30:30 +02:00
#include "internal/catch_test_case_info.h"
Moved catch_interfaces_runner.hpp out of conditionally compiled section
2012-06-03 00:12:42 +02:00
#include "internal/catch_interfaces_runner.h"
Re-ordered Obj-C headers to fix dependency issue
2011-08-12 19:52:10 +02:00
#ifdef __OBJC__
#include "internal/catch_objc.hpp"
#endif
First commit of (in progress) TeamCity reporter Should run but is not complete
2014-12-19 18:52:33 +01:00
#ifdef CATCH_IMPL
Moved WIndows leak detector code out of main()
2017-02-18 00:43:31 +01:00
// !TBD: Move the leak detector code into a separate header
#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
#include <crtdbg.h>
class LeakDetector {
public:
LeakDetector() {
int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
flag |= _CRTDBG_LEAK_CHECK_DF;
flag |= _CRTDBG_ALLOC_MEM_DF;
_CrtSetDbgFlag(flag);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
// Change this to leaking allocation's number to break there
_CrtSetBreakAlloc(-1);
}
};
#else
class LeakDetector {};
#endif
LeakDetector leakDetector;
First cut of StaticRegistries - separate from Context
2012-08-06 21:16:53 +02:00
#include "internal/catch_impl.hpp"
Fix problem (hopefully) with single source definitions from Clara - define CLARA_CONFIG_MAIN in the right place
2014-03-06 22:53:34 +01:00
#endif
Tweaks to allow headers to be glued together. Added Python script to generate single header. Added new XCode project that runs self test against single header
2011-05-24 09:23:02 +02:00
#ifdef CATCH_CONFIG_MAIN
#include "internal/catch_default_main.hpp"
Fix problem (hopefully) with single source definitions from Clara - define CLARA_CONFIG_MAIN in the right place
2014-03-06 22:53:34 +01:00
#endif
#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
# undef CLARA_CONFIG_MAIN
#endif
Tweaks to allow headers to be glued together. Added Python script to generate single header. Added new XCode project that runs self test against single header
2011-05-24 09:23:02 +02:00
First commit for GitHub
2010-11-10 00:24:00 +01:00
//////
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
#ifdef CATCH_CONFIG_PREFIX_ALL
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#if defined(CATCH_CONFIG_FAST_COMPILE)
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#else
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#endif
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", __VA_ARGS__ )
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define CATCH_CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", __VA_ARGS__ )
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#if defined(CATCH_CONFIG_FAST_COMPILE)
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#else
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#endif
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
Gutted catch_compiler_capabilities All C++11 toggles are now removed. What is left is either platform specific (POSIX_SIGNALS, WINDOWS_SEH), or possibly still needed (USE_COUNTER). If current CLion is compatible with `__COUNTER__`, then we should also force `__COUNTER__` usage. Changed * CATCH_AUTO_PTR -> std::unique_ptr * CATCH_OVERRIDE -> override * CATCH_NULL -> nullptr * CATCH_NOEXCEPT -> noexcept * CATCH_NOEXCEPT_IS -> noexcept Removed * CATCH_CONFIG_CPP11_UNIQUE_PTR * CATCH_CONFIG_CPP11_SHUFFLE * CATCH_CONFIG_CPP11_TYPE_TRAITS * CATCH_CONFIG_CPP11_OVERRIDE * CATCH_CONFIG_CPP11_LONG_LONG * CATCH_CONFIG_CPP11_TUPLE * CATCH_CONFIG_CPP11_IS_ENUM * CATCH_CONFIG_CPP11_GENERATED_METHODS * CATCH_CONFIG_CPP11_NOEXCEPT * CATCH_CONFIG_CPP11_NULLPTR * CATCH_CONFIG_VARIADIC_MACROS
2017-04-25 12:41:30 +02:00
#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, "CATCH_FAIL", __VA_ARGS__ )
#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
Initial support for variadic macros
2013-03-16 21:18:52 +01:00
#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
Added BDD macros (Also includes regenerated files from previous commits)
2013-03-13 13:19:30 +01:00
// "BDD-style" convenience wrappers
Variadics support for BDD macros (scenarios)
2013-03-16 21:39:19 +01:00
#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
Added SCENARIO_METHOD for BDD testing with fixtures.
2014-07-10 11:22:20 +02:00
#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
Given, When, Then prefixes are now std::strings (and so can be prepended to std::strings themselves) see #455
2015-07-22 19:07:28 +02:00
#define CATCH_GIVEN( desc ) CATCH_SECTION( std::string( "Given: ") + desc, "" )
#define CATCH_WHEN( desc ) CATCH_SECTION( std::string( " When: ") + desc, "" )
#define CATCH_AND_WHEN( desc ) CATCH_SECTION( std::string( " And: ") + desc, "" )
#define CATCH_THEN( desc ) CATCH_SECTION( std::string( " Then: ") + desc, "" )
#define CATCH_AND_THEN( desc ) CATCH_SECTION( std::string( " And: ") + desc, "" )
Added BDD macros (Also includes regenerated files from previous commits)
2013-03-13 13:19:30 +01:00
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
#else
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#if defined(CATCH_CONFIG_FAST_COMPILE)
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define REQUIRE( ... ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#else
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#endif
First commit for GitHub
2010-11-10 00:24:00 +01:00
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", __VA_ARGS__ )
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
First commit for GitHub
2010-11-10 00:24:00 +01:00
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
First commit for GitHub
2010-11-10 00:24:00 +01:00
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", __VA_ARGS__ )
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
Most of Assertion macros are now variadic This means that `REQUIRE(std::vector<int>{1, 2} == std::vector<int>{1, 2});` works as expected. Note that assertion macros taking more than 1 argument are currently not variadic, because variadic args have to come last, which would make the interface of these ugly: `REQUIRE_THROWS_AS(std::exception const&, .... )`
2017-04-25 20:20:46 +02:00
#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
First commit for GitHub
2010-11-10 00:24:00 +01:00
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#if defined(CATCH_CONFIG_FAST_COMPILE)
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#else
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
CATCH_CONFIG_FAST_COMPILE now disables trys in REQUIRE* This seems to give about 15% speedup when compiling tests using GCC. The tradeoff is that under certain circumstances, there is a chance for false negative result, when the expression under test throws exception and the test code catches it before it gets to the test runner. Example: ``` cpp TEST_CASE("False negative") { try { REQUIRE(throws() == ""); } catch (...) {} } ``` This test case will succeed, reporting no assertions checked, instead of failing as it would with `CATCH_CONFIG_FAST_COMPILE` disabled. However, just removing the try-catch block inside client's code will fix this, so it is worthwhile. This change does not apply to CHECK* macros, because these are currently specified as continuing on exception and thus need the local try-catch to work as intended.
2017-03-17 13:21:40 +01:00
#endif
First cut of Matcher support
2012-03-04 12:14:21 +01:00
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
#define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
First commit for GitHub
2010-11-10 00:24:00 +01:00
Added FAIL_CHECK Works like FAIL, but does not abort test. As proposed in #765
2017-03-08 16:40:20 +01:00
#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
Changed all internal forwarding macro usages to put macro name as first argument (and ‘expression’, if any, last) This is a first step towards allowing expression arguments to become variadic
2017-03-21 14:22:39 +01:00
#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
Initial support for variadic macros
2013-03-16 21:18:52 +01:00
#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
First commit for GitHub
2010-11-10 00:24:00 +01:00
Multiple generators working and factored out a bit better
2011-01-27 23:29:36 +01:00
#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
First commit for GitHub
2010-11-10 00:24:00 +01:00
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
#endif
#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
First commit for GitHub
2010-11-10 00:24:00 +01:00
Added BDD macros (Also includes regenerated files from previous commits)
2013-03-13 13:19:30 +01:00
// "BDD-style" convenience wrappers
Variadics support for BDD macros (scenarios)
2013-03-16 21:39:19 +01:00
#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
Added SCENARIO_METHOD for BDD testing with fixtures.
2014-07-10 11:22:20 +02:00
#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
Gutted catch_compiler_capabilities All C++11 toggles are now removed. What is left is either platform specific (POSIX_SIGNALS, WINDOWS_SEH), or possibly still needed (USE_COUNTER). If current CLion is compatible with `__COUNTER__`, then we should also force `__COUNTER__` usage. Changed * CATCH_AUTO_PTR -> std::unique_ptr * CATCH_OVERRIDE -> override * CATCH_NULL -> nullptr * CATCH_NOEXCEPT -> noexcept * CATCH_NOEXCEPT_IS -> noexcept Removed * CATCH_CONFIG_CPP11_UNIQUE_PTR * CATCH_CONFIG_CPP11_SHUFFLE * CATCH_CONFIG_CPP11_TYPE_TRAITS * CATCH_CONFIG_CPP11_OVERRIDE * CATCH_CONFIG_CPP11_LONG_LONG * CATCH_CONFIG_CPP11_TUPLE * CATCH_CONFIG_CPP11_IS_ENUM * CATCH_CONFIG_CPP11_GENERATED_METHODS * CATCH_CONFIG_CPP11_NOEXCEPT * CATCH_CONFIG_CPP11_NULLPTR * CATCH_CONFIG_VARIADIC_MACROS
2017-04-25 12:41:30 +02:00
Given, When, Then prefixes are now std::strings (and so can be prepended to std::strings themselves) see #455
2015-07-22 19:07:28 +02:00
#define GIVEN( desc ) SECTION( std::string(" Given: ") + desc, "" )
#define WHEN( desc ) SECTION( std::string(" When: ") + desc, "" )
#define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc, "" )
#define THEN( desc ) SECTION( std::string(" Then: ") + desc, "" )
#define AND_THEN( desc ) SECTION( std::string(" And: ") + desc, "" )
Added BDD macros (Also includes regenerated files from previous commits)
2013-03-13 13:19:30 +01:00
Moved Approx into its own namespace to avoid ADL issues with operator ==
2011-04-04 08:56:44 +02:00
using Catch::Detail::Approx;
First commit for GitHub
2010-11-10 00:24:00 +01:00
Suppressed a load of warnings
2014-05-19 19:57:14 +02:00
#include "internal/catch_reenable_warnings.h"
Builds almost completely cleanly with -WEverything in LLVM
2012-08-13 08:46:10 +02:00
Fixed more warnings and applied workaround for getting to std::numeric_limits without clashing with Windows' min() and max() macros.
2011-02-16 20:02:09 +01:00
#endif // TWOBLUECUBES_CATCH_HPP_INCLUDED
Reference in New Issue Copy Permalink