3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2024-11-30 01:03:30 +01:00
Code Issues Packages Projects Releases Wiki Activity

integrated AssertionHandler into INTERNAL_CATCH_NO_THROW

Browse Source
This commit is contained in:
Phil Nash 2017-08-08 19:36:18 +01:00
parent f247ce5bff
commit f033f4f184
3 changed files with 28 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
include/internal/catch_assertionhandler.cpp
View File

@ -59,24 +59,17 @@ namespace Catch {
getCurrentContext().getResultCapture()->assertionStarting( m_assertionInfo ); getCurrentContext().getResultCapture()->assertionStarting( m_assertionInfo );
} }
void AssertionHandler::handle( ITransientExpression const& expr ) { void AssertionHandler::handle( ResultWas::OfType resultType, ITransientExpression const* expr, bool negated ) {
bool negated = isFalseTest( m_assertionInfo.resultDisposition );
bool result = expr.getResult() != negated;
AssertionResultData data( result ? ResultWas::Ok : ResultWas::ExpressionFailed, LazyExpression( negated ) );
// Deprecated
// data.negated = negated;
// data.parenthesized = negated && expr.isBinaryExpression(); // !TBD: needed?
// data.decomposedExpression = nullptr; // !TBD
// data.reconstructedExpression = ""; // !TBD
AssertionResultData data( resultType, LazyExpression( negated ) );
handle( data, expr );
}
void AssertionHandler::handle( AssertionResultData const& resultData, ITransientExpression const* expr ) {
getResultCapture().assertionRun(); getResultCapture().assertionRun();
AssertionResult assertionResult{ m_assertionInfo, data }; AssertionResult assertionResult{ m_assertionInfo, resultData };
assertionResult.m_resultData.lazyExpression.m_transientExpression = &expr; assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
getResultCapture().assertionEnded( assertionResult ); getResultCapture().assertionEnded( assertionResult );
@ -87,6 +80,16 @@ namespace Catch {
(m_assertionInfo.resultDisposition & ResultDisposition::Normal); (m_assertionInfo.resultDisposition & ResultDisposition::Normal);
} }
} }
void AssertionHandler::handle( ITransientExpression const& expr ) {
bool negated = isFalseTest( m_assertionInfo.resultDisposition );
bool result = expr.getResult() != negated;
handle( result ? ResultWas::Ok : ResultWas::ExpressionFailed, &expr, negated );
}
void AssertionHandler::handle( ResultWas::OfType resultType ) {
handle( resultType, nullptr, false );
}
auto AssertionHandler::shouldDebugBreak() const -> bool { auto AssertionHandler::shouldDebugBreak() const -> bool {
return m_shouldDebugBreak; return m_shouldDebugBreak;
@ -116,20 +119,7 @@ namespace Catch {
AssertionResultData data( ResultWas::ThrewException, LazyExpression( negated ) ); AssertionResultData data( ResultWas::ThrewException, LazyExpression( negated ) );
data.message = Catch::translateActiveException(); data.message = Catch::translateActiveException();
//data.decomposedExpression = &expr; // for lazy reconstruction handle( data, nullptr );
AssertionResult result( m_assertionInfo, data );
getResultCapture().assertionEnded( result );
// !TBD: factor this out? handleResult()?
if( !result.isOk() ) {
if( getCurrentContext().getConfig()->shouldDebugBreak() )
m_shouldDebugBreak = true;
if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) )
m_shouldThrow = true;
}
} }
} // namespace Catch } // namespace Catch

4
include/internal/catch_assertionhandler.h
View File

@ -14,6 +14,7 @@
namespace Catch { namespace Catch {
struct TestFailureException{}; struct TestFailureException{};
struct AssertionResultData;
class LazyExpression { class LazyExpression {
friend class AssertionHandler; friend class AssertionHandler;
@ -48,6 +49,9 @@ namespace Catch {
void handle( ExprLhs<T> const& expr ) { void handle( ExprLhs<T> const& expr ) {
handle( expr.makeUnaryExpr() ); handle( expr.makeUnaryExpr() );
} }
void handle( ResultWas::OfType resultType );
void handle( ResultWas::OfType resultType, ITransientExpression const* expr, bool negated );
void handle( AssertionResultData const& resultData, ITransientExpression const* expr );
auto shouldDebugBreak() const -> bool; auto shouldDebugBreak() const -> bool;
void reactWithDebugBreak() const; void reactWithDebugBreak() const;

11
include/internal/catch_capture.hpp
View File

@ -51,6 +51,7 @@
#define INTERNAL_CATCH_TRY try #define INTERNAL_CATCH_TRY try
#define INTERNAL_CATCH_CATCH( capturer, disposition ) catch(...) { capturer.useActiveException( disposition ); } #define INTERNAL_CATCH_CATCH( capturer, disposition ) catch(...) { capturer.useActiveException( disposition ); }
#define INTERNAL_CATCH_CATCH2( capturer ) catch(...) { capturer.useActiveException(); }
#endif #endif
@ -62,7 +63,7 @@
CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
catchAssertionHandler.handle( Catch::Decomposer() <= __VA_ARGS__ ); \ catchAssertionHandler.handle( Catch::Decomposer() <= __VA_ARGS__ ); \
CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \ CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
} INTERNAL_CATCH_CATCH( catchAssertionHandler, resultDisposition ) \ } INTERNAL_CATCH_CATCH2( catchAssertionHandler ) \
INTERNAL_CATCH_REACT2( catchAssertionHandler ) \ INTERNAL_CATCH_REACT2( catchAssertionHandler ) \
} 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 } 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
// The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&. // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
@ -80,15 +81,15 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \ #define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
do { \ do { \
Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, #__VA_ARGS__, resultDisposition ); \ Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, #__VA_ARGS__, resultDisposition ); \
try { \ try { \
static_cast<void>(__VA_ARGS__); \ static_cast<void>(__VA_ARGS__); \
__catchResult.captureResult( Catch::ResultWas::Ok ); \ catchAssertionHandler.handle( Catch::ResultWas::Ok ); \
} \ } \
catch( ... ) { \ catch( ... ) { \
__catchResult.useActiveException( resultDisposition ); \ catchAssertionHandler.useActiveException(); \
} \ } \
INTERNAL_CATCH_REACT( __catchResult ) \ INTERNAL_CATCH_REACT2( catchAssertionHandler ) \
} while( Catch::alwaysFalse() ) } while( Catch::alwaysFalse() )
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////