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

497 lines
29 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
Add CATCH_VERSION_* defines for external use I wonder how much use they will actually see, but their cost is fairly minor. Closes #1131
2018-01-26 20:27:19 +01:00
#define CATCH_VERSION_MAJOR 2
v2.10.0
2019-10-13 23:44:18 +02:00
#define CATCH_VERSION_MINOR 10
#define CATCH_VERSION_PATCH 0
Initial prototype of PCH support Related to #1061
2017-11-14 21:04:36 +01: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
Initial prototype of PCH support Related to #1061
2017-11-14 21:04:36 +01:00
# define CATCH_CONFIG_ALL_PARTS
#endif
// In the impl file, we want to have access to all parts of the headers
// Can also be used to sanely support PCHs
#if defined(CATCH_CONFIG_ALL_PARTS)
Add define that pulls in reporter and listeners interfaces This allows users to define reporters and listeners in files different from the main file. Related to #991, #986
2017-08-17 20:21:06 +02:00
# define CATCH_CONFIG_EXTERNAL_INTERFACES
Always compile matchers implementation
2017-08-30 18:06:48 +02:00
# if defined(CATCH_CONFIG_DISABLE_MATCHERS)
# undef CATCH_CONFIG_DISABLE_MATCHERS
# endif
Properly guard CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER definition
2018-07-03 09:25:34 +02:00
# if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
# define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
# endif
Fixed instance of Clara::_ placeholder when using CATCH_CONFIG_RUNNER
2014-03-10 19:02:18 +01:00
#endif
Initial prototype of PCH support Related to #1061
2017-11-14 21:04:36 +01:00
#if !defined(CATCH_CONFIG_IMPL_ONLY)
Force include catch_platform.h before any if-defs Closes #994
2017-08-21 14:58:50 +02:00
#include "internal/catch_platform.h"
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
Introduce a way to intentionally expose interface for use in tests Fixes #1076
2017-11-21 11:10:07 +01:00
#include "internal/catch_user_interfaces.h"
Split Option<T> and TagAlias definitions away from the main include path
2017-07-27 11:55:30 +02:00
#include "internal/catch_tag_alias_autoregistrar.h"
Changed all .hpp extensions to .h where there is now a corresponding .cpp
2017-09-07 12:24:33 +02:00
#include "internal/catch_test_registry.h"
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"
First cut of custom exception support
2011-04-20 16:40:40 +02:00
#include "internal/catch_interfaces_exception.h"
Changed all .hpp extensions to .h where there is now a corresponding .cpp
2017-09-07 12:24:33 +02:00
#include "internal/catch_approx.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"
Fixed Objective-C mode
2017-09-06 16:43:26 +02:00
#include "internal/catch_string_manip.h"
First commit for GitHub
2010-11-10 00:24:00 +01:00
Moved matcher-based capture macros into their own file - this file excluded from the CATCH_CONFIG_DISABLE_MATCHERS path. - matchers are always compiled in to the impl file - _THROWS_WITH macros are still available with matchers disabled - but only the ones that take a string - tests that use matchers have #ifdefs, so the whole SelfTest project can compile with matchers disable.
2017-08-09 13:10:14 +02:00
#ifndef CATCH_CONFIG_DISABLE_MATCHERS
#include "internal/catch_capture_matchers.h"
#endif
First attempt at data generator support The support is to be considered experimental, that is, the interfaces, the first party generators and helper functions can change or be removed at any point in time. Related to #850
2018-06-12 18:50:39 +02:00
#include "internal/catch_generators.hpp"
Add ChunkGenerator This generator collects values from the underlying generator until it has a specified amount of them, and then returns them in one "chunk". In case the underlying generator does not have enough elements for a specific chunk, the left-over elements are discarded. Closes #1538
2019-02-23 20:22:46 +01:00
#include "internal/catch_generators_generic.hpp"
Introduce random number (Integral and Float) generators
2019-02-19 22:09:14 +01:00
#include "internal/catch_generators_specific.hpp"
Moved matcher-based capture macros into their own file - this file excluded from the CATCH_CONFIG_DISABLE_MATCHERS path. - matchers are always compiled in to the impl file - _THROWS_WITH macros are still available with matchers disabled - but only the ones that take a string - tests that use matchers have #ifdefs, so the whole SelfTest project can compile with matchers disable.
2017-08-09 13:10:14 +02: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
Fix benchmarking in stand-alone files
2019-06-17 11:58:40 +02:00
// Benchmarking needs the externally-facing parts of reporters to work
#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
Add define that pulls in reporter and listeners interfaces This allows users to define reporters and listeners in files different from the main file. Related to #991, #986
2017-08-17 20:21:06 +02:00
#include "internal/catch_external_interfaces.h"
#endif
Various improvements to the benchmarking support * Units from <ratio> are no longer redeclared in our own namespace * The default clock is `steady_clock`, not `high_resolution_clock`, because, as HH says "high_resolution_clock is useless. If you want measure the passing of time, use steady_clock. If you want user friendly time, use system_clock". * Benchmarking support is opt-in, not opt-out, to avoid the large (~10%) compile time penalty. * Benchmarking-related options in CLI are always present, to decrease the amount of code that is only compiled conditionally and making the whole shebang more maintainble.
2019-05-19 20:54:44 +02:00
#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
#include "internal/benchmark/catch_benchmark.hpp"
#endif
Initial prototype of PCH support Related to #1061
2017-11-14 21:04:36 +01:00
#endif // ! CATCH_CONFIG_IMPL_ONLY
First commit of (in progress) TeamCity reporter Should run but is not complete
2014-12-19 18:52:33 +01:00
#ifdef CATCH_IMPL
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
Integrate Nonius benchmark into Catch2 Changes done to Nonius: * Moved things into "Catch::Benchmark" namespace * Benchmarks were integrated with `TEST_CASE`/`SECTION`/`GENERATE` macros * Removed Nonius's parameters for benchmarks, Generators should be used instead * Added relevant methods to the reporter interface (default-implemented, to avoid breaking existing 3rd party reporters) * Async processing is guarded with `_REENTRANT` macro for GCC/Clang, used by default on MSVC * Added a macro `CATCH_CONFIG_DISABLE_BENCHMARKING` that removes all traces of benchmarking from Catch
2019-04-23 23:41:13 +02:00
Initial prototype of PCH support Related to #1061
2017-11-14 21:04:36 +01:00
#if !defined(CATCH_CONFIG_IMPL_ONLY)
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
#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
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
#if !defined(CATCH_CONFIG_DISABLE)
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
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__ )
Added ability to specify if macros should be prefixed with CATCH_
2012-07-20 19:43:48 +02:00
Catch: resolve inconsistency in CATCH_REQUIRE_THROWS The REQUIRE_THROWS and CATCH_REQUIRE_THROWS macros have a subtle inconsistency in their implementation which can cause a warning if [-Wunused-value] is used. This commit changes CATCH_REQUIRE_THROWS so it has the same implementation as REQUIRE_THROWS It looks like REQUIRE_THROWS was change in commit fae0fa4ec but not CATCH_REQUIRE_THROWS. Similar changes for CATCH_CHECK_THROWS
2019-02-08 20:10:46 +01: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 )
Fix missing CATCH_ prefixed macros
2017-07-28 21:04:18 +02:00
#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
Moved matcher-based capture macros into their own file - this file excluded from the CATCH_CONFIG_DISABLE_MATCHERS path. - matchers are always compiled in to the impl file - _THROWS_WITH macros are still available with matchers disabled - but only the ones that take a string - tests that use matchers have #ifdefs, so the whole SelfTest project can compile with matchers disable.
2017-08-09 13:10:14 +02:00
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
Fix missing CATCH_ prefixed macros
2017-07-28 21:04:18 +02:00
#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
Introduce compile time toggle to remove Matchers from TU The toggle is `CATCH_CONFIG_DISABLE_MATCHERS` and the only use is to speed up compilation of small TUs. For large ones it is likely insignificant, because the speed up is constant relative to number of tests/assertions in TU.
2017-07-28 21:34:34 +02:00
#endif// CATCH_CONFIG_DISABLE_MATCHERS
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
Catch: resolve inconsistency in CATCH_REQUIRE_THROWS The REQUIRE_THROWS and CATCH_REQUIRE_THROWS macros have a subtle inconsistency in their implementation which can cause a warning if [-Wunused-value] is used. This commit changes CATCH_REQUIRE_THROWS so it has the same implementation as REQUIRE_THROWS It looks like REQUIRE_THROWS was change in commit fae0fa4ec but not CATCH_REQUIRE_THROWS. Similar changes for CATCH_CHECK_THROWS
2019-02-08 20:10:46 +01: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 )
Fix missing CATCH_ prefixed macros
2017-07-28 21:04:18 +02:00
#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
Moved matcher-based capture macros into their own file - this file excluded from the CATCH_CONFIG_DISABLE_MATCHERS path. - matchers are always compiled in to the impl file - _THROWS_WITH macros are still available with matchers disabled - but only the ones that take a string - tests that use matchers have #ifdefs, so the whole SelfTest project can compile with matchers disable.
2017-08-09 13:10:14 +02:00
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
Fix missing CATCH_ prefixed macros
2017-07-28 21:04:18 +02:00
#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
Introduce compile time toggle to remove Matchers from TU The toggle is `CATCH_CONFIG_DISABLE_MATCHERS` and the only use is to speed up compilation of small TUs. For large ones it is likely insignificant, because the speed up is constant relative to number of tests/assertions in TU.
2017-07-28 21:34:34 +02:00
#endif // CATCH_CONFIG_DISABLE_MATCHERS
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
Fix inverted CATCH_CONFIG_DISABLE_MATCHERS toggle
2017-07-29 08:43:32 +02:00
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
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
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 )
Introduce compile time toggle to remove Matchers from TU The toggle is `CATCH_CONFIG_DISABLE_MATCHERS` and the only use is to speed up compilation of small TUs. For large ones it is likely insignificant, because the speed up is constant relative to number of tests/assertions in TU.
2017-07-28 21:34:34 +02:00
#endif // CATCH_CONFIG_DISABLE_MATCHERS
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 )
Add UNSCOPED_INFO to prefix/disabled sections
2019-04-24 21:51:21 +02:00
#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
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_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
CAPTURE is now variadic
2018-06-27 22:34:35 +02:00
#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
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__ )
Added DYNAMIC_SECTION and implemented GIVEN/ WHEN/ THEN in terms of it
2018-06-25 20:19:21 +02:00
#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
Fix order of arguments in CATCH_FAIL macro
2017-04-28 18:33:52 +02:00
#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __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
#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__ )
Removed all (that I could find) redundant second macro args to TEST_CASE and SECTION - now we can rely on variadic macros
2017-07-13 10:20:37 +02: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
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#else
#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#endif
Add STATIC_REQUIRE assertion By default, it expands into a `static_assert` + `SUCCEED` pair, but it can also be deferred to runtime by defining `CATCH_CONFIG_RUNTIME_STATIC_REQUIRE`, which causes it to expand into plain old `REQUIRE`. Closes #1362 Closes #1356
2018-10-13 21:29:59 +02:00
#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
#define CATCH_STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__ , #__VA_ARGS__ ); CATCH_SUCCEED( #__VA_ARGS__ )
#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
#else
#define CATCH_STATIC_REQUIRE( ... ) CATCH_REQUIRE( __VA_ARGS__ )
#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
#endif
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__ )
Add BDD AND_GIVEN based macros issue #1360 It is possible to have multple given contexts in a single BDD scenario; if you have to type 'and' in the GIVEN description; it's very likely you need an AND. A generic AND is not possible, thus a AND_GIVEN is added to complement the AND_WHEN and AND_THEN. Can be used without needing to increase indent: SCENARIO("...") { GIVEN("...") AND_GIVEN("...") { WHEN("...") { THEN("...") { // ... } } } } would correctly output, when requested/needed: Given: ... And given: ... When: ... Then: ... The padding had to be increased by a character in the output message, to continue to be uniform.
2018-08-14 11:49:55 +02:00
#define CATCH_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc )
#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
#define CATCH_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc )
#define CATCH_AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
#define CATCH_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc )
#define CATCH_AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc )
Added BDD macros (Also includes regenerated files from previous commits)
2013-03-13 13:19:30 +01:00
Various improvements to the benchmarking support * Units from <ratio> are no longer redeclared in our own namespace * The default clock is `steady_clock`, not `high_resolution_clock`, because, as HH says "high_resolution_clock is useless. If you want measure the passing of time, use steady_clock. If you want user friendly time, use system_clock". * Benchmarking support is opt-in, not opt-out, to avoid the large (~10%) compile time penalty. * Benchmarking-related options in CLI are always present, to decrease the amount of code that is only compiled conditionally and making the whole shebang more maintainble.
2019-05-19 20:54:44 +02:00
#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
Integrate Nonius benchmark into Catch2 Changes done to Nonius: * Moved things into "Catch::Benchmark" namespace * Benchmarks were integrated with `TEST_CASE`/`SECTION`/`GENERATE` macros * Removed Nonius's parameters for benchmarks, Generators should be used instead * Added relevant methods to the reporter interface (default-implemented, to avoid breaking existing 3rd party reporters) * Async processing is guarded with `_REENTRANT` macro for GCC/Clang, used by default on MSVC * Added a macro `CATCH_CONFIG_DISABLE_BENCHMARKING` that removes all traces of benchmarking from Catch
2019-04-23 23:41:13 +02:00
#define CATCH_BENCHMARK(...) \
INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
#define CATCH_BENCHMARK_ADVANCED(name) \
INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
Various improvements to the benchmarking support * Units from <ratio> are no longer redeclared in our own namespace * The default clock is `steady_clock`, not `high_resolution_clock`, because, as HH says "high_resolution_clock is useless. If you want measure the passing of time, use steady_clock. If you want user friendly time, use system_clock". * Benchmarking support is opt-in, not opt-out, to avoid the large (~10%) compile time penalty. * Benchmarking-related options in CLI are always present, to decrease the amount of code that is only compiled conditionally and making the whole shebang more maintainble.
2019-05-19 20:54:44 +02:00
#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
Integrate Nonius benchmark into Catch2 Changes done to Nonius: * Moved things into "Catch::Benchmark" namespace * Benchmarks were integrated with `TEST_CASE`/`SECTION`/`GENERATE` macros * Removed Nonius's parameters for benchmarks, Generators should be used instead * Added relevant methods to the reporter interface (default-implemented, to avoid breaking existing 3rd party reporters) * Async processing is guarded with `_REENTRANT` macro for GCC/Clang, used by default on MSVC * Added a macro `CATCH_CONFIG_DISABLE_BENCHMARKING` that removes all traces of benchmarking from Catch
2019-04-23 23:41:13 +02: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
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__ )
First commit for GitHub
2010-11-10 00:24:00 +01:00
Merge branch 'dev-second-string-argument-removal' into dev-modernize It is no longer true that an assertion macro has either 1 or 2 args, so...
2017-06-26 20:48:41 +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 )
Merge branch 'dev-second-string-argument-removal' into dev-modernize It is no longer true that an assertion macro has either 1 or 2 args, so...
2017-06-26 20:48:41 +02:00
#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
Moved matcher-based capture macros into their own file - this file excluded from the CATCH_CONFIG_DISABLE_MATCHERS path. - matchers are always compiled in to the impl file - _THROWS_WITH macros are still available with matchers disabled - but only the ones that take a string - tests that use matchers have #ifdefs, so the whole SelfTest project can compile with matchers disable.
2017-08-09 13:10:14 +02:00
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
Added new assertion macros: `*_THROWS_WITH` It combines `*_THROWS_AS` and `*_THROWS_WITH` macros, so that the exception type matches expectetations and its contents match a specific matcher.
2017-06-05 18:40:50 +02:00
#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
Introduce compile time toggle to remove Matchers from TU The toggle is `CATCH_CONFIG_DISABLE_MATCHERS` and the only use is to speed up compilation of small TUs. For large ones it is likely insignificant, because the speed up is constant relative to number of tests/assertions in TU.
2017-07-28 21:34:34 +02:00
#endif // CATCH_CONFIG_DISABLE_MATCHERS
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
Merge branch 'dev-second-string-argument-removal' into dev-modernize It is no longer true that an assertion macro has either 1 or 2 args, so...
2017-06-26 20:48:41 +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 )
Merge branch 'dev-second-string-argument-removal' into dev-modernize It is no longer true that an assertion macro has either 1 or 2 args, so...
2017-06-26 20:48:41 +02:00
#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
Moved matcher-based capture macros into their own file - this file excluded from the CATCH_CONFIG_DISABLE_MATCHERS path. - matchers are always compiled in to the impl file - _THROWS_WITH macros are still available with matchers disabled - but only the ones that take a string - tests that use matchers have #ifdefs, so the whole SelfTest project can compile with matchers disable.
2017-08-09 13:10:14 +02:00
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
Added new assertion macros: `*_THROWS_WITH` It combines `*_THROWS_AS` and `*_THROWS_WITH` macros, so that the exception type matches expectetations and its contents match a specific matcher.
2017-06-05 18:40:50 +02:00
#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
Introduce compile time toggle to remove Matchers from TU The toggle is `CATCH_CONFIG_DISABLE_MATCHERS` and the only use is to speed up compilation of small TUs. For large ones it is likely insignificant, because the speed up is constant relative to number of tests/assertions in TU.
2017-07-28 21:34:34 +02:00
#endif // CATCH_CONFIG_DISABLE_MATCHERS
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
Introduce compile time toggle to remove Matchers from TU The toggle is `CATCH_CONFIG_DISABLE_MATCHERS` and the only use is to speed up compilation of small TUs. For large ones it is likely insignificant, because the speed up is constant relative to number of tests/assertions in TU.
2017-07-28 21:34:34 +02:00
Fix inverted CATCH_CONFIG_DISABLE_MATCHERS toggle
2017-07-29 08:43:32 +02:00
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
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
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 )
Introduce compile time toggle to remove Matchers from TU The toggle is `CATCH_CONFIG_DISABLE_MATCHERS` and the only use is to speed up compilation of small TUs. For large ones it is likely insignificant, because the speed up is constant relative to number of tests/assertions in TU.
2017-07-28 21:34:34 +02:00
#endif // CATCH_CONFIG_DISABLE_MATCHERS
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 )
Add unscoped info functionality This adds UNSCOPED_INFO macro, creating a log message that is stored until the end of next assertion or the end of test case, whichever comes first. These messages are not scoped locally, unlike messages created by INFO macro.
2019-02-01 16:11:30 +01:00
#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
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 WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
CAPTURE is now variadic
2018-06-27 22:34:35 +02:00
#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
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__ )
Added DYNAMIC_SECTION and implemented GIVEN/ WHEN/ THEN in terms of it
2018-06-25 20:19:21 +02:00
#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_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__ )
Removed all (that I could find) redundant second macro args to TEST_CASE and SECTION - now we can rely on variadic macros
2017-07-13 10:20:37 +02:00
#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
First commit for GitHub
2010-11-10 00:24:00 +01:00
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
TEMPLATE_LIST_TEST_CASE implementation Closes #1627
2019-05-27 17:24:16 +02:00
#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#else
#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
TEMPLATE_LIST_TEST_CASE implementation Closes #1627
2019-05-27 17:24:16 +02:00
#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#endif
Add STATIC_REQUIRE assertion By default, it expands into a `static_assert` + `SUCCEED` pair, but it can also be deferred to runtime by defining `CATCH_CONFIG_RUNTIME_STATIC_REQUIRE`, which causes it to expand into plain old `REQUIRE`. Closes #1362 Closes #1356
2018-10-13 21:29:59 +02:00
#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
#define STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__, #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
#else
#define STATIC_REQUIRE( ... ) REQUIRE( __VA_ARGS__ )
#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
#endif
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
Add BDD AND_GIVEN based macros issue #1360 It is possible to have multple given contexts in a single BDD scenario; if you have to type 'and' in the GIVEN description; it's very likely you need an AND. A generic AND is not possible, thus a AND_GIVEN is added to complement the AND_WHEN and AND_THEN. Can be used without needing to increase indent: SCENARIO("...") { GIVEN("...") AND_GIVEN("...") { WHEN("...") { THEN("...") { // ... } } } } would correctly output, when requested/needed: Given: ... And given: ... When: ... Then: ... The padding had to be increased by a character in the output message, to continue to be uniform.
2018-08-14 11:49:55 +02:00
#define GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc )
#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
#define WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc )
#define AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
#define THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc )
#define AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc )
Added BDD macros (Also includes regenerated files from previous commits)
2013-03-13 13:19:30 +01:00
Various improvements to the benchmarking support * Units from <ratio> are no longer redeclared in our own namespace * The default clock is `steady_clock`, not `high_resolution_clock`, because, as HH says "high_resolution_clock is useless. If you want measure the passing of time, use steady_clock. If you want user friendly time, use system_clock". * Benchmarking support is opt-in, not opt-out, to avoid the large (~10%) compile time penalty. * Benchmarking-related options in CLI are always present, to decrease the amount of code that is only compiled conditionally and making the whole shebang more maintainble.
2019-05-19 20:54:44 +02:00
#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
Integrate Nonius benchmark into Catch2 Changes done to Nonius: * Moved things into "Catch::Benchmark" namespace * Benchmarks were integrated with `TEST_CASE`/`SECTION`/`GENERATE` macros * Removed Nonius's parameters for benchmarks, Generators should be used instead * Added relevant methods to the reporter interface (default-implemented, to avoid breaking existing 3rd party reporters) * Async processing is guarded with `_REENTRANT` macro for GCC/Clang, used by default on MSVC * Added a macro `CATCH_CONFIG_DISABLE_BENCHMARKING` that removes all traces of benchmarking from Catch
2019-04-23 23:41:13 +02:00
#define BENCHMARK(...) \
INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
#define BENCHMARK_ADVANCED(name) \
INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
Various improvements to the benchmarking support * Units from <ratio> are no longer redeclared in our own namespace * The default clock is `steady_clock`, not `high_resolution_clock`, because, as HH says "high_resolution_clock is useless. If you want measure the passing of time, use steady_clock. If you want user friendly time, use system_clock". * Benchmarking support is opt-in, not opt-out, to avoid the large (~10%) compile time penalty. * Benchmarking-related options in CLI are always present, to decrease the amount of code that is only compiled conditionally and making the whole shebang more maintainble.
2019-05-19 20:54:44 +02:00
#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
Integrate Nonius benchmark into Catch2 Changes done to Nonius: * Moved things into "Catch::Benchmark" namespace * Benchmarks were integrated with `TEST_CASE`/`SECTION`/`GENERATE` macros * Removed Nonius's parameters for benchmarks, Generators should be used instead * Added relevant methods to the reporter interface (default-implemented, to avoid breaking existing 3rd party reporters) * Async processing is guarded with `_REENTRANT` macro for GCC/Clang, used by default on MSVC * Added a macro `CATCH_CONFIG_DISABLE_BENCHMARKING` that removes all traces of benchmarking from Catch
2019-04-23 23:41:13 +02: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
Added DYNAMIC_SECTION to CATCH_CONFIG_DISABLE builds
2018-06-25 20:22:57 +02:00
#else // CATCH_CONFIG_DISABLE
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
//////
// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
#ifdef CATCH_CONFIG_PREFIX_ALL
#define CATCH_REQUIRE( ... ) (void)(0)
#define CATCH_REQUIRE_FALSE( ... ) (void)(0)
#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
#endif// CATCH_CONFIG_DISABLE_MATCHERS
#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
#define CATCH_CHECK( ... ) (void)(0)
#define CATCH_CHECK_FALSE( ... ) (void)(0)
#define CATCH_CHECKED_IF( ... ) if (__VA_ARGS__)
#define CATCH_CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
#define CATCH_CHECK_NOFAIL( ... ) (void)(0)
#define CATCH_CHECK_THROWS( ... ) (void)(0)
#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
#define CATCH_CHECK_THROWS_WITH( expr, matcher ) (void)(0)
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
#endif // CATCH_CONFIG_DISABLE_MATCHERS
#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
#define CATCH_CHECK_THAT( arg, matcher ) (void)(0)
#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
#endif // CATCH_CONFIG_DISABLE_MATCHERS
Add UNSCOPED_INFO to prefix/disabled sections
2019-04-24 21:51:21 +02:00
#define CATCH_INFO( msg ) (void)(0)
#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
#define CATCH_WARN( msg ) (void)(0)
#define CATCH_CAPTURE( msg ) (void)(0)
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
#define CATCH_METHOD_AS_TEST_CASE( method, ... )
#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
#define CATCH_SECTION( ... )
Added DYNAMIC_SECTION to CATCH_CONFIG_DISABLE builds
2018-06-25 20:22:57 +02:00
#define CATCH_DYNAMIC_SECTION( ... )
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
#define CATCH_FAIL( ... ) (void)(0)
#define CATCH_FAIL_CHECK( ... ) (void)(0)
#define CATCH_SUCCEED( ... ) (void)(0)
#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#else
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#endif
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
// "BDD-style" convenience wrappers
#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
#define CATCH_GIVEN( desc )
Add BDD AND_GIVEN based macros issue #1360 It is possible to have multple given contexts in a single BDD scenario; if you have to type 'and' in the GIVEN description; it's very likely you need an AND. A generic AND is not possible, thus a AND_GIVEN is added to complement the AND_WHEN and AND_THEN. Can be used without needing to increase indent: SCENARIO("...") { GIVEN("...") AND_GIVEN("...") { WHEN("...") { THEN("...") { // ... } } } } would correctly output, when requested/needed: Given: ... And given: ... When: ... Then: ... The padding had to be increased by a character in the output message, to continue to be uniform.
2018-08-14 11:49:55 +02:00
#define CATCH_AND_GIVEN( desc )
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
#define CATCH_WHEN( desc )
#define CATCH_AND_WHEN( desc )
#define CATCH_THEN( desc )
#define CATCH_AND_THEN( desc )
Add STATIC_REQUIRE assertion By default, it expands into a `static_assert` + `SUCCEED` pair, but it can also be deferred to runtime by defining `CATCH_CONFIG_RUNTIME_STATIC_REQUIRE`, which causes it to expand into plain old `REQUIRE`. Closes #1362 Closes #1356
2018-10-13 21:29:59 +02:00
#define CATCH_STATIC_REQUIRE( ... ) (void)(0)
#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
#else
#define REQUIRE( ... ) (void)(0)
#define REQUIRE_FALSE( ... ) (void)(0)
#define REQUIRE_THROWS( ... ) (void)(0)
#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
#endif // CATCH_CONFIG_DISABLE_MATCHERS
#define REQUIRE_NOTHROW( ... ) (void)(0)
#define CHECK( ... ) (void)(0)
#define CHECK_FALSE( ... ) (void)(0)
#define CHECKED_IF( ... ) if (__VA_ARGS__)
#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
#define CHECK_NOFAIL( ... ) (void)(0)
#define CHECK_THROWS( ... ) (void)(0)
#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
#endif // CATCH_CONFIG_DISABLE_MATCHERS
#define CHECK_NOTHROW( ... ) (void)(0)
#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
#define CHECK_THAT( arg, matcher ) (void)(0)
#define REQUIRE_THAT( arg, matcher ) (void)(0)
#endif // CATCH_CONFIG_DISABLE_MATCHERS
#define INFO( msg ) (void)(0)
Add UNSCOPED_INFO to prefix/disabled sections
2019-04-24 21:51:21 +02:00
#define UNSCOPED_INFO( msg ) (void)(0)
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
#define WARN( msg ) (void)(0)
#define CAPTURE( msg ) (void)(0)
#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
#define METHOD_AS_TEST_CASE( method, ... )
#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
#define SECTION( ... )
Added DYNAMIC_SECTION to CATCH_CONFIG_DISABLE builds
2018-06-25 20:22:57 +02:00
#define DYNAMIC_SECTION( ... )
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
#define FAIL( ... ) (void)(0)
#define FAIL_CHECK( ... ) (void)(0)
#define SUCCEED( ... ) (void)(0)
#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#else
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
Template tests: added TEMPLATE_PRODUCT_TEST_CASE support for generating test cases based on multiple template template types combined with template arguments for each of the template template types specified e.g. ``` TEMPLATE_PRODUCT_TEST_CASE("template product","[template]", (std::tuple, std::pair, std::map), ((int,float),(char,double),(int,char))) ``` will effectively create 9 test cases with types: std::tuple<int,float> std::tuple<char,double> std::tuple<int,char> std::pair<int,float> std::pair<char, double> std::pair<int,char> std::map<int,float> std::map<char,double> std::map<int,char> Tested type is accessible in test case body as TestType Unique name is created by appending ` - <index>` to test name since preprocessor has some limitations in recursions Closes #1454
2018-12-06 19:27:33 +01:00
#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
Nttp support Closes #1531
2019-04-17 20:23:24 +02:00
#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
Add support for templated tests This adds support for templated tests and test methods via `TEMPLATE_TEST_CASE` and `TEMPLATE_TEST_CASE_METHOD` macros. These work mostly just like their regular counterparts*, but take an unlimited** number of types as their last arguments. * Unlike the plain `TEST_CASE*` macros, the `TEMPLATE*` variants require a tag string. ** In practice there is limit of about 300 types.
2018-11-08 07:26:39 +01:00
#endif
Add STATIC_REQUIRE assertion By default, it expands into a `static_assert` + `SUCCEED` pair, but it can also be deferred to runtime by defining `CATCH_CONFIG_RUNTIME_STATIC_REQUIRE`, which causes it to expand into plain old `REQUIRE`. Closes #1362 Closes #1356
2018-10-13 21:29:59 +02:00
#define STATIC_REQUIRE( ... ) (void)(0)
#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
#endif
Prevent exception translator registration with CATCH_CONFIG_DISABLE
2017-08-29 09:52:25 +02:00
#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
// "BDD-style" convenience wrappers
#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ) )
#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
#define GIVEN( desc )
Add BDD AND_GIVEN based macros issue #1360 It is possible to have multple given contexts in a single BDD scenario; if you have to type 'and' in the GIVEN description; it's very likely you need an AND. A generic AND is not possible, thus a AND_GIVEN is added to complement the AND_WHEN and AND_THEN. Can be used without needing to increase indent: SCENARIO("...") { GIVEN("...") AND_GIVEN("...") { WHEN("...") { THEN("...") { // ... } } } } would correctly output, when requested/needed: Given: ... And given: ... When: ... Then: ... The padding had to be increased by a character in the output message, to continue to be uniform.
2018-08-14 11:49:55 +02:00
#define AND_GIVEN( desc )
Add partial implementation of CATCH_CONFIG_DISABLE * Assertions are defined into (void)(0) no-op * SECTIONs are defined away (leaving {} as scope) * TEST_CASEs and TEST_CASE_METHODs are not registered. * REGISTER_TEST_CASE is defined into (void)(0) no-op * METHOD_AS_TEST_CASE is defined away
2017-08-27 17:03:32 +02:00
#define WHEN( desc )
#define AND_WHEN( desc )
#define THEN( desc )
#define AND_THEN( desc )
using Catch::Detail::Approx;
#endif
Initial prototype of PCH support Related to #1061
2017-11-14 21:04:36 +01:00
#endif // ! CATCH_CONFIG_IMPL_ONLY
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