feedc0de/Catch2
1
0
Fork 0
forked from catchorg/Catch2
Code Pull Requests Activity
Files
820b1f12bf04a5df1ac86893cecee67dcfb4a607
Catch2/include/internal/catch_capture_matchers.h

88 lines
3.7 KiB
C
Raw Normal View History

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 12:10:14 +01:00
/*
* Created by Phil on 9/8/2017
* Copyright 2017 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_MATCHERS_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_CAPTURE_MATCHERS_HPP_INCLUDED
#include "catch_capture.hpp"
Changed all .hpp extensions to .h where there is now a corresponding .cpp
2017-09-07 11:24:33 +01:00
#include "catch_matchers.h"
Add ULP and margin matcher Closes #1074
2017-11-10 18:14:42 +01:00
#include "catch_matchers_floating.h"
Add PredicateMatcher that takes an arbitrary predicate functions Also adds `Predicate` helper function to create `PredicateMatcher`. Because of limitations in type inference it needs to be explicitly typed, like so `Predicate<std::string>([](std::string const& str) { ... })`. It also takes an optional second argument for description of the predicate. It is possible to infer the argument with sufficient TMP, see https://stackoverflow.com/questions/43560492/how-to-extract-lambdas-return-type-and-variadic-parameters-pack-back-from-gener/43561563#43561563 but I don't think that the magic is worth introducing ATM. Closes #1236
2018-04-03 23:28:14 +02:00
#include "catch_matchers_generic.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 12:10:14 +01:00
#include "catch_matchers_string.h"
Don't include string/ vector matchers if CATCH_CONFIG_MATCHERS defined
2017-08-16 14:37:54 +01:00
#include "catch_matchers_vector.h"
Construct StringRef from constant strings in macros directly using UDL This avoids having to call `strlen` to get the constant string's length and thus should improve performance.
2018-07-23 13:55:14 +02:00
#include "catch_stringref.h"
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 12:10:14 +01:00
namespace Catch {
template<typename ArgT, typename MatcherT>
class MatchExpr : public ITransientExpression {
ArgT const& m_arg;
MatcherT m_matcher;
StringRef m_matcherString;
public:
Avoid copying StringRef In theory the copy is cheap (couple of pointers change), but tests are usually compiled in Debug mode/with minimal optimizations, which means that most users will still have to pay the cost for those function calls.
2018-07-23 13:49:29 +02:00
MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
De-virtualised isBinaryExpression() and getResult() on ITransientExpression
2017-11-27 22:49:26 +03:00
: ITransientExpression{ true, matcher.match( arg ) },
m_arg( arg ),
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 12:10:14 +01:00
m_matcher( matcher ),
De-virtualised isBinaryExpression() and getResult() on ITransientExpression
2017-11-27 22:49:26 +03:00
m_matcherString( matcherString )
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 12:10:14 +01:00
{}
void streamReconstructedExpression( std::ostream &os ) const override {
auto matcherAsString = m_matcher.toString();
os << Catch::Detail::stringify( m_arg ) << ' ';
if( matcherAsString == Detail::unprintableString )
Removed redundant .c_str()s from StringRef usages
2017-08-14 08:54:57 +01:00
os << m_matcherString;
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 12:10:14 +01:00
else
os << matcherAsString;
}
};
using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
Avoid copying StringRef In theory the copy is cheap (couple of pointers change), but tests are usually compiled in Debug mode/with minimal optimizations, which means that most users will still have to pay the cost for those function calls.
2018-07-23 13:49:29 +02:00
void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString );
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 12:10:14 +01:00
template<typename ArgT, typename MatcherT>
Avoid copying StringRef In theory the copy is cheap (couple of pointers change), but tests are usually compiled in Debug mode/with minimal optimizations, which means that most users will still have to pay the cost for those function calls.
2018-07-23 13:49:29 +02:00
auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString ) -> MatchExpr<ArgT, MatcherT> {
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 12:10:14 +01:00
return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
}
} // namespace Catch
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
do { \
Construct StringRef from constant strings in macros directly using UDL This avoids having to call `strlen` to get the constant string's length and thus should improve performance.
2018-07-23 13:55:14 +02:00
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
Bake exception guard into assertion handler flow
2017-11-23 16:52:46 +00:00
INTERNAL_CATCH_TRY { \
Construct StringRef from constant strings in macros directly using UDL This avoids having to call `strlen` to get the constant string's length and thus should improve performance.
2018-07-23 13:55:14 +02:00
catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
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 12:10:14 +01:00
} INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
INTERNAL_CATCH_REACT( catchAssertionHandler ) \
Remove isTrue, alwaysTrue, alwaysFalse isTrue and alwaysFalse were replaced by (void)0, 0 inspired by doctest alwaysTrue was replaced by warning suppression
2017-11-21 21:39:40 +01:00
} while( false )
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 12:10:14 +01:00
///////////////////////////////////////////////////////////////////////////////
#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
do { \
Construct StringRef from constant strings in macros directly using UDL This avoids having to call `strlen` to get the constant string's length and thus should improve performance.
2018-07-23 13:55:14 +02:00
Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
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 12:10:14 +01:00
if( catchAssertionHandler.allowThrows() ) \
try { \
static_cast<void>(__VA_ARGS__ ); \
Refactored most handle() calls to more specific/ descriptive calls
2017-11-24 19:15:46 +00:00
catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
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 12:10:14 +01:00
} \
catch( exceptionType const& ex ) { \
Construct StringRef from constant strings in macros directly using UDL This avoids having to call `strlen` to get the constant string's length and thus should improve performance.
2018-07-23 13:55:14 +02:00
catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
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 12:10:14 +01:00
} \
catch( ... ) { \
Refactored most handle() calls to more specific/ descriptive calls
2017-11-24 19:15:46 +00:00
catchAssertionHandler.handleUnexpectedInflightException(); \
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 12:10:14 +01:00
} \
else \
Refactored most handle() calls to more specific/ descriptive calls
2017-11-24 19:15:46 +00:00
catchAssertionHandler.handleThrowingCallSkipped(); \
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 12:10:14 +01:00
INTERNAL_CATCH_REACT( catchAssertionHandler ) \
Remove isTrue, alwaysTrue, alwaysFalse isTrue and alwaysFalse were replaced by (void)0, 0 inspired by doctest alwaysTrue was replaced by warning suppression
2017-11-21 21:39:40 +01:00
} while( false )
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 12:10:14 +01:00
#endif // TWOBLUECUBES_CATCH_CAPTURE_MATCHERS_HPP_INCLUDED
Copy Permalink