catchorg/Catch2
1
0
Fork 1
mirror of https://github.com/catchorg/Catch2.git synced 2025-11-04 00:51:52 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
af661065007abe7fe3cafbdc986f581eb58add2a
Catch2/include/internal/catch_capture.hpp

193 lines
9.1 KiB
C++
Raw Normal View History

First commit for GitHub
2010-11-09 23:24:00 +00:00
/*
* Created by Phil on 18/10/2010.
* Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
*
* 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_CAPTURE_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
#include "catch_result_builder.h"
Changed the way info messages are handled. This fixes issue with SCOPED_INFO and makes output more readable. Needs some refactoring.
2013-02-02 19:58:04 +00:00
#include "catch_message.h"
Refactored more into Hub
2011-01-11 09:13:31 +00:00
#include "catch_interfaces_capture.h"
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 18:52:41 +00:00
#include "catch_debugger.h"
Factored Approx out into own file
2011-04-28 08:03:28 +01:00
#include "catch_common.h"
Renamed catch_tostring.hpp catch_tostring.h - in preparation for splitting implementation into catch_tostring.hpp
2014-04-23 06:51:58 +01:00
#include "catch_tostring.h"
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
#include "catch_interfaces_runner.h"
Changed relative #includes and made SourceLineInfo sortable (added < op)
2015-03-04 07:08:53 +00:00
#include "catch_compiler_capabilities.h"
Compiler capabilities clean-up - renamed CATCH_SFINAE -> CATCH_CONFIG_SFINAE - moved variadic macros detection into catch_compiler_capabilities.h
2013-04-22 08:19:17 +01:00
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
Move debug break out of tests, speeds up compilation time This is hidden behind CATCH_CONFIG_FAST_COMPILE
2017-02-14 15:35:12 +01:00
#if defined(CATCH_CONFIG_FAST_COMPILE)
///////////////////////////////////////////////////////////////////////////////
// We can speedup compilation significantly by breaking into debugger lower in
// the callstack, because then we don't have to expand CATCH_BREAK_INTO_DEBUGGER
// macro in each assertion
#define INTERNAL_CATCH_REACT( resultBuilder ) \
resultBuilder.react();
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
///////////////////////////////////////////////////////////////////////////////
// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
// macros.
// This can potentially cause false negative, if the test code catches
// the exception before it propagates back up to the runner.
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 13:22:39 +00:00
#define INTERNAL_CATCH_TEST_NO_TRY( macroName, resultDisposition, expr ) \
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
do { \
Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr, resultDisposition ); \
Rework of REQUIRE* changes in CATCH_CONFIG_FAST_COMPILE `ResultBuilder`s destructor now checks for exceptions, preventing false negatives. The speedup should remain the same give or take a tiny bit.
2017-03-29 21:12:06 +02:00
__catchResult.setExceptionGuard(); \
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
CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
( __catchResult <= expr ).endExpression(); \
CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
Rework of REQUIRE* changes in CATCH_CONFIG_FAST_COMPILE `ResultBuilder`s destructor now checks for exceptions, preventing false negatives. The speedup should remain the same give or take a tiny bit.
2017-03-29 21:12:06 +02:00
__catchResult.unsetExceptionGuard(); \
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
INTERNAL_CATCH_REACT( __catchResult ) \
} while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
// The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
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 13:22:39 +00:00
#define INTERNAL_CHECK_THAT_NO_TRY( macroName, matcher, resultDisposition, 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
do { \
Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg ", " #matcher, resultDisposition ); \
Rework of REQUIRE* changes in CATCH_CONFIG_FAST_COMPILE `ResultBuilder`s destructor now checks for exceptions, preventing false negatives. The speedup should remain the same give or take a tiny bit.
2017-03-29 21:12:06 +02:00
__catchResult.setExceptionGuard(); \
__catchResult.captureMatch( arg, matcher, #matcher ); \
__catchResult.unsetExceptionGuard(); \
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
INTERNAL_CATCH_REACT( __catchResult ) \
} while( Catch::alwaysFalse() )
Move debug break out of tests, speeds up compilation time This is hidden behind CATCH_CONFIG_FAST_COMPILE
2017-02-14 15:35:12 +01:00
#else
Some layout reformatting. I think everything is in my preferred style now
2011-02-03 20:00:46 +00:00
///////////////////////////////////////////////////////////////////////////////
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
// In the event of a failure works out if the debugger needs to be invoked
// and/or an exception thrown and takes appropriate action.
// This needs to be done as a macro so the debugger will stop in the user
// source code rather than in Catch library code
#define INTERNAL_CATCH_REACT( resultBuilder ) \
if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
Move debug break out of tests, speeds up compilation time This is hidden behind CATCH_CONFIG_FAST_COMPILE
2017-02-14 15:35:12 +01:00
resultBuilder.react();
#endif
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
Added ability to break into debugger on Windows and Mac
2010-12-27 20:49:19 +00:00
More AssertionResult refactoring
2012-10-24 21:59:47 +01:00
///////////////////////////////////////////////////////////////////////////////
Made INTERNAL_CATCH_TEST variadic so commas in assertions work
2017-04-26 16:10:18 +01:00
#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
do { \
Made INTERNAL_CATCH_TEST variadic so commas in assertions work
2017-04-26 16:10:18 +01:00
Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #__VA_ARGS__, resultDisposition ); \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
try { \
Suppress parentheses warnings on clang and gcc - should address #593, #528, #521, #496 (and possibly others)
2016-02-29 08:01:06 +00:00
CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
Made INTERNAL_CATCH_TEST variadic so commas in assertions work
2017-04-26 16:10:18 +01:00
( __catchResult <= __VA_ARGS__ ).endExpression(); \
push/pop warnings when disabling parentheses warnings within assertion (gcc/ clang)
2017-02-15 09:38:38 +00:00
CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
} \
catch( ... ) { \
CHECK no longer stops running SECTION on exception. This seems to be much closer to desired behaviour than the current one, where CHECK(false) lets the execution continue, but CHECK(<throws>) does not.
2017-01-15 20:28:02 +01:00
__catchResult.useActiveException( resultDisposition ); \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
} \
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
INTERNAL_CATCH_REACT( __catchResult ) \
Made INTERNAL_CATCH_TEST variadic so commas in assertions work
2017-04-26 16:10:18 +01:00
} while( Catch::isTrue( false && static_cast<bool>( !!(__VA_ARGS__) ) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
Revert "use sizeof(expr) for unevaluated syntax check" Using sizeof(expr) can trigger a compile-time error, "lambda expressions are not allowed in an unevaluated context", when passing expression containing lambda, like a std algorithm. This error is considered a standard defect, as it is meant to prevent lambdas in decltype or templates, but not in sizeof. This reverts commit 227598af47e4d46f06cfcc879f206eb34e681275.
2017-01-30 11:56:29 +01:00
// The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
First commit for GitHub
2010-11-09 23:24:00 +00:00
Added CHECKED_IF and CHECKED_ELSE
2012-02-10 08:30:13 +00:00
///////////////////////////////////////////////////////////////////////////////
More macros are now variadic Also added tests for them
2017-05-03 19:10:27 +02:00
#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
Implemented CHECK_NO_FAIL
2012-11-13 09:44:52 +00:00
if( Catch::getResultCapture().getLastResult()->succeeded() )
Added CHECKED_IF and CHECKED_ELSE
2012-02-10 08:30:13 +00:00
///////////////////////////////////////////////////////////////////////////////
More macros are now variadic Also added tests for them
2017-05-03 19:10:27 +02:00
#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
Implemented CHECK_NO_FAIL
2012-11-13 09:44:52 +00:00
if( !Catch::getResultCapture().getLastResult()->succeeded() )
Added CHECKED_IF and CHECKED_ELSE
2012-02-10 08:30:13 +00:00
Fixed exception check regression
2011-03-14 08:45:55 +00:00
///////////////////////////////////////////////////////////////////////////////
More macros are now variadic Also added tests for them
2017-05-03 19:10:27 +02:00
#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
do { \
More macros are now variadic Also added tests for them
2017-05-03 19:10:27 +02:00
Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #__VA_ARGS__, resultDisposition ); \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
try { \
More macros are now variadic Also added tests for them
2017-05-03 19:10:27 +02:00
static_cast<void>(__VA_ARGS__); \
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
__catchResult.captureResult( Catch::ResultWas::Ok ); \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
} \
catch( ... ) { \
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
__catchResult.useActiveException( resultDisposition ); \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
} \
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
INTERNAL_CATCH_REACT( __catchResult ) \
} while( Catch::alwaysFalse() )
Fixed exception check regression
2011-03-14 08:45:55 +00:00
Some layout reformatting. I think everything is in my preferred style now
2011-02-03 20:00:46 +00:00
///////////////////////////////////////////////////////////////////////////////
More macros are now variadic Also added tests for them
2017-05-03 19:10:27 +02:00
#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, matcher, ... ) \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
do { \
More macros are now variadic Also added tests for them
2017-05-03 19:10:27 +02:00
Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #__VA_ARGS__, resultDisposition, #matcher ); \
Fixed regression with -e
2014-06-05 18:11:31 +01:00
if( __catchResult.allowThrows() ) \
try { \
More macros are now variadic Also added tests for them
2017-05-03 19:10:27 +02:00
static_cast<void>(__VA_ARGS__); \
Fixed regression with -e
2014-06-05 18:11:31 +01:00
__catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
} \
catch( ... ) { \
Exception message assertions now work with matchers
2015-07-15 23:02:25 +01:00
__catchResult.captureExpectedException( matcher ); \
Fixed regression with -e
2014-06-05 18:11:31 +01:00
} \
else \
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
__catchResult.captureResult( Catch::ResultWas::Ok ); \
INTERNAL_CATCH_REACT( __catchResult ) \
} while( Catch::alwaysFalse() )
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
Some layout reformatting. I think everything is in my preferred style now
2011-02-03 20:00:46 +00: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 13:22:39 +00:00
#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
do { \
REQUIRE_THROWS_AS is now reported with expected type as well Also updated tests to reflect this change.
2017-02-09 12:41:16 +01:00
Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr ", " #exceptionType, resultDisposition ); \
Fixed regression with -e
2014-06-05 18:11:31 +01:00
if( __catchResult.allowThrows() ) \
try { \
expr is now cast to void in THROWS family of assertions. This prevents Clang from complaining about unused value in expressions containing explicit casts used in the THROW assertion macro family. Example: `REQUIRE_THROWS_AS(static_cast<bool>(object), std::bad_cast);` would trigger `-Wunused-value` warning. Now it does not. Credits to Arto Bendiken, who submitted a PR almost 3 years ago, but his branch has since died and I was unable to merge it.
2017-01-31 18:02:11 +01:00
static_cast<void>(expr); \
Fixed regression with -e
2014-06-05 18:11:31 +01:00
__catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
} \
Don't sanitize exception type in REQUIRE_THROWS_AS Effectively a revert of previous commit, fixing #542, where this was added to stop linters complaining about `REQUIRE_THROWS_AS` used like `REQUIRE_THROWS_AS(expr, std::exception);`, which would be slicing the caught exception. Now it is user's responsibility to pass us proper exception type. Closes #833 which wanted to add `typename`, so that the construct works in a template, but that would not work with MSVC and older GCC's, as having `typename` outside of a template is allowed only from C++11 onward.
2017-03-23 21:11:21 +01:00
catch( exceptionType ) { \
Fixed regression with -e
2014-06-05 18:11:31 +01:00
__catchResult.captureResult( Catch::ResultWas::Ok ); \
} \
catch( ... ) { \
__catchResult.useActiveException( resultDisposition ); \
} \
else \
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
__catchResult.captureResult( Catch::ResultWas::Ok ); \
INTERNAL_CATCH_REACT( __catchResult ) \
} while( Catch::alwaysFalse() )
First commit for GitHub
2010-11-09 23:24:00 +00:00
Changed the way info messages are handled. This fixes issue with SCOPED_INFO and makes output more readable. Needs some refactoring.
2013-02-02 19:58:04 +00: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 13:22:39 +00:00
#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
Allow FAIL() to be empty
2013-12-12 23:02:31 +00:00
do { \
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
Folded ExpressionResultBuilder into ResultBuilder (even more SRP violations!)
2014-05-29 07:50:19 +01:00
__catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
__catchResult.captureResult( messageType ); \
INTERNAL_CATCH_REACT( __catchResult ) \
} while( Catch::alwaysFalse() )
First commit for GitHub
2010-11-09 23:24:00 +00:00
Some layout reformatting. I think everything is in my preferred style now
2011-02-03 20:00:46 +00: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 13:22:39 +00:00
#define INTERNAL_CATCH_INFO( macroName, log ) \
INFO and CAPTURE are now scoped - SCOPED_INFO and SCOPED_CAPTURE are now just aliases
2013-06-28 17:09:57 +01:00
Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;
Changed the way info messages are handled. This fixes issue with SCOPED_INFO and makes output more readable. Needs some refactoring.
2013-02-02 19:58:04 +00:00
First cut of Matcher support
2012-03-04 11:14:21 +00: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 13:22:39 +00:00
#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
do { \
Add missing comma when in captured expression for matchers Such that CHECK_THAT( hex_encode(outbuf) Equals("B5D4045C") ) becomes CHECK_THAT( hex_encode(outbuf), Equals("B5D4045C") )
2015-08-08 00:15:58 +02:00
Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #arg ", " #matcher, resultDisposition ); \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
try { \
lazily stringify expressions
2017-01-09 13:23:10 +01:00
__catchResult.captureMatch( arg, matcher, #matcher ); \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
} catch( ... ) { \
Fix erroneous result disposition for {REQUIRE,CHECK}_THAT This fixes result disposition being ContinueOnFailure | ContinueOnFailure for CHECK_THAT (obviously an error) and Normal | ContinueOnFailure for REQUIRE_THAT (less obviously an error, but worse, as that signals to the pipeline that assertion failure should both abort and continue the test with ???? happening).
2017-06-06 15:12:03 +02:00
__catchResult.useActiveException( resultDisposition ); \
Fixed remaining reporting regressions
2012-10-29 19:55:13 +00:00
} \
Big assertion capture refactoring. - moved as much logic out of the macros as possible - moved most logic into new ResultBuilder class, which wraps ExpressionResultBuilder (may take it over next), subsumes ResultAction and also takes place of ExpressionDecomposer. This introduces many SRP violations - but all in the name of minimising macro logic!
2014-05-28 18:53:01 +01:00
INTERNAL_CATCH_REACT( __catchResult ) \
} while( Catch::alwaysFalse() )
First cut of Matcher support
2012-03-04 11:14:21 +00:00
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 INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, expr ) \
do { \
Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #expr ", " #exceptionType, resultDisposition, #matcher ); \
if( __catchResult.allowThrows() ) \
try { \
static_cast<void>(expr); \
__catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
} \
catch( exceptionType ex ) { \
__catchResult.captureMatch( ex, matcher, #matcher ); \
} \
catch( ... ) { \
__catchResult.useActiveException( resultDisposition ); \
} \
else \
__catchResult.captureResult( Catch::ResultWas::Ok ); \
INTERNAL_CATCH_REACT( __catchResult ) \
} while( Catch::alwaysFalse() )
First commit for GitHub
2010-11-09 23:24:00 +00:00
#endif // TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
Reference in New Issue Copy Permalink