catch_amalgamated.hpp File Reference

#include <type_traits>
#include <string>
#include <cstddef>
#include <iosfwd>
#include <cassert>
#include <cstring>
#include <chrono>
#include <vector>
#include <algorithm>
#include <cmath>
#include <exception>
#include <ostream>
#include <ctime>
#include <ratio>
#include <cstdint>
#include <map>
#include <memory>
#include <sstream>
#include <tuple>
#include <climits>

Include dependency graph for catch_amalgamated.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	Catch::Context
struct	Catch::TestFailureException
	Used to signal that an assertion macro failed. More...
struct	Catch::TestSkipException
	Used to signal that the remainder of a test should be skipped. More...
class	Catch::StringRef
struct	Catch::ResultWas
struct	Catch::ResultDisposition
class	Catch::Detail::unique_ptr< T >
class	Catch::IResultCapture
class	Catch::Detail::NonCopyable
	Deriving classes become noncopyable and nonmovable. More...
struct	Catch::WarnAbout
struct	Catch::WaitForKeypress
class	Catch::IConfig
class	Catch::IRegistryHub
class	Catch::IMutableRegistryHub
struct	Catch::Benchmark::Estimate< Type >
struct	Catch::Benchmark::OutlierClassification
struct	Catch::BenchmarkInfo
struct	Catch::BenchmarkStats< Dummy >
struct	Catch::Benchmark::EnvironmentEstimate
struct	Catch::Benchmark::Environment
struct	Catch::true_given< typename >
struct	Catch::is_callable_tester
struct	Catch::is_callable< Fun(Args...)>
struct	Catch::Benchmark::Detail::ChronometerConcept
struct	Catch::Benchmark::Detail::ChronometerModel< Clock >
struct	Catch::Benchmark::Chronometer
struct	Catch::Benchmark::Detail::is_related< T, U >
struct	Catch::Benchmark::Detail::BenchmarkFunction
struct	Catch::Benchmark::Detail::BenchmarkFunction::callable
struct	Catch::Benchmark::Detail::BenchmarkFunction::model< Fun >
struct	Catch::Benchmark::Detail::repeater< Fun >
struct	Catch::Benchmark::Detail::CompleteType< T >
struct	Catch::Benchmark::Detail::CompleteType< void >
struct	Catch::Benchmark::Detail::CompleteType< void >::type
struct	Catch::Benchmark::Detail::CompleteInvoker< Result >
struct	Catch::Benchmark::Detail::CompleteInvoker< void >
struct	Catch::Benchmark::Timing< Result >
struct	Catch::Benchmark::ExecutionPlan
struct	Catch::Benchmark::Detail::bootstrap_analysis
struct	Catch::Benchmark::SampleAnalysis
struct	Catch::Benchmark::Benchmark
struct	Catch::Benchmark::Detail::ObjectStorage< T, Destruct >
class	Catch::ReusableStringStream
struct	Catch::Detail::make_void<... >
struct	Catch::Detail::EnumInfo
class	Catch::IMutableEnumValuesRegistry
struct	Catch_global_namespace_dummy
class	Catch::Detail::IsStreamInsertable< T >
struct	Catch::StringMaker< T, typename >
struct	Catch::StringMaker< std::string >
struct	Catch::StringMaker< char const * >
struct	Catch::StringMaker< char * >
struct	Catch::StringMaker< std::wstring >
struct	Catch::StringMaker< wchar_t const * >
struct	Catch::StringMaker< wchar_t * >
struct	Catch::StringMaker< char[SZ]>
struct	Catch::StringMaker< signed char[SZ]>
struct	Catch::StringMaker< unsigned char[SZ]>
struct	Catch::StringMaker< int >
struct	Catch::StringMaker< long >
struct	Catch::StringMaker< long long >
struct	Catch::StringMaker< unsigned int >
struct	Catch::StringMaker< unsigned long >
struct	Catch::StringMaker< unsigned long long >
struct	Catch::StringMaker< bool >
struct	Catch::StringMaker< char >
struct	Catch::StringMaker< signed char >
struct	Catch::StringMaker< unsigned char >
struct	Catch::StringMaker< std::nullptr_t >
struct	Catch::StringMaker< float >
struct	Catch::StringMaker< double >
struct	Catch::StringMaker< T * >
struct	Catch::StringMaker< R C::* >
struct	Catch::Detail::is_range_impl< T, typename >
struct	Catch::Detail::is_range_impl< T, void_t< decltype(begin(std::declval< T >()))> >
struct	Catch::is_range< T >
struct	Catch::StringMaker< R, std::enable_if_t< is_range< R >::value &&!::Catch::Detail::IsStreamInsertable< R >::value > >
struct	Catch::StringMaker< T[SZ]>
struct	Catch::ratio_string< Ratio >
struct	Catch::ratio_string< std::atto >
struct	Catch::ratio_string< std::femto >
struct	Catch::ratio_string< std::pico >
struct	Catch::ratio_string< std::nano >
struct	Catch::ratio_string< std::micro >
struct	Catch::ratio_string< std::milli >
struct	Catch::StringMaker< std::chrono::duration< Value, Ratio > >
struct	Catch::StringMaker< std::chrono::duration< Value, std::ratio< 1 > > >
struct	Catch::StringMaker< std::chrono::duration< Value, std::ratio< 60 > > >
struct	Catch::StringMaker< std::chrono::duration< Value, std::ratio< 3600 > > >
struct	Catch::StringMaker< std::chrono::time_point< Clock, Duration > >
struct	Catch::StringMaker< std::chrono::time_point< std::chrono::system_clock, Duration > >
class	Catch::Approx
struct	Catch::StringMaker< Catch::Approx >
struct	Catch::SourceLineInfo
struct	Catch::AssertionInfo
class	Catch::LazyExpression
struct	Catch::AssertionResultData
class	Catch::AssertionResult
class	Catch::WildcardPattern
class	Catch::TestSpec
class	Catch::TestSpec::Pattern
class	Catch::TestSpec::NamePattern
class	Catch::TestSpec::TagPattern
struct	Catch::TestSpec::Filter
struct	Catch::TestSpec::FilterMatch
class	Catch::Optional< T >
class	Catch::ReporterSpec
struct	Catch::ProcessedReporterSpec
struct	Catch::ConfigData
class	Catch::Config
struct	Catch::StreamEndStop
struct	Catch::MessageInfo
struct	Catch::MessageStream
struct	Catch::MessageBuilder
class	Catch::ScopedMessage
class	Catch::Capturer
struct	Catch::Counts
struct	Catch::Totals
struct	Catch::SectionInfo
struct	Catch::SectionEndInfo
struct	Catch::Clara::accept_many_t
struct	Catch::Clara::Detail::fake_arg
struct	Catch::Clara::Detail::is_unary_function< F, typename >
struct	Catch::Clara::Detail::is_unary_function< F, Catch::Detail::void_t< decltype(std::declval< F >()(fake_arg())) > >
struct	Catch::Clara::Detail::UnaryLambdaTraits< L >
struct	Catch::Clara::Detail::UnaryLambdaTraits< ReturnT(ClassT::*)(Args...) const >
struct	Catch::Clara::Detail::UnaryLambdaTraits< ReturnT(ClassT::*)(ArgT) const >
struct	Catch::Clara::Detail::Token
class	Catch::Clara::Detail::TokenStream
class	Catch::Clara::Detail::ResultBase
class	Catch::Clara::Detail::ResultValueBase< T >
class	Catch::Clara::Detail::ResultValueBase< void >
class	Catch::Clara::Detail::BasicResult< T >
class	Catch::Clara::Detail::ParseState
struct	Catch::Clara::Detail::HelpColumns
struct	Catch::Clara::Detail::BoundRef
struct	Catch::Clara::Detail::BoundValueRefBase
struct	Catch::Clara::Detail::BoundFlagRefBase
struct	Catch::Clara::Detail::BoundValueRef< T >
struct	Catch::Clara::Detail::BoundValueRef< std::vector< T > >
struct	Catch::Clara::Detail::BoundFlagRef
struct	Catch::Clara::Detail::LambdaInvoker< ReturnType >
struct	Catch::Clara::Detail::LambdaInvoker< void >
struct	Catch::Clara::Detail::BoundLambda< L >
struct	Catch::Clara::Detail::BoundManyLambda< L >
struct	Catch::Clara::Detail::BoundFlagLambda< L >
class	Catch::Clara::Detail::ParserBase
class	Catch::Clara::Detail::ComposableParserImpl< DerivedT >
class	Catch::Clara::Detail::ParserRefImpl< DerivedT >
class	Catch::Clara::Arg
class	Catch::Clara::Opt
class	Catch::Clara::ExeName
class	Catch::Clara::Parser
class	Catch::Clara::Args
struct	Catch::Clara::Help
class	Catch::Session
struct	Catch::TagAlias
struct	Catch::RegistrarForTagAliases
struct	Catch::Detail::conjunction<... >
struct	Catch::Detail::conjunction< B1 >
struct	Catch::Detail::conjunction< B1, Bn... >
struct	Catch::Detail::disjunction<... >
struct	Catch::Detail::disjunction< B1 >
struct	Catch::Detail::disjunction< B1, Bn... >
struct	Catch::Detail::negation< B >
struct	Catch::capture_by_value< T >
struct	Catch::always_false< T >
class	Catch::ITransientExpression
class	Catch::BinaryExpr< LhsT, RhsT >
class	Catch::UnaryExpr< LhsT >
class	Catch::ExprLhs< LhsT >
struct	Catch::Decomposer
struct	Catch::AssertionReaction
class	Catch::AssertionHandler
class	Catch::Timer
class	Catch::Section
class	Catch::ITestInvoker
class	Catch::TestInvokerAsMethod< C >
class	Catch::TestInvokerFixture< C >
struct	Catch::NameAndTags
struct	Catch::AutoReg
struct	Catch::Tag
struct	Catch::TestCaseInfo
class	Catch::TestCaseHandle
class	Catch::IExceptionTranslator
class	Catch::IExceptionTranslatorRegistry
class	Catch::ExceptionTranslatorRegistrar
class	Catch::ExceptionTranslatorRegistrar::ExceptionTranslator< T >
struct	Catch::Version
class	Catch::GeneratorException
class	Catch::Generators::GeneratorUntypedBase
class	Catch::IGeneratorTracker
class	Catch::Generators::IGenerator< T >
class	Catch::Generators::GeneratorWrapper< T >
class	Catch::Generators::SingleValueGenerator< T >
class	Catch::Generators::FixedValuesGenerator< T >
class	Catch::Generators::Generators< T >
struct	Catch::Generators::as< T >
class	Catch::Generators::TakeGenerator< T >
class	Catch::Generators::FilterGenerator< T, Predicate >
class	Catch::Generators::RepeatGenerator< T >
class	Catch::Generators::MapGenerator< T, U, Func >
class	Catch::Generators::ChunkGenerator< T >
class	Catch::SimplePcg32

Namespaces
namespace	Catch
namespace	Catch::Detail
namespace	Catch::Benchmark
namespace	Catch::Generators
namespace	mpl_
namespace	Catch::Benchmark::Detail
namespace	Catch::literals
namespace	Catch::Clara
namespace	Catch::Clara::Detail
namespace	Catch::Generators::Detail

Macros
#define	CATCH_ALL_HPP_INCLUDED
#define	CATCH_BENCHMARK_ALL_HPP_INCLUDED
#define	CATCH_BENCHMARK_HPP_INCLUDED
#define	CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
#define	CATCH_PLATFORM_HPP_INCLUDED
#define	CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
#define	CATCH_INTERNAL_CONFIG_GETENV
#define	CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
#define	CATCH_CONFIG_POSIX_SIGNALS
#define	CATCH_CONFIG_GETENV
#define	CATCH_CONFIG_CPP11_TO_STRING
#define	CATCH_CONFIG_DISABLE_EXCEPTIONS
#define	CATCH_CONFIG_GLOBAL_NEXTAFTER
#define	CATCH_INTERNAL_IGNORE_BUT_WARN(...)
#define	CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
#define	CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
#define	CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
#define	CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
#define	CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT
#define	CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
#define	CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS
#define	CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
#define	CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#define	CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
#define	CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
#define	CATCH_TRY   if ((true))
#define	CATCH_CATCH_ALL   if ((false))
#define	CATCH_CATCH_ANON(type)
#define	CATCH_EXPORT
#define	CATCH_CONTEXT_HPP_INCLUDED
#define	CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
#define	CATCH_MOVE(...)
	Replacement for std::move with better compile time performance.
#define	CATCH_FORWARD(...)
	Replacement for std::forward with better compile time performance.
#define	CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
#define	CATCH_UNIQUE_NAME_HPP_INCLUDED
#define	CATCH_CONFIG_COUNTER_HPP_INCLUDED
#define	CATCH_INTERNAL_CONFIG_COUNTER
#define	CATCH_CONFIG_COUNTER
#define	INTERNAL_CATCH_UNIQUE_NAME_LINE2(name, line)
#define	INTERNAL_CATCH_UNIQUE_NAME_LINE(name, line)
#define	INTERNAL_CATCH_UNIQUE_NAME(name)
#define	CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
#define	CATCH_STRINGREF_HPP_INCLUDED
#define	CATCH_RESULT_TYPE_HPP_INCLUDED
#define	CATCH_UNIQUE_PTR_HPP_INCLUDED
#define	CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
#define	CATCH_CLOCK_HPP_INCLUDED
#define	CATCH_INTERFACES_CONFIG_HPP_INCLUDED
#define	CATCH_NONCOPYABLE_HPP_INCLUDED
#define	CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
#define	CATCH_BENCHMARK_STATS_HPP_INCLUDED
#define	CATCH_ESTIMATE_HPP_INCLUDED
#define	CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
#define	CATCH_ENVIRONMENT_HPP_INCLUDED
#define	CATCH_EXECUTION_PLAN_HPP_INCLUDED
#define	CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
#define	CATCH_CHRONOMETER_HPP_INCLUDED
#define	CATCH_OPTIMIZER_HPP_INCLUDED
#define	CATCH_META_HPP_INCLUDED
#define	CATCH_REPEAT_HPP_INCLUDED
#define	CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
#define	CATCH_MEASURE_HPP_INCLUDED
#define	CATCH_COMPLETE_INVOKE_HPP_INCLUDED
#define	CATCH_TIMING_HPP_INCLUDED
#define	CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
#define	CATCH_STATS_HPP_INCLUDED
#define	CATCH_ANALYSE_HPP_INCLUDED
#define	CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
#define	INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...)
#define	INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...)
#define	INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)
#define	INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)
#define	BENCHMARK(...)
#define	BENCHMARK_ADVANCED(name)
#define	CATCH_CONSTRUCTOR_HPP_INCLUDED
#define	CATCH_APPROX_HPP_INCLUDED
#define	CATCH_TOSTRING_HPP_INCLUDED
#define	CATCH_CONFIG_WCHAR_HPP_INCLUDED
#define	CATCH_CONFIG_WCHAR
#define	CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
#define	CATCH_VOID_TYPE_HPP_INCLUDED
#define	CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
#define	INTERNAL_CATCH_REGISTER_ENUM(enumName, ...)
#define	CATCH_REGISTER_ENUM(enumName, ...)
#define	CATCH_ASSERTION_INFO_HPP_INCLUDED
#define	CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
#define	CATCH_INTERNAL_LINEINFO    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
#define	CATCH_ASSERTION_RESULT_HPP_INCLUDED
#define	CATCH_LAZY_EXPR_HPP_INCLUDED
#define	CATCH_CASE_SENSITIVE_HPP_INCLUDED
#define	CATCH_CONFIG_HPP_INCLUDED
#define	CATCH_TEST_SPEC_HPP_INCLUDED
#define	CATCH_WILDCARD_PATTERN_HPP_INCLUDED
#define	CATCH_OPTIONAL_HPP_INCLUDED
#define	CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
#define	CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
#define	CATCH_GET_RANDOM_SEED_HPP_INCLUDED
#define	CATCH_MESSAGE_HPP_INCLUDED
#define	CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
#define	CATCH_STREAM_END_STOP_HPP_INCLUDED
#define	CATCH_MESSAGE_INFO_HPP_INCLUDED
#define	INTERNAL_CATCH_MSG(macroName, messageType, resultDisposition, ...)
#define	INTERNAL_CATCH_CAPTURE(varName, macroName, ...)
#define	INTERNAL_CATCH_INFO(macroName, log)
#define	INTERNAL_CATCH_UNSCOPED_INFO(macroName, log)
#define	INFO(msg)
#define	UNSCOPED_INFO(msg)
#define	WARN(msg)
#define	CAPTURE(...)
#define	CATCH_SECTION_INFO_HPP_INCLUDED
#define	CATCH_TOTALS_HPP_INCLUDED
#define	CATCH_SESSION_HPP_INCLUDED
#define	CATCH_COMMANDLINE_HPP_INCLUDED
#define	CATCH_CLARA_HPP_INCLUDED
#define	CATCH_TAG_ALIAS_HPP_INCLUDED
#define	CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
#define	CATCH_REGISTER_TAG_ALIAS(alias, spec)
#define	CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
#define	CATCH_TEST_MACROS_HPP_INCLUDED
#define	CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
#define	CATCH_ASSERTION_HANDLER_HPP_INCLUDED
#define	CATCH_DECOMPOSER_HPP_INCLUDED
#define	CATCH_COMPARE_TRAITS_HPP_INCLUDED
#define	CATCH_DEFINE_COMPARABLE_TRAIT(id, op)
#define	CATCH_LOGICAL_TRAITS_HPP_INCLUDED
#define	CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR(id, op)
#define	CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR(id, op)
#define	CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(op)
#define	CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
#define	CATCH_INTERNAL_STRINGIFY(...)
#define	INTERNAL_CATCH_TRY
#define	INTERNAL_CATCH_CATCH(capturer)
#define	INTERNAL_CATCH_TEST(macroName, resultDisposition, ...)
#define	INTERNAL_CATCH_IF(macroName, resultDisposition, ...)
#define	INTERNAL_CATCH_ELSE(macroName, resultDisposition, ...)
#define	INTERNAL_CATCH_NO_THROW(macroName, resultDisposition, ...)
#define	INTERNAL_CATCH_THROWS(macroName, resultDisposition, ...)
#define	INTERNAL_CATCH_THROWS_AS(macroName, exceptionType, resultDisposition, expr)
#define	INTERNAL_CATCH_THROWS_STR_MATCHES(macroName, resultDisposition, matcher, ...)
#define	CATCH_SECTION_HPP_INCLUDED
#define	CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
#define	CATCH_TIMER_HPP_INCLUDED
#define	INTERNAL_CATCH_SECTION(...)
#define	INTERNAL_CATCH_DYNAMIC_SECTION(...)
#define	CATCH_TEST_REGISTRY_HPP_INCLUDED
#define	CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
#define	CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
#define	INTERNAL_CATCH_EXPAND1(param)
#define	INTERNAL_CATCH_EXPAND2(...)
#define	INTERNAL_CATCH_DEF(...)
#define	INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
#define	INTERNAL_CATCH_REMOVE_PARENS(...)
#define	INTERNAL_CATCH_TESTCASE2(TestName, ...)
#define	INTERNAL_CATCH_TESTCASE(...)
#define	INTERNAL_CATCH_TEST_CASE_METHOD2(TestName, ClassName, ...)
#define	INTERNAL_CATCH_TEST_CASE_METHOD(ClassName, ...)
#define	INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2(TestName, ClassName, ...)
#define	INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE(ClassName, ...)
#define	INTERNAL_CATCH_METHOD_AS_TEST_CASE(QualifiedMethod, ...)
#define	INTERNAL_CATCH_REGISTER_TESTCASE(Function, ...)
#define	REQUIRE(...)
#define	REQUIRE_FALSE(...)
#define	REQUIRE_THROWS(...)
#define	REQUIRE_THROWS_AS(expr, exceptionType)
#define	REQUIRE_NOTHROW(...)
#define	CHECK(...)
#define	CHECK_FALSE(...)
#define	CHECKED_IF(...)
#define	CHECKED_ELSE(...)
#define	CHECK_NOFAIL(...)
#define	CHECK_THROWS(...)
#define	CHECK_THROWS_AS(expr, exceptionType)
#define	CHECK_NOTHROW(...)
#define	TEST_CASE(...)
#define	TEST_CASE_METHOD(className, ...)
#define	METHOD_AS_TEST_CASE(method, ...)
#define	TEST_CASE_PERSISTENT_FIXTURE(className, ...)
#define	REGISTER_TEST_CASE(Function, ...)
#define	SECTION(...)
#define	DYNAMIC_SECTION(...)
#define	FAIL(...)
#define	FAIL_CHECK(...)
#define	SUCCEED(...)
#define	SKIP(...)
#define	STATIC_REQUIRE(...)
#define	STATIC_REQUIRE_FALSE(...)
#define	STATIC_CHECK(...)
#define	STATIC_CHECK_FALSE(...)
#define	SCENARIO(...)
#define	SCENARIO_METHOD(className, ...)
#define	GIVEN(desc)
#define	AND_GIVEN(desc)
#define	WHEN(desc)
#define	AND_WHEN(desc)
#define	THEN(desc)
#define	AND_THEN(desc)
#define	CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
#define	CATCH_PREPROCESSOR_HPP_INCLUDED
#define	CATCH_RECURSION_LEVEL0(...)
#define	CATCH_RECURSION_LEVEL1(...)
#define	CATCH_RECURSION_LEVEL2(...)
#define	CATCH_RECURSION_LEVEL3(...)
#define	CATCH_RECURSION_LEVEL4(...)
#define	CATCH_RECURSION_LEVEL5(...)
#define	CATCH_RECURSE(...)
#define	CATCH_REC_END(...)
#define	CATCH_REC_OUT
#define	CATCH_EMPTY()
#define	CATCH_DEFER(id)
#define	CATCH_REC_GET_END2()
#define	CATCH_REC_GET_END1(...)
#define	CATCH_REC_GET_END(...)
#define	CATCH_REC_NEXT0(test, next, ...)
#define	CATCH_REC_NEXT1(test, next)
#define	CATCH_REC_NEXT(test, next)
#define	CATCH_REC_LIST0(f, x, peek, ...)
#define	CATCH_REC_LIST1(f, x, peek, ...)
#define	CATCH_REC_LIST2(f, x, peek, ...)
#define	CATCH_REC_LIST0_UD(f, userdata, x, peek, ...)
#define	CATCH_REC_LIST1_UD(f, userdata, x, peek, ...)
#define	CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)
#define	CATCH_REC_LIST_UD(f, userdata, ...)
#define	CATCH_REC_LIST(f, ...)
#define	INTERNAL_CATCH_STRINGIZE(...)
#define	INTERNAL_CATCH_STRINGIZE2(...)
#define	INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param)
#define	INTERNAL_CATCH_MAKE_NAMESPACE2(...)
#define	INTERNAL_CATCH_MAKE_NAMESPACE(name)
#define	INTERNAL_CATCH_MAKE_TYPE_LIST2(...)
#define	INTERNAL_CATCH_MAKE_TYPE_LIST(...)
#define	INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)
#define	INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0)
#define	INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1)
#define	INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2)
#define	INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3)
#define	INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4)
#define	INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5)
#define	INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6)
#define	INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7)
#define	INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8)
#define	INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9)
#define	INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
#define	INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...)
#define	INTERNAL_CATCH_TYPE_GEN
#define	INTERNAL_CATCH_NTTP_1(signature, ...)
#define	INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
#define	INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)
#define	INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)
#define	INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
#define	INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)
#define	INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature, ...)
#define	INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)
#define	INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)
#define	INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)
#define	INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)
#define	INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
#define	INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)
#define	INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)
#define	INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
#define	INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)
#define	INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)
#define	INTERNAL_CATCH_NTTP_0
#define	INTERNAL_CATCH_NTTP_GEN(...)
#define	INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...)
#define	INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...)
#define	INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...)
#define	INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...)
#define	INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...)
#define	INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...)
#define	INTERNAL_CATCH_REMOVE_PARENS_GEN(...)
#define	INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ...)
#define	INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...)
#define	INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...)
#define	INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList)
#define	INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)
#define	INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)
#define	INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)
#define	INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList)
#define	INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, ...)
#define	INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD(ClassName, Name, Tags, ...)
#define	INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG(ClassName, Name, Tags, Signature, ...)
#define	INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)
#define	INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD(ClassName, Name, Tags, ...)
#define	INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(ClassName, Name, Tags, Signature, ...)
#define	INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, TmplList)
#define	INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList)
#define	TEMPLATE_TEST_CASE(...)
#define	TEMPLATE_TEST_CASE_SIG(...)
#define	TEMPLATE_TEST_CASE_METHOD(className, ...)
#define	TEMPLATE_TEST_CASE_METHOD_SIG(className, ...)
#define	TEMPLATE_PRODUCT_TEST_CASE(...)
#define	TEMPLATE_PRODUCT_TEST_CASE_SIG(...)
#define	TEMPLATE_PRODUCT_TEST_CASE_METHOD(className, ...)
#define	TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(className, ...)
#define	TEMPLATE_LIST_TEST_CASE(...)
#define	TEMPLATE_LIST_TEST_CASE_METHOD(className, ...)
#define	CATCH_TEST_CASE_INFO_HPP_INCLUDED
#define	CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
#define	CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
#define	INTERNAL_CATCH_TRANSLATE_EXCEPTION2(translatorName, signature)
#define	INTERNAL_CATCH_TRANSLATE_EXCEPTION(signature)
#define	CATCH_TRANSLATE_EXCEPTION(signature)
#define	CATCH_VERSION_HPP_INCLUDED
#define	CATCH_VERSION_MACROS_HPP_INCLUDED
#define	CATCH_VERSION_MAJOR   3
#define	CATCH_VERSION_MINOR   8
#define	CATCH_VERSION_PATCH   1
#define	CATCH_GENERATORS_ALL_HPP_INCLUDED
#define	CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
#define	CATCH_GENERATORS_HPP_INCLUDED
#define	CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
#define	CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(...)
#define	CATCH_INTERNAL_GENERATOR_STRINGIZE(...)
#define	GENERATE(...)
#define	GENERATE_COPY(...)
#define	GENERATE_REF(...)
#define	CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
#define	CATCH_GENERATORS_RANDOM_HPP_INCLUDED
#define	CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
#define	CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
#define	CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
#define	SizedUnsignedTypeHelper(TYPE)
#define	CarryBits(x)

Typedefs
using	Catch::Benchmark::IDuration = std::chrono::nanoseconds
using	Catch::Benchmark::FDuration = std::chrono::duration<double, std::nano>
template<typename Clock>
using	Catch::Benchmark::TimePoint = typename Clock::time_point
using	Catch::Benchmark::default_clock = std::chrono::steady_clock
using	Catch::Generators::GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>
using	Catch::IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>
template<typename Func, typename... U>
using	Catch::FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U...)>>>
template<typename T>
using	Catch::Benchmark::Detail::CompleteType_t = typename CompleteType<T>::type
template<typename Func, typename... Args>
using	Catch::Benchmark::TimingOf = Timing<Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>
template<typename Clock, typename Fun>
using	Catch::Benchmark::Detail::run_for_at_least_argument_t = std::conditional_t<is_callable<Fun(Chronometer)>::value, Chronometer, int>
using	Catch::Benchmark::Detail::sample = std::vector<double>
template<typename T>
using	Catch::Benchmark::storage_for = Detail::ObjectStorage<T, true>
template<typename T>
using	Catch::Benchmark::destructable_object = Detail::ObjectStorage<T, false>
template<typename... Ts>
using	Catch::Detail::void_t = typename make_void<Ts...>::type
using	Catch::Clara::Detail::Result = BasicResult<void>
using	Catch::Clara::Detail::ParserResult = BasicResult<ParseResultType>
using	Catch::Clara::Detail::InternalParseResult = BasicResult<ParseState>
template<typename T>
using	Catch::Detail::RemoveCVRef_t = std::remove_cv_t<std::remove_reference_t<T>>
using	Catch::exceptionTranslateFunction = std::string(*)()
using	Catch::ExceptionTranslators = std::vector<Detail::unique_ptr<IExceptionTranslator const>>
template<typename T>
using	Catch::Generators::GeneratorPtr = Catch::Detail::unique_ptr<IGenerator<T>>
using	Catch::Clara::ParserResult

Enumerations
enum class	Catch::Verbosity { Catch::Quiet = 0 , Catch::Normal , Catch::High }
enum class	Catch::ShowDurations { Catch::DefaultForReporter , Catch::Always , Catch::Never }
enum class	Catch::TestRunOrder { Catch::Declared , Catch::LexicographicallySorted , Catch::Randomized }
enum class	Catch::ColourMode : std::uint8_t { Catch::PlatformDefault , Catch::ANSI , Catch::Win32 , Catch::None }
enum class	Catch::CaseSensitive { Catch::Yes , Catch::No }
enum class	Catch::GenerateFrom { Catch::Time , Catch::RandomDevice , Catch::Default }
enum class	Catch::Clara::ParseResultType { Catch::Clara::Matched , Catch::Clara::NoMatch , Catch::Clara::ShortCircuitAll , Catch::Clara::ShortCircuitSame }
enum class	Catch::Clara::Detail::TokenType { Catch::Clara::Detail::Option , Catch::Clara::Detail::Argument }
enum class	Catch::Clara::Detail::ResultType { Catch::Clara::Detail::Ok , Catch::Clara::Detail::LogicError , Catch::Clara::Detail::RuntimeError }
	Denotes type of a parsing result. More...
enum class	Catch::Clara::Detail::Optionality { Catch::Clara::Detail::Optional , Catch::Clara::Detail::Required }
enum class	Catch::TestCaseProperties : uint8_t {   Catch::None = 0 , Catch::IsHidden = 1 << 1 , Catch::ShouldFail = 1 << 2 , Catch::MayFail = 1 << 3 ,   Catch::Throws = 1 << 4 , Catch::NonPortable = 1 << 5 , Catch::Benchmark = 1 << 6 }

Functions
Context &	Catch::getCurrentMutableContext ()
Context const &	Catch::getCurrentContext ()
void	Catch::cleanUpContext ()
SimplePcg32 &	Catch::sharedRng ()
void	Catch::throw_test_failure_exception ()
void	Catch::throw_test_skip_exception ()
constexpr auto	Catch::operator""_sr (char const *rawChars, std::size_t size) noexcept -> StringRef
constexpr auto	operator""_catch_sr (char const *rawChars, std::size_t size) noexcept -> Catch::StringRef
constexpr bool	Catch::isOk (ResultWas::OfType resultType)
constexpr bool	Catch::isJustInfo (int flags)
constexpr ResultDisposition::Flags	Catch::operator| (ResultDisposition::Flags lhs, ResultDisposition::Flags rhs)
constexpr bool	Catch::isFalseTest (int flags)
constexpr bool	Catch::shouldSuppressFailure (int flags)
template<typename T, typename... Args>
unique_ptr< T >	Catch::Detail::make_unique (Args &&... args)
IResultCapture &	Catch::getResultCapture ()
IRegistryHub const &	Catch::getRegistryHub ()
IMutableRegistryHub &	Catch::getMutableRegistryHub ()
void	Catch::cleanUp ()
std::string	Catch::translateActiveException ()
template<typename T>
void	Catch::Benchmark::deoptimize_value (T &&x)
template<typename Fn, typename... Args>
auto	Catch::Benchmark::invoke_deoptimized (Fn &&fn, Args &&... args) -> std::enable_if_t<!std::is_same< void, decltype(fn(args...))>::value >
template<typename Fun>
repeater< std::decay_t< Fun > >	Catch::Benchmark::Detail::repeat (Fun &&fun)
template<typename Fun, typename... Args>
CompleteType_t< FunctionReturnType< Fun, Args... > >	Catch::Benchmark::Detail::complete_invoke (Fun &&fun, Args &&... args)
template<typename Fun>
Detail::CompleteType_t< FunctionReturnType< Fun > >	Catch::Benchmark::user_code (Fun &&fun)
template<typename Clock, typename Fun, typename... Args>
TimingOf< Fun, Args... >	Catch::Benchmark::Detail::measure (Fun &&fun, Args &&... args)
template<typename Clock, typename Fun>
TimingOf< Fun, int >	Catch::Benchmark::Detail::measure_one (Fun &&fun, int iters, std::false_type)
template<typename Clock, typename Fun>
TimingOf< Fun, Chronometer >	Catch::Benchmark::Detail::measure_one (Fun &&fun, int iters, std::true_type)
void	Catch::Benchmark::Detail::throw_optimized_away_error ()
template<typename Clock, typename Fun>
TimingOf< Fun, run_for_at_least_argument_t< Clock, Fun > >	Catch::Benchmark::Detail::run_for_at_least (IDuration how_long, const int initial_iterations, Fun &&fun)
double	Catch::Benchmark::Detail::weighted_average_quantile (int k, int q, double *first, double *last)
OutlierClassification	Catch::Benchmark::Detail::classify_outliers (double const *first, double const *last)
double	Catch::Benchmark::Detail::mean (double const *first, double const *last)
double	Catch::Benchmark::Detail::normal_cdf (double x)
double	Catch::Benchmark::Detail::erfc_inv (double x)
double	Catch::Benchmark::Detail::normal_quantile (double p)
Estimate< double >	Catch::Benchmark::Detail::bootstrap (double confidence_level, double *first, double *last, sample const &resample, double(*estimator)(double const *, double const *))
bootstrap_analysis	Catch::Benchmark::Detail::analyse_samples (double confidence_level, unsigned int n_resamples, double *first, double *last)
template<typename Clock>
std::vector< double >	Catch::Benchmark::Detail::resolution (int k)
template<typename Clock>
int	Catch::Benchmark::Detail::warmup ()
template<typename Clock>
EnvironmentEstimate	Catch::Benchmark::Detail::estimate_clock_resolution (int iterations)
template<typename Clock>
EnvironmentEstimate	Catch::Benchmark::Detail::estimate_clock_cost (FDuration resolution)
template<typename Clock>
Environment	Catch::Benchmark::Detail::measure_environment ()
SampleAnalysis	Catch::Benchmark::Detail::analyse (const IConfig &cfg, FDuration *first, FDuration *last)
std::ostream &	operator<< (std::ostream &, Catch_global_namespace_dummy)
std::size_t	Catch::Detail::catch_strnlen (const char *str, std::size_t n)
std::string	Catch::Detail::convertIntoString (StringRef string, bool escapeInvisibles)
	Encases `string in quotes, and optionally escapes invisibles.
std::string	Catch::Detail::convertIntoString (StringRef string)
	Encases string in quotes, and escapes invisibles if user requested it via CLI.
std::string	Catch::Detail::rawMemoryToString (const void *object, std::size_t size)
template<typename T>
std::string	Catch::Detail::rawMemoryToString (const T &object)
template<typename E>
std::string	Catch::Detail::convertUnknownEnumToString (E e)
template<typename T>
std::enable_if_t< !std::is_enum< T >::value &&!std::is_base_of< std::exception, T >::value, std::string >	Catch::Detail::convertUnstreamable (T const &)
template<typename T>
std::enable_if_t< !std::is_enum< T >::value &&std::is_base_of< std::exception, T >::value, std::string >	Catch::Detail::convertUnstreamable (T const &ex)
template<typename T>
std::enable_if_t< std::is_enum< T >::value, std::string >	Catch::Detail::convertUnstreamable (T const &value)
template<typename T>
std::string	Catch::Detail::stringify (const T &e)
template<typename InputIterator, typename Sentinel = InputIterator>
std::string	Catch::Detail::rangeToString (InputIterator first, Sentinel last)
template<typename Range>
std::string	Catch::rangeToString (Range const &range)
template<typename Allocator>
std::string	Catch::rangeToString (std::vector< bool, Allocator > const &v)
Approx	Catch::literals::operator""_a (long double val)
Approx	Catch::literals::operator""_a (unsigned long long val)
std::uint32_t	Catch::generateRandomSeed (GenerateFrom from)
std::vector< std::string >	Catch::Detail::splitReporterSpec (StringRef reporterSpec)
	Splits the reporter spec into reporter name and kv-pair options.
Optional< ColourMode >	Catch::Detail::stringToColourMode (StringRef colourMode)
Optional< ReporterSpec >	Catch::parseReporterSpec (StringRef reporterSpec)
std::uint32_t	Catch::getSeed ()
	Returns Catch2's current RNG seed.
template<typename T>
ParserResult	Catch::Clara::Detail::convertInto (std::string const &source, T &target)
ParserResult	Catch::Clara::Detail::convertInto (std::string const &source, std::string &target)
ParserResult	Catch::Clara::Detail::convertInto (std::string const &source, bool &target)
template<typename ArgType, typename L>
auto	Catch::Clara::Detail::invokeLambda (L const &lambda, std::string const &arg) -> ParserResult
Clara::Parser	Catch::makeCommandLineParser (ConfigData &config)
void	Catch::formatReconstructedExpression (std::ostream &os, std::string const &lhs, StringRef op, std::string const &rhs)
void	Catch::handleExceptionMatchExpr (AssertionHandler &handler, std::string const &str)
Detail::unique_ptr< ITestInvoker >	Catch::makeTestInvoker (void(*testAsFunction)())
template<typename C>
Detail::unique_ptr< ITestInvoker >	Catch::makeTestInvoker (void(C::*testAsMethod)())
template<typename C>
Detail::unique_ptr< ITestInvoker >	Catch::makeTestInvokerFixture (void(C::*testAsMethod)() const)
Detail::unique_ptr< TestCaseInfo >	Catch::makeTestCaseInfo (StringRef _className, NameAndTags const &nameAndTags, SourceLineInfo const &_lineInfo)
void	Catch::Detail::registerTranslatorImpl (Detail::unique_ptr< IExceptionTranslator > &&translator)
Version const &	Catch::libraryVersion ()
void	Catch::Generators::Detail::throw_generator_exception (char const *msg)
	Throws GeneratorException with the provided message.
template<typename T, typename DecayedT = std::decay_t<T>>
GeneratorWrapper< DecayedT >	Catch::Generators::value (T &&value)
template<typename T>
GeneratorWrapper< T >	Catch::Generators::values (std::initializer_list< T > values)
template<typename... Ts>
GeneratorWrapper< std::tuple< std::decay_t< Ts >... > >	Catch::Generators::table (std::initializer_list< std::tuple< std::decay_t< Ts >... > > tuples)
template<typename T, typename... Gs>
auto	Catch::Generators::makeGenerators (GeneratorWrapper< T > &&generator, Gs &&... moreGenerators) -> Generators< T >
template<typename T>
auto	Catch::Generators::makeGenerators (GeneratorWrapper< T > &&generator) -> Generators< T >
template<typename T, typename... Gs>
auto	Catch::Generators::makeGenerators (T &&val, Gs &&... moreGenerators) -> Generators< std::decay_t< T > >
template<typename T, typename U, typename... Gs>
auto	Catch::Generators::makeGenerators (as< T >, U &&val, Gs &&... moreGenerators) -> Generators< T >
IGeneratorTracker *	Catch::Generators::acquireGeneratorTracker (StringRef generatorName, SourceLineInfo const &lineInfo)
IGeneratorTracker *	Catch::Generators::createGeneratorTracker (StringRef generatorName, SourceLineInfo lineInfo, GeneratorBasePtr &&generator)
template<typename L>
auto	Catch::Generators::generate (StringRef generatorName, SourceLineInfo const &lineInfo, L const &generatorExpression) -> typename decltype(generatorExpression())::type
template<typename T>
GeneratorWrapper< T >	Catch::Generators::take (size_t target, GeneratorWrapper< T > &&generator)
template<typename T, typename Predicate>
GeneratorWrapper< T >	Catch::Generators::filter (Predicate &&pred, GeneratorWrapper< T > &&generator)
template<typename T>
GeneratorWrapper< T >	Catch::Generators::repeat (size_t repeats, GeneratorWrapper< T > &&generator)
template<typename Func, typename U, typename T = FunctionReturnType<Func, U>>
GeneratorWrapper< T >	Catch::Generators::map (Func &&function, GeneratorWrapper< U > &&generator)
template<typename T>
GeneratorWrapper< std::vector< T > >	Catch::Generators::chunk (size_t size, GeneratorWrapper< T > &&generator)

Variables
constexpr auto	Catch::Benchmark::Detail::warmup_iterations = 10000
constexpr auto	Catch::Benchmark::Detail::warmup_time = std::chrono::milliseconds(100)
constexpr auto	Catch::Benchmark::Detail::minimum_ticks = 1000
constexpr auto	Catch::Benchmark::Detail::warmup_seed = 10000
constexpr auto	Catch::Benchmark::Detail::clock_resolution_estimation_time = std::chrono::milliseconds(500)
constexpr auto	Catch::Benchmark::Detail::clock_cost_estimation_time_limit = std::chrono::seconds(1)
constexpr auto	Catch::Benchmark::Detail::clock_cost_estimation_tick_limit = 100000
constexpr auto	Catch::Benchmark::Detail::clock_cost_estimation_time = std::chrono::milliseconds(10)
constexpr auto	Catch::Benchmark::Detail::clock_cost_estimation_iterations = 10000
constexpr StringRef	Catch::Detail::unprintableString = "{?}"_sr
constexpr accept_many_t	Catch::Clara::accept_many {}

Detailed Description

This is a convenience header for Catch2. It includes all of Catch2 headers.

Generally the Catch2 users should use specific includes they need, but this header can be used instead for ease-of-experimentation, or just plain convenience, at the cost of (significantly) increased compilation times.

When a new header is added to either the top level folder, or to the corresponding internal subfolder, it should be added here. Headers added to the various subparts (e.g. matchers, generators, etc...), should go their respective catch-all headers.

This is a convenience header for Catch2's benchmarking. It includes all of Catch2 headers related to benchmarking.

Generally the Catch2 users should use specific includes they need, but this header can be used instead for ease-of-experimentation, or just plain convenience, at the cost of (significantly) increased compilation times.

When a new header is added to either the benchmark folder, or to the corresponding internal (detail) subfolder, it should be added here.

Wrapper for the CONFIG configuration option

When generating internal unique names, there are two options. Either we mix in the current line number, or mix in an incrementing number. We prefer the latter, using __COUNTER__, but users might want to use the former.

Wrapper for the WCHAR configuration option

We want to support platforms that do not provide wchar_t, so we sometimes have to disable providing wchar_t overloads through Catch2, e.g. the StringMaker specialization for std::wstring.

Wrapper for the CATCH_CONFIG_PREFIX_MESSAGES configuration option

CATCH_CONFIG_PREFIX_ALL can be used to avoid clashes with other macros by prepending CATCH_. This may not be desirable if the only clashes are with logger macros such as INFO and WARN. In this cases CATCH_CONFIG_PREFIX_MESSAGES can be used to only prefix a small subset of relevant macros.

Why does decomposing look the way it does:

Conceptually, decomposing is simple. We change REQUIRE( a == b ) into Decomposer{} <= a == b, so that Decomposer{} <= a is evaluated first, and our custom operator is used for a == b, because a is transformed into ExprLhs<T&> and then into BinaryExpr<T&, U&>.

In practice, decomposing ends up a mess, because we have to support various fun things.

1) Types that are only comparable with literal 0, and they do this by comparing against a magic type with pointer constructor and deleted other constructors. Example: REQUIRE((a <=> b) == 0) in libstdc++

2) Types that are only comparable with literal 0, and they do this by comparing against a magic type with consteval integer constructor. Example: REQUIRE((a <=> b) == 0) in current MSVC STL.

3) Types that have no linkage, and so we cannot form a reference to them. Example: some implementations of traits.

4) Starting with C++20, when the compiler sees a == b, it also uses b == a when constructing the overload set. For us this means that when the compiler handles ExprLhs<T> == b, it also tries to resolve the overload set for b == ExprLhs<T>.

To accomodate these use cases, decomposer ended up rather complex.

1) These types are handled by adding SFINAE overloads to our comparison operators, checking whether T == U are comparable with the given operator, and if not, whether T (or U) are comparable with literal 0. If yes, the overload compares T (or U) with 0 literal inline in the definition.

Note that for extra correctness, we check that the other type is either an int (literal 0 is captured as int by templates), or a long (some platforms use 0L for NULL and we want to support that for pointer comparisons).

2) For these types, is_foo_comparable<T, int> is true, but letting them fall into the overload that actually does T == int causes compilation error. Handling them requires that the decomposition is constexpr, so that P2564R3 applies and the consteval from their accompanying magic type is propagated through the constexpr call stack.

However this is not enough to handle these types automatically, because our default is to capture types by reference, to avoid runtime copies. While these references cannot become dangling, they outlive the constexpr context and thus the default capture path cannot be actually constexpr.

The solution is to capture these types by value, by explicitly specializing Catch::capture_by_value for them. Catch2 provides specialization for std::foo_orderings, but users can specialize the trait for their own types as well.

3) If a type has no linkage, we also cannot capture it by reference. The solution is once again to capture them by value. We handle the common cases by using std::is_arithmetic as the default for Catch::capture_by_value, but that is only a some-effort heuristic. But as with 2), users can specialize capture_by_value for their own types as needed.

4) To support C++20 and make the SFINAE on our decomposing operators work, the SFINAE has to happen in return type, rather than in a template type. This is due to our use of logical type traits (conjunction/disjunction/negation), that we use to workaround an issue in older (9-) versions of GCC. I still blame C++20 for this, because without the comparison order switching, the logical traits could still be used in template type.

There are also other side concerns, e.g. supporting both REQUIRE(a) and REQUIRE(a == b), or making REQUIRE_THAT(a, IsEqual(b)) slot nicely into the same expression handling logic, but these are rather straightforward and add only a bit of complexity (e.g. common base class for decomposed expressions).

Wrapper for the STATIC_ANALYSIS_SUPPORT configuration option

Some of Catch2's macros can be defined differently to work better with static analysis tools, like clang-tidy or coverity. Currently the main use case is to show that SECTIONs are executed exclusively, and not all in one run of a TEST_CASE.

This is a convenience header for Catch2's Generator support. It includes all of Catch2 headers related to generators.

Generally the Catch2 users should use specific includes they need, but this header can be used instead for ease-of-experimentation, or just plain convenience, at the cost of (significantly) increased compilation times.

When a new header is added to either the generators folder, or to the corresponding internal subfolder, it should be added here.

Macro Definition Documentation

AND_GIVEN

#define AND_GIVEN

(

desc

)

Value:

INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )

AND_THEN

#define AND_THEN

(

desc

)

Value:

INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )

AND_WHEN

#define AND_WHEN

(

desc

)

Value:

INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )

BENCHMARK

#define BENCHMARK

(

...

)

Value:

    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))

BENCHMARK_ADVANCED

#define BENCHMARK_ADVANCED

(

name

)

Value:

    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)

CAPTURE

#define CAPTURE

(

...

)

Value:

INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE", __VA_ARGS__ )

CarryBits

#define CarryBits

(

x

)

Value:

( x >> 32 )

CATCH_ALL_HPP_INCLUDED

#define CATCH_ALL_HPP_INCLUDED

CATCH_ANALYSE_HPP_INCLUDED

#define CATCH_ANALYSE_HPP_INCLUDED

CATCH_APPROX_HPP_INCLUDED

#define CATCH_APPROX_HPP_INCLUDED

CATCH_ASSERTION_HANDLER_HPP_INCLUDED

#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED

CATCH_ASSERTION_INFO_HPP_INCLUDED

#define CATCH_ASSERTION_INFO_HPP_INCLUDED

CATCH_ASSERTION_RESULT_HPP_INCLUDED

#define CATCH_ASSERTION_RESULT_HPP_INCLUDED

CATCH_BENCHMARK_ALL_HPP_INCLUDED

#define CATCH_BENCHMARK_ALL_HPP_INCLUDED

CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED

#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED

CATCH_BENCHMARK_HPP_INCLUDED

#define CATCH_BENCHMARK_HPP_INCLUDED

CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED

#define CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED

CATCH_BENCHMARK_STATS_HPP_INCLUDED

#define CATCH_BENCHMARK_STATS_HPP_INCLUDED

CATCH_CASE_SENSITIVE_HPP_INCLUDED

#define CATCH_CASE_SENSITIVE_HPP_INCLUDED

CATCH_CATCH_ALL

#define CATCH_CATCH_ALL   if ((false))

CATCH_CATCH_ANON

#define CATCH_CATCH_ANON

(

type

)

Value:

if ((false))

CATCH_CHRONOMETER_HPP_INCLUDED

#define CATCH_CHRONOMETER_HPP_INCLUDED

CATCH_CLARA_HPP_INCLUDED

#define CATCH_CLARA_HPP_INCLUDED

CATCH_CLOCK_HPP_INCLUDED

#define CATCH_CLOCK_HPP_INCLUDED

CATCH_COMMANDLINE_HPP_INCLUDED

#define CATCH_COMMANDLINE_HPP_INCLUDED

CATCH_COMPARE_TRAITS_HPP_INCLUDED

#define CATCH_COMPARE_TRAITS_HPP_INCLUDED

CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED

#define CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED

CATCH_COMPLETE_INVOKE_HPP_INCLUDED

#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED

CATCH_CONFIG_COUNTER

#define CATCH_CONFIG_COUNTER

CATCH_CONFIG_COUNTER_HPP_INCLUDED

#define CATCH_CONFIG_COUNTER_HPP_INCLUDED

CATCH_CONFIG_CPP11_TO_STRING

#define CATCH_CONFIG_CPP11_TO_STRING

CATCH_CONFIG_DISABLE_EXCEPTIONS

#define CATCH_CONFIG_DISABLE_EXCEPTIONS

CATCH_CONFIG_GETENV

#define CATCH_CONFIG_GETENV

CATCH_CONFIG_GLOBAL_NEXTAFTER

#define CATCH_CONFIG_GLOBAL_NEXTAFTER

CATCH_CONFIG_HPP_INCLUDED

#define CATCH_CONFIG_HPP_INCLUDED

CATCH_CONFIG_POSIX_SIGNALS

#define CATCH_CONFIG_POSIX_SIGNALS

CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED

#define CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED

CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED

#define CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED

CATCH_CONFIG_WCHAR

#define CATCH_CONFIG_WCHAR

CATCH_CONFIG_WCHAR_HPP_INCLUDED

#define CATCH_CONFIG_WCHAR_HPP_INCLUDED

CATCH_CONSTRUCTOR_HPP_INCLUDED

#define CATCH_CONSTRUCTOR_HPP_INCLUDED

CATCH_CONTEXT_HPP_INCLUDED

#define CATCH_CONTEXT_HPP_INCLUDED

CATCH_DECOMPOSER_HPP_INCLUDED

#define CATCH_DECOMPOSER_HPP_INCLUDED

CATCH_DEFER

#define CATCH_DEFER

(

id

)

Value:

id CATCH_EMPTY()

CATCH_DEFINE_COMPARABLE_TRAIT

#define CATCH_DEFINE_COMPARABLE_TRAIT	(		id,
			op )

Value:

    template <typename, typename, typename = void>                            \
    struct is_##id##_comparable : std::false_type {};                         \
    template <typename T, typename U>                                         \
    struct is_##id##_comparable<                                              \
        T,                                                                    \
        U,                                                                    \
        void_t<decltype( std::declval<T>() op std::declval<U>() )>>           \
        : std::true_type {};                                                  \
    template <typename, typename = void>                                      \
    struct is_##id##_0_comparable : std::false_type {};                       \
    template <typename T>                                                     \
    struct is_##id##_0_comparable<T,                                          \
                                  void_t<decltype( std::declval<T>() op 0 )>> \
        : std::true_type {};

CATCH_EMPTY

#define CATCH_EMPTY

(

)

CATCH_ENVIRONMENT_HPP_INCLUDED

#define CATCH_ENVIRONMENT_HPP_INCLUDED

CATCH_ESTIMATE_CLOCK_HPP_INCLUDED

#define CATCH_ESTIMATE_CLOCK_HPP_INCLUDED

CATCH_ESTIMATE_HPP_INCLUDED

#define CATCH_ESTIMATE_HPP_INCLUDED

CATCH_EXECUTION_PLAN_HPP_INCLUDED

#define CATCH_EXECUTION_PLAN_HPP_INCLUDED

CATCH_EXPORT

#define CATCH_EXPORT

CATCH_FORWARD

#define CATCH_FORWARD

(

...

)

Value:

static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)

Replacement for std::forward with better compile time performance.

CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED

#define CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED

CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED

#define CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED

CATCH_GENERATORS_ALL_HPP_INCLUDED

#define CATCH_GENERATORS_ALL_HPP_INCLUDED

CATCH_GENERATORS_HPP_INCLUDED

#define CATCH_GENERATORS_HPP_INCLUDED

CATCH_GENERATORS_RANDOM_HPP_INCLUDED

#define CATCH_GENERATORS_RANDOM_HPP_INCLUDED

CATCH_GET_RANDOM_SEED_HPP_INCLUDED

#define CATCH_GET_RANDOM_SEED_HPP_INCLUDED

CATCH_INTERFACES_CAPTURE_HPP_INCLUDED

#define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED

CATCH_INTERFACES_CONFIG_HPP_INCLUDED

#define CATCH_INTERFACES_CONFIG_HPP_INCLUDED

CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED

#define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED

CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED

#define CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED

CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED

#define CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED

CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED

#define CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED

CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED

#define CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED

CATCH_INTERNAL_CONFIG_COUNTER

#define CATCH_INTERNAL_CONFIG_COUNTER

CATCH_INTERNAL_CONFIG_GETENV

#define CATCH_INTERNAL_CONFIG_GETENV

CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER

#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER

CATCH_INTERNAL_CONFIG_POSIX_SIGNALS

#define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS

CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR

#define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR	(		id,
			op )

CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR

#define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR	(		id,
			op )

CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR

#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR

(

op

)

Value:

    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs )             \
        -> std::enable_if_t<                                                   \
            !capture_by_value<Detail::RemoveCVRef_t<RhsT>>::value,             \
            BinaryExpr<LhsT, RhsT const&>> {                                   \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }                                                                          \
    template <typename RhsT>                                                   \
    constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs )               \
        -> std::enable_if_t<capture_by_value<RhsT>::value,                     \
                            BinaryExpr<LhsT, RhsT>> {                          \
        return {                                                               \
            static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
    }

CATCH_INTERNAL_GENERATOR_STRINGIZE

#define CATCH_INTERNAL_GENERATOR_STRINGIZE

(

...

)

Value:

CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(__VA_ARGS__)

CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL

#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL

(

...

)

Value:

#__VA_ARGS__##_catch_sr

CATCH_INTERNAL_IGNORE_BUT_WARN

#define CATCH_INTERNAL_IGNORE_BUT_WARN

(

...

)

CATCH_INTERNAL_LINEINFO

#define CATCH_INTERNAL_LINEINFO    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )

CATCH_INTERNAL_START_WARNINGS_SUPPRESSION

#define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION

CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

#define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

CATCH_INTERNAL_STRINGIFY

#define CATCH_INTERNAL_STRINGIFY

(

...

)

Value:

#__VA_ARGS__##_catch_sr

CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS

#define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS

CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS

#define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS

CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS

#define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS

CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS

#define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS

CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT

#define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT

CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS

#define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS

CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS

#define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS

CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS

#define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS

CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS

#define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS

CATCH_LAZY_EXPR_HPP_INCLUDED

#define CATCH_LAZY_EXPR_HPP_INCLUDED

CATCH_LOGICAL_TRAITS_HPP_INCLUDED

#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED

CATCH_MEASURE_HPP_INCLUDED

#define CATCH_MEASURE_HPP_INCLUDED

CATCH_MESSAGE_HPP_INCLUDED

#define CATCH_MESSAGE_HPP_INCLUDED

CATCH_MESSAGE_INFO_HPP_INCLUDED

#define CATCH_MESSAGE_INFO_HPP_INCLUDED

CATCH_META_HPP_INCLUDED

#define CATCH_META_HPP_INCLUDED

CATCH_MOVE

#define CATCH_MOVE

(

...

)

Value:

static_cast<std::remove_reference_t<decltype(__VA_ARGS__)>&&>(__VA_ARGS__)

Replacement for std::move with better compile time performance.

CATCH_MOVE_AND_FORWARD_HPP_INCLUDED

#define CATCH_MOVE_AND_FORWARD_HPP_INCLUDED

CATCH_NONCOPYABLE_HPP_INCLUDED

#define CATCH_NONCOPYABLE_HPP_INCLUDED

CATCH_OPTIMIZER_HPP_INCLUDED

#define CATCH_OPTIMIZER_HPP_INCLUDED

CATCH_OPTIONAL_HPP_INCLUDED

#define CATCH_OPTIONAL_HPP_INCLUDED

CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED

#define CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED

CATCH_PLATFORM_HPP_INCLUDED

#define CATCH_PLATFORM_HPP_INCLUDED

CATCH_PREPROCESSOR_HPP_INCLUDED

#define CATCH_PREPROCESSOR_HPP_INCLUDED

CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED

#define CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED

CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED

#define CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED

CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED

#define CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED

CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED

#define CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED

CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED

#define CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED

CATCH_REC_END

#define CATCH_REC_END

(

...

)

CATCH_REC_GET_END

#define CATCH_REC_GET_END

(

...

)

Value:

CATCH_REC_GET_END1

CATCH_REC_GET_END1

#define CATCH_REC_GET_END1

(

...

)

Value:

CATCH_REC_GET_END2

CATCH_REC_GET_END2

#define CATCH_REC_GET_END2

(

)

Value:

0, CATCH_REC_END

CATCH_REC_LIST

#define CATCH_REC_LIST	(		f,
			... )

Value:

CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))

CATCH_REC_LIST0

#define CATCH_REC_LIST0	(		f,
			x,
			peek,
			... )

Value:

, f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )

CATCH_REC_LIST0_UD

#define CATCH_REC_LIST0_UD	(		f,
			userdata,
			x,
			peek,
			... )

Value:

, f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )

CATCH_REC_LIST1

#define CATCH_REC_LIST1	(		f,
			x,
			peek,
			... )

Value:

, f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )

CATCH_REC_LIST1_UD

#define CATCH_REC_LIST1_UD	(		f,
			userdata,
			x,
			peek,
			... )

Value:

, f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )

CATCH_REC_LIST2

#define CATCH_REC_LIST2	(		f,
			x,
			peek,
			... )

Value:

f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )

CATCH_REC_LIST2_UD

#define CATCH_REC_LIST2_UD	(		f,
			userdata,
			x,
			peek,
			... )

Value:

f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )

CATCH_REC_LIST_UD

#define CATCH_REC_LIST_UD	(		f,
			userdata,
			... )

Value:

CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))

CATCH_REC_NEXT

#define CATCH_REC_NEXT	(		test,
			next )

Value:

CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)

CATCH_REC_NEXT0

#define CATCH_REC_NEXT0	(		test,
			next,
			... )

Value:

next CATCH_REC_OUT

CATCH_REC_NEXT1

#define CATCH_REC_NEXT1	(		test,
			next )

Value:

CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)

CATCH_REC_OUT

#define CATCH_REC_OUT

CATCH_RECURSE

#define CATCH_RECURSE

(

...

)

Value:

CATCH_RECURSION_LEVEL5(__VA_ARGS__)

CATCH_RECURSION_LEVEL0

#define CATCH_RECURSION_LEVEL0

(

...

)

Value:

__VA_ARGS__

CATCH_RECURSION_LEVEL1

#define CATCH_RECURSION_LEVEL1

(

...

)

Value:

CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))

CATCH_RECURSION_LEVEL2

#define CATCH_RECURSION_LEVEL2

(

...

)

Value:

CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))

CATCH_RECURSION_LEVEL3

#define CATCH_RECURSION_LEVEL3

(

...

)

Value:

CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))

CATCH_RECURSION_LEVEL4

#define CATCH_RECURSION_LEVEL4

(

...

)

Value:

CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))

CATCH_RECURSION_LEVEL5

#define CATCH_RECURSION_LEVEL5

(

...

)

Value:

CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))

CATCH_REGISTER_ENUM

#define CATCH_REGISTER_ENUM	(		enumName,
			... )

Value:

INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )

CATCH_REGISTER_TAG_ALIAS

#define CATCH_REGISTER_TAG_ALIAS	(		alias,
			spec )

Value:

    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

CATCH_REPEAT_HPP_INCLUDED

#define CATCH_REPEAT_HPP_INCLUDED

CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED

#define CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED

CATCH_RESULT_TYPE_HPP_INCLUDED

#define CATCH_RESULT_TYPE_HPP_INCLUDED

CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED

#define CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED

CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED

#define CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED

CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED

#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED

CATCH_SECTION_HPP_INCLUDED

#define CATCH_SECTION_HPP_INCLUDED

CATCH_SECTION_INFO_HPP_INCLUDED

#define CATCH_SECTION_INFO_HPP_INCLUDED

CATCH_SESSION_HPP_INCLUDED

#define CATCH_SESSION_HPP_INCLUDED

CATCH_SOURCE_LINE_INFO_HPP_INCLUDED

#define CATCH_SOURCE_LINE_INFO_HPP_INCLUDED

CATCH_STATS_HPP_INCLUDED

#define CATCH_STATS_HPP_INCLUDED

CATCH_STREAM_END_STOP_HPP_INCLUDED

#define CATCH_STREAM_END_STOP_HPP_INCLUDED

CATCH_STRINGREF_HPP_INCLUDED

#define CATCH_STRINGREF_HPP_INCLUDED

CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED

#define CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED

CATCH_TAG_ALIAS_HPP_INCLUDED

#define CATCH_TAG_ALIAS_HPP_INCLUDED

CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED

#define CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED

CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED

#define CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED

CATCH_TEST_CASE_INFO_HPP_INCLUDED

#define CATCH_TEST_CASE_INFO_HPP_INCLUDED

CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED

#define CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED

CATCH_TEST_MACRO_IMPL_HPP_INCLUDED

#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED

CATCH_TEST_MACROS_HPP_INCLUDED

#define CATCH_TEST_MACROS_HPP_INCLUDED

CATCH_TEST_REGISTRY_HPP_INCLUDED

#define CATCH_TEST_REGISTRY_HPP_INCLUDED

CATCH_TEST_SPEC_HPP_INCLUDED

#define CATCH_TEST_SPEC_HPP_INCLUDED

CATCH_TIMER_HPP_INCLUDED

#define CATCH_TIMER_HPP_INCLUDED

CATCH_TIMING_HPP_INCLUDED

#define CATCH_TIMING_HPP_INCLUDED

CATCH_TOSTRING_HPP_INCLUDED

#define CATCH_TOSTRING_HPP_INCLUDED

CATCH_TOTALS_HPP_INCLUDED

#define CATCH_TOTALS_HPP_INCLUDED

CATCH_TRANSLATE_EXCEPTION

#define CATCH_TRANSLATE_EXCEPTION

(

signature

)

Value:

INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )

CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED

#define CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED

CATCH_TRY

#define CATCH_TRY   if ((true))

CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED

#define CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED

CATCH_UNIQUE_NAME_HPP_INCLUDED

#define CATCH_UNIQUE_NAME_HPP_INCLUDED

CATCH_UNIQUE_PTR_HPP_INCLUDED

#define CATCH_UNIQUE_PTR_HPP_INCLUDED

CATCH_VERSION_HPP_INCLUDED

#define CATCH_VERSION_HPP_INCLUDED

CATCH_VERSION_MACROS_HPP_INCLUDED

#define CATCH_VERSION_MACROS_HPP_INCLUDED

CATCH_VERSION_MAJOR

#define CATCH_VERSION_MAJOR   3

CATCH_VERSION_MINOR

#define CATCH_VERSION_MINOR   8

CATCH_VERSION_PATCH

#define CATCH_VERSION_PATCH   1

CATCH_VOID_TYPE_HPP_INCLUDED

#define CATCH_VOID_TYPE_HPP_INCLUDED

CATCH_WILDCARD_PATTERN_HPP_INCLUDED

#define CATCH_WILDCARD_PATTERN_HPP_INCLUDED

CHECK

#define CHECK

(

...

)

Value:

INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )

CHECK_FALSE

#define CHECK_FALSE

(

...

)

Value:

INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )

CHECK_NOFAIL

#define CHECK_NOFAIL

(

...

)

Value:

INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )

CHECK_NOTHROW

#define CHECK_NOTHROW

(

...

)

Value:

INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )

CHECK_THROWS

#define CHECK_THROWS

(

...

)

Value:

INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )

CHECK_THROWS_AS

#define CHECK_THROWS_AS	(		expr,
			exceptionType )

Value:

INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )

CHECKED_ELSE

#define CHECKED_ELSE

(

...

)

Value:

INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )

CHECKED_IF

#define CHECKED_IF

(

...

)

Value:

INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )

DYNAMIC_SECTION

#define DYNAMIC_SECTION

(

...

)

Value:

INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )

FAIL

#define FAIL

(

...

)

Value:

INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )

FAIL_CHECK

#define FAIL_CHECK

(

...

)

Value:

INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )

GENERATE

#define GENERATE

(

...

)

Value:

    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
                                 CATCH_INTERNAL_LINEINFO, \
                                 [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )

GENERATE_COPY

#define GENERATE_COPY

(

...

)

Value:

    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
                                 CATCH_INTERNAL_LINEINFO, \
                                 [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )

GENERATE_REF

#define GENERATE_REF

(

...

)

Value:

    Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
                                 CATCH_INTERNAL_LINEINFO, \
                                 [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } )

GIVEN

#define GIVEN

(

desc

)

Value:

INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )

INFO

#define INFO

(

msg

)

Value:

INTERNAL_CATCH_INFO( "INFO", msg )

INTERNAL_CATCH_BENCHMARK

#define INTERNAL_CATCH_BENCHMARK	(		BenchmarkName,
			name,
			benchmarkIndex )

Value:

    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
        BenchmarkName = [&](int benchmarkIndex)

INTERNAL_CATCH_BENCHMARK_ADVANCED

#define INTERNAL_CATCH_BENCHMARK_ADVANCED	(		BenchmarkName,
			name )

Value:

    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
        BenchmarkName = [&]

INTERNAL_CATCH_CAPTURE

#define INTERNAL_CATCH_CAPTURE	(		varName,
			macroName,
			... )

Value:

    Catch::Capturer varName( macroName##_catch_sr,        \
                             CATCH_INTERNAL_LINEINFO,     \
                             Catch::ResultWas::Info,      \
                             #__VA_ARGS__##_catch_sr );   \
    varName.captureValues( 0, __VA_ARGS__ )

INTERNAL_CATCH_CATCH

#define INTERNAL_CATCH_CATCH

(

capturer

)

INTERNAL_CATCH_DECLARE_SIG_TEST

#define INTERNAL_CATCH_DECLARE_SIG_TEST	(		TestName,
			... )

Value:

INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)

INTERNAL_CATCH_DECLARE_SIG_TEST0

#define INTERNAL_CATCH_DECLARE_SIG_TEST0

(

TestName

)

INTERNAL_CATCH_DECLARE_SIG_TEST1

#define INTERNAL_CATCH_DECLARE_SIG_TEST1	(		TestName,
			signature )

Value:

    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()

INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD

#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD	(		TestName,
			ClassName,
			... )

Value:

INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)

INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0

#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0	(		TestName,
			ClassName )

INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1

#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1	(		TestName,
			ClassName,
			signature )

Value:

    template<typename TestType> \
    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
        void test();\
    }

INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X

#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X	(		TestName,
			ClassName,
			signature,
			... )

Value:

    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
        void test();\
    }

INTERNAL_CATCH_DECLARE_SIG_TEST_X

#define INTERNAL_CATCH_DECLARE_SIG_TEST_X	(		TestName,
			signature,
			... )

Value:

    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()

INTERNAL_CATCH_DEF

#define INTERNAL_CATCH_DEF

(

...

)

Value:

INTERNAL_CATCH_DEF __VA_ARGS__

INTERNAL_CATCH_DEFINE_SIG_TEST

#define INTERNAL_CATCH_DEFINE_SIG_TEST	(		TestName,
			... )

Value:

INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)

INTERNAL_CATCH_DEFINE_SIG_TEST0

#define INTERNAL_CATCH_DEFINE_SIG_TEST0

(

TestName

)

INTERNAL_CATCH_DEFINE_SIG_TEST1

#define INTERNAL_CATCH_DEFINE_SIG_TEST1	(		TestName,
			signature )

Value:

    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()

INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD

#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD	(		TestName,
			... )

Value:

INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)

INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0

#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0

(

TestName

)

INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1

#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1	(		TestName,
			signature )

Value:

    template<typename TestType> \
    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()

INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X

#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X	(		TestName,
			signature,
			... )

Value:

    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()

INTERNAL_CATCH_DEFINE_SIG_TEST_X

#define INTERNAL_CATCH_DEFINE_SIG_TEST_X	(		TestName,
			signature,
			... )

Value:

    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    static void TestName()

INTERNAL_CATCH_DYNAMIC_SECTION

#define INTERNAL_CATCH_DYNAMIC_SECTION

(

...

)

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                     \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS              \
        if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(        \
                 catch_internal_Section ) =                           \
                 Catch::SectionInfo(                                  \
                     CATCH_INTERNAL_LINEINFO,                         \
                     ( Catch::ReusableStringStream() << __VA_ARGS__ ) \
                         .str() ) )                                   \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

INTERNAL_CATCH_ELSE

#define INTERNAL_CATCH_ELSE	(		macroName,
			resultDisposition,
			... )

Value:

    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
    if( !Catch::getResultCapture().lastAssertionPassed() )

INTERNAL_CATCH_EXPAND1

#define INTERNAL_CATCH_EXPAND1

(

param

)

Value:

INTERNAL_CATCH_EXPAND2( param )

INTERNAL_CATCH_EXPAND2

#define INTERNAL_CATCH_EXPAND2

(

...

)

Value:

INTERNAL_CATCH_NO##__VA_ARGS__

INTERNAL_CATCH_GET_1_ARG

#define INTERNAL_CATCH_GET_1_ARG	(		arg1,
			arg2,
			... )

Value:

arg1

INTERNAL_CATCH_GET_2_ARG

#define INTERNAL_CATCH_GET_2_ARG	(		arg1,
			arg2,
			... )

Value:

arg2

INTERNAL_CATCH_IF

#define INTERNAL_CATCH_IF	(		macroName,
			resultDisposition,
			... )

Value:

    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
    if( Catch::getResultCapture().lastAssertionPassed() )

INTERNAL_CATCH_INFO

#define INTERNAL_CATCH_INFO	(		macroName,
			log )

Value:

    const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )

INTERNAL_CATCH_MAKE_NAMESPACE

#define INTERNAL_CATCH_MAKE_NAMESPACE

(

name

)

Value:

INTERNAL_CATCH_MAKE_NAMESPACE2(name)

INTERNAL_CATCH_MAKE_NAMESPACE2

#define INTERNAL_CATCH_MAKE_NAMESPACE2

(

...

)

Value:

ns_##__VA_ARGS__

INTERNAL_CATCH_MAKE_TYPE_LIST

#define INTERNAL_CATCH_MAKE_TYPE_LIST

(

...

)

Value:

INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))

INTERNAL_CATCH_MAKE_TYPE_LIST2

#define INTERNAL_CATCH_MAKE_TYPE_LIST2

(

...

)

Value:

decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())

INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES

#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES

(

...

)

Value:

    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)

INTERNAL_CATCH_METHOD_AS_TEST_CASE

#define INTERNAL_CATCH_METHOD_AS_TEST_CASE	(		QualifiedMethod,
			... )

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        namespace {                                                           \
        const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
            Catch::makeTestInvoker( &QualifiedMethod ),                   \
            CATCH_INTERNAL_LINEINFO,                                      \
            "&" #QualifiedMethod##_catch_sr,                              \
            Catch::NameAndTags{ __VA_ARGS__ } );                          \
    } /* NOLINT */ \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

INTERNAL_CATCH_MSG

#define INTERNAL_CATCH_MSG	(		macroName,
			messageType,
			resultDisposition,
			... )

Value:

    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
        catchAssertionHandler.complete(); \
    } while( false )

INTERNAL_CATCH_NO_THROW

#define INTERNAL_CATCH_NO_THROW	(		macroName,
			resultDisposition,
			... )

Value:

    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
        try { \
            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
            CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
            static_cast<void>(__VA_ARGS__); \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
        } \
        catch( ... ) { \
            catchAssertionHandler.handleUnexpectedInflightException(); \
        } \
        catchAssertionHandler.complete(); \
    } while( false )

INTERNAL_CATCH_NOINTERNAL_CATCH_DEF

#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF

INTERNAL_CATCH_NTTP_0

#define INTERNAL_CATCH_NTTP_0

INTERNAL_CATCH_NTTP_1

#define INTERNAL_CATCH_NTTP_1	(		signature,
			... )

Value:

    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
    \
    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };

INTERNAL_CATCH_NTTP_GEN

#define INTERNAL_CATCH_NTTP_GEN

(

...

)

Value:

INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)

INTERNAL_CATCH_NTTP_REG_GEN

#define INTERNAL_CATCH_NTTP_REG_GEN	(		TestFunc,
			... )

Value:

INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)

INTERNAL_CATCH_NTTP_REG_METHOD_GEN

#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN	(		TestName,
			... )

Value:

INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)

INTERNAL_CATCH_NTTP_REGISTER

#define INTERNAL_CATCH_NTTP_REGISTER	(		TestFunc,
			signature,
			... )

Value:

    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
    }

INTERNAL_CATCH_NTTP_REGISTER0

#define INTERNAL_CATCH_NTTP_REGISTER0	(		TestFunc,
			signature )

Value:

    template<typename Type>\
    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
    }

INTERNAL_CATCH_NTTP_REGISTER_METHOD

#define INTERNAL_CATCH_NTTP_REGISTER_METHOD	(		TestName,
			signature,
			... )

Value:

    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
    }

INTERNAL_CATCH_NTTP_REGISTER_METHOD0

#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0	(		TestName,
			signature,
			... )

Value:

    template<typename Type>\
    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
    {\
        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
    }

INTERNAL_CATCH_REGISTER_ENUM

#define INTERNAL_CATCH_REGISTER_ENUM	(		enumName,
			... )

Value:

namespace Catch { \
    template<> struct StringMaker<enumName> { \
        static std::string convert( enumName value ) { \
            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
        } \
    }; \
}

INTERNAL_CATCH_REGISTER_TESTCASE

#define INTERNAL_CATCH_REGISTER_TESTCASE	(		Function,
			... )

Value:

        do { \
            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
            CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
            CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        } while(false)

INTERNAL_CATCH_REMOVE_PARENS

#define INTERNAL_CATCH_REMOVE_PARENS

(

...

)

Value:

    INTERNAL_CATCH_EXPAND1( INTERNAL_CATCH_DEF __VA_ARGS__ )

INTERNAL_CATCH_REMOVE_PARENS_10_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG	(		_0,
			_1,
			_2,
			_3,
			_4,
			_5,
			_6,
			_7,
			_8,
			_9 )

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)

INTERNAL_CATCH_REMOVE_PARENS_11_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG	(		_0,
			_1,
			_2,
			_3,
			_4,
			_5,
			_6,
			_7,
			_8,
			_9,
			_10 )

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)

INTERNAL_CATCH_REMOVE_PARENS_1_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG

(

_0

)

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0)

INTERNAL_CATCH_REMOVE_PARENS_2_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG	(		_0,
			_1 )

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)

INTERNAL_CATCH_REMOVE_PARENS_3_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG	(		_0,
			_1,
			_2 )

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)

INTERNAL_CATCH_REMOVE_PARENS_4_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG	(		_0,
			_1,
			_2,
			_3 )

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)

INTERNAL_CATCH_REMOVE_PARENS_5_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG	(		_0,
			_1,
			_2,
			_3,
			_4 )

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)

INTERNAL_CATCH_REMOVE_PARENS_6_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG	(		_0,
			_1,
			_2,
			_3,
			_4,
			_5 )

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)

INTERNAL_CATCH_REMOVE_PARENS_7_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG	(		_0,
			_1,
			_2,
			_3,
			_4,
			_5,
			_6 )

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)

INTERNAL_CATCH_REMOVE_PARENS_8_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG	(		_0,
			_1,
			_2,
			_3,
			_4,
			_5,
			_6,
			_7 )

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)

INTERNAL_CATCH_REMOVE_PARENS_9_ARG

#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG	(		_0,
			_1,
			_2,
			_3,
			_4,
			_5,
			_6,
			_7,
			_8 )

Value:

INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)

INTERNAL_CATCH_REMOVE_PARENS_GEN

#define INTERNAL_CATCH_REMOVE_PARENS_GEN

(

...

)

Value:

INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)

INTERNAL_CATCH_SECTION

#define INTERNAL_CATCH_SECTION

(

...

)

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                         \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                  \
        if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME(            \
                 catch_internal_Section ) =                               \
                 Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

INTERNAL_CATCH_STRINGIZE

#define INTERNAL_CATCH_STRINGIZE

(

...

)

Value:

INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)

INTERNAL_CATCH_STRINGIZE2

#define INTERNAL_CATCH_STRINGIZE2

(

...

)

Value:

#__VA_ARGS__

INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS

#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS

(

param

)

Value:

INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))

INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE

#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE	(		Name,
			Tags,
			TmplList )

Value:

        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, TmplList )

INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2

#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2	(		TestName,
			TestFunc,
			Name,
			Tags,
			TmplList )

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        template<typename TestType> static void TestFunc();       \
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
        INTERNAL_CATCH_TYPE_GEN\
        template<typename... Types>                               \
        struct TestName {                                         \
            void reg_tests() {                                          \
                size_t index = 0;                                    \
                using expander = size_t[];                           \
                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
            }                                                     \
        };\
        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
                using TestInit = typename convert<TestName, TmplList>::type; \
                TestInit t;                                           \
                t.reg_tests();                                        \
                return 0;                                             \
            }();                                                      \
        }}\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
        template<typename TestType>                                   \
        static void TestFunc()

INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD

#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD	(		ClassName,
			Name,
			Tags,
			TmplList )

Value:

        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, TmplList )

INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2

#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2	(		TestNameClass,
			TestName,
			ClassName,
			Name,
			Tags,
			TmplList )

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        template<typename TestType> \
        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
            void test();\
        };\
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
            INTERNAL_CATCH_TYPE_GEN\
            template<typename...Types>\
            struct TestNameClass{\
                void reg_tests(){\
                    size_t index = 0;\
                    using expander = size_t[];\
                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName##_catch_sr, Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
                using TestInit = typename convert<TestNameClass, TmplList>::type;\
                TestInit t;\
                t.reg_tests();\
                return 0;\
            }(); \
        }}\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        template<typename TestType> \
        void TestName<TestType>::test()

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE

#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE	(		Name,
			Tags,
			... )

Value:

        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T,__VA_ARGS__)

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2

#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2	(		TestName,
			TestFuncName,
			Name,
			Tags,
			Signature,
			TmplTypes,
			TypesList )

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD

#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD	(		ClassName,
			Name,
			Tags,
			... )

Value:

        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2

#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2	(		TestNameClass,
			TestName,
			ClassName,
			Name,
			Tags,
			Signature,
			TmplTypes,
			TypesList )

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG

#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG	(		ClassName,
			Name,
			Tags,
			Signature,
			... )

Value:

        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG

#define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG	(		Name,
			Tags,
			Signature,
			... )

Value:

        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__)

INTERNAL_CATCH_TEMPLATE_TEST_CASE

#define INTERNAL_CATCH_TEMPLATE_TEST_CASE	(		Name,
			Tags,
			... )

Value:

        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )

INTERNAL_CATCH_TEMPLATE_TEST_CASE_2

#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2	(		TestName,
			TestFunc,
			Name,
			Tags,
			Signature,
			... )

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
            INTERNAL_CATCH_TYPE_GEN\
            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            template<typename...Types> \
            struct TestName{\
                TestName(){\
                    size_t index = 0;                                    \
                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
                    using expander = size_t[]; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
            return 0;\
        }();\
        }\
        }\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))

INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD

#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD	(		ClassName,
			Name,
			Tags,
			... )

Value:

        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )

INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2

#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2	(		TestNameClass,
			TestName,
			ClassName,
			Name,
			Tags,
			Signature,
			... )

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        namespace {\
        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
            INTERNAL_CATCH_TYPE_GEN\
            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
            template<typename...Types> \
            struct TestNameClass{\
                TestNameClass(){\
                    size_t index = 0;                                    \
                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
                    using expander = size_t[];\
                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
                return 0;\
        }();\
        }\
        }\
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))

INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG

#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG	(		ClassName,
			Name,
			Tags,
			Signature,
			... )

Value:

        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )

INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG

#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG	(		Name,
			Tags,
			Signature,
			... )

Value:

        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )

INTERNAL_CATCH_TEST

#define INTERNAL_CATCH_TEST	(		macroName,
			resultDisposition,
			... )

Value:

    do { /* NOLINT(bugprone-infinite-loop) */ \
        /* The expression should not be evaluated, but warnings should hopefully be checked */ \
        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
        INTERNAL_CATCH_TRY { \
            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
        catchAssertionHandler.complete(); \
    } while( (void)0, (false) && static_cast<const bool&>( !!(__VA_ARGS__) ) )

INTERNAL_CATCH_TEST_CASE_METHOD

#define INTERNAL_CATCH_TEST_CASE_METHOD	(		ClassName,
			... )

Value:

        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )

INTERNAL_CATCH_TEST_CASE_METHOD2

#define INTERNAL_CATCH_TEST_CASE_METHOD2	(		TestName,
			ClassName,
			... )

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        namespace{ \
            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                void test(); \
            }; \
            const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
            Catch::makeTestInvoker( &TestName::test ),                    \
            CATCH_INTERNAL_LINEINFO,                                      \
            #ClassName##_catch_sr,                                        \
            Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
        } \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        void TestName::test()

INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE

#define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE	(		ClassName,
			... )

Value:

        INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )

INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2

#define INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE2	(		TestName,
			ClassName,
			... )

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                             \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                              \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS                      \
        namespace {                                                           \
            struct TestName : INTERNAL_CATCH_REMOVE_PARENS( ClassName ) {     \
                void test() const;                                            \
            };                                                                \
            const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
                Catch::makeTestInvokerFixture( &TestName::test ),                    \
                CATCH_INTERNAL_LINEINFO,                                      \
                #ClassName##_catch_sr,                                        \
                Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */             \
        }                                                                     \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                              \
        void TestName::test() const

INTERNAL_CATCH_TESTCASE

#define INTERNAL_CATCH_TESTCASE

(

...

)

Value:

        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__ )

INTERNAL_CATCH_TESTCASE2

#define INTERNAL_CATCH_TESTCASE2	(		TestName,
			... )

Value:

        static void TestName(); \
        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
        CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
        namespace{ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        static void TestName()

INTERNAL_CATCH_THROWS

#define INTERNAL_CATCH_THROWS	(		macroName,
			resultDisposition,
			... )

Value:

    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
                static_cast<void>(__VA_ARGS__); \
                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleExceptionThrownAsExpected(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        catchAssertionHandler.complete(); \
    } while( false )

INTERNAL_CATCH_THROWS_AS

#define INTERNAL_CATCH_THROWS_AS	(		macroName,
			exceptionType,
			resultDisposition,
			expr )

Value:

    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
                static_cast<void>(expr); \
                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( exceptionType const& ) { \
                catchAssertionHandler.handleExceptionThrownAsExpected(); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleUnexpectedInflightException(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        catchAssertionHandler.complete(); \
    } while( false )

INTERNAL_CATCH_THROWS_STR_MATCHES

#define INTERNAL_CATCH_THROWS_STR_MATCHES	(		macroName,
			resultDisposition,
			matcher,
			... )

Value:

    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
                CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
                CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
                static_cast<void>(__VA_ARGS__); \
                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( ... ) { \
                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher ); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        catchAssertionHandler.complete(); \
    } while( false )

INTERNAL_CATCH_TRANSLATE_EXCEPTION

#define INTERNAL_CATCH_TRANSLATE_EXCEPTION

(

signature

)

Value:

INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )

INTERNAL_CATCH_TRANSLATE_EXCEPTION2

#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2	(		translatorName,
			signature )

Value:

    static std::string translatorName( signature ); \
    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
    static std::string translatorName( signature )

INTERNAL_CATCH_TRY

#define INTERNAL_CATCH_TRY

INTERNAL_CATCH_TYPE_GEN

#define INTERNAL_CATCH_TYPE_GEN

INTERNAL_CATCH_UNIQUE_NAME

#define INTERNAL_CATCH_UNIQUE_NAME

(

name

)

Value:

INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )

INTERNAL_CATCH_UNIQUE_NAME_LINE

#define INTERNAL_CATCH_UNIQUE_NAME_LINE	(		name,
			line )

Value:

INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )

INTERNAL_CATCH_UNIQUE_NAME_LINE2

#define INTERNAL_CATCH_UNIQUE_NAME_LINE2	(		name,
			line )

Value:

name##line

INTERNAL_CATCH_UNSCOPED_INFO

#define INTERNAL_CATCH_UNSCOPED_INFO	(		macroName,
			log )

Value:

    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )

INTERNAL_CATCH_VA_NARGS_IMPL

#define INTERNAL_CATCH_VA_NARGS_IMPL	(		_0,
			_1,
			_2,
			_3,
			_4,
			_5,
			_6,
			_7,
			_8,
			_9,
			_10,
			N,
			... )

Value:

N

METHOD_AS_TEST_CASE

#define METHOD_AS_TEST_CASE	(		method,
			... )

Value:

INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )

REGISTER_TEST_CASE

#define REGISTER_TEST_CASE	(		Function,
			... )

Value:

INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )

REQUIRE

#define REQUIRE

(

...

)

Value:

INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )

REQUIRE_FALSE

#define REQUIRE_FALSE

(

...

)

Value:

INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )

REQUIRE_NOTHROW

#define REQUIRE_NOTHROW

(

...

)

Value:

INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )

REQUIRE_THROWS

#define REQUIRE_THROWS

(

...

)

Value:

INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )

REQUIRE_THROWS_AS

#define REQUIRE_THROWS_AS	(		expr,
			exceptionType )

Value:

INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )

SCENARIO

#define SCENARIO

(

...

)

Value:

TEST_CASE( "Scenario: " __VA_ARGS__ )

SCENARIO_METHOD

#define SCENARIO_METHOD	(		className,
			... )

Value:

INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )

SECTION

#define SECTION

(

...

)

Value:

INTERNAL_CATCH_SECTION( __VA_ARGS__ )

SizedUnsignedTypeHelper

#define SizedUnsignedTypeHelper

(

TYPE

)

Value:

    template <>                                \
    struct SizedUnsignedType<sizeof( TYPE )> { \
        using type = TYPE;                     \
    }

SKIP

#define SKIP

(

...

)

Value:

INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )

STATIC_CHECK

#define STATIC_CHECK

(

...

)

Value:

static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )

STATIC_CHECK_FALSE

#define STATIC_CHECK_FALSE

(

...

)

Value:

static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )

STATIC_REQUIRE

#define STATIC_REQUIRE

(

...

)

Value:

static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )

STATIC_REQUIRE_FALSE

#define STATIC_REQUIRE_FALSE

(

...

)

Value:

static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )

SUCCEED

#define SUCCEED

(

...

)

Value:

INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )

TEMPLATE_LIST_TEST_CASE

#define TEMPLATE_LIST_TEST_CASE

(

...

)

Value:

INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)

TEMPLATE_LIST_TEST_CASE_METHOD

#define TEMPLATE_LIST_TEST_CASE_METHOD	(		className,
			... )

Value:

INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )

TEMPLATE_PRODUCT_TEST_CASE

#define TEMPLATE_PRODUCT_TEST_CASE

(

...

)

Value:

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )

TEMPLATE_PRODUCT_TEST_CASE_METHOD

#define TEMPLATE_PRODUCT_TEST_CASE_METHOD	(		className,
			... )

Value:

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )

TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG

#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG	(		className,
			... )

Value:

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )

TEMPLATE_PRODUCT_TEST_CASE_SIG

#define TEMPLATE_PRODUCT_TEST_CASE_SIG

(

...

)

Value:

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )

TEMPLATE_TEST_CASE

#define TEMPLATE_TEST_CASE

(

...

)

Value:

INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )

TEMPLATE_TEST_CASE_METHOD

#define TEMPLATE_TEST_CASE_METHOD	(		className,
			... )

Value:

INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )

TEMPLATE_TEST_CASE_METHOD_SIG

#define TEMPLATE_TEST_CASE_METHOD_SIG	(		className,
			... )

Value:

INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )

TEMPLATE_TEST_CASE_SIG

#define TEMPLATE_TEST_CASE_SIG

(

...

)

Value:

INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )

TEST_CASE

#define TEST_CASE

(

...

)

Value:

INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )

TEST_CASE_METHOD

#define TEST_CASE_METHOD	(		className,
			... )

Value:

INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )

TEST_CASE_PERSISTENT_FIXTURE

#define TEST_CASE_PERSISTENT_FIXTURE	(		className,
			... )

Value:

INTERNAL_CATCH_TEST_CASE_PERSISTENT_FIXTURE( className, __VA_ARGS__ )

THEN

#define THEN

(

desc

)

Value:

INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )

UNSCOPED_INFO

#define UNSCOPED_INFO

(

msg

)

Value:

INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )

WARN

#define WARN

(

msg

)

Value:

INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )

WHEN

#define WHEN

(

desc

)

Value:

INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )

Function Documentation

operator""_catch_sr()

auto operator""_catch_sr ( char const * rawChars, std::size_t size ) -> Catch::StringRef

constexprnoexcept

operator<<()

std::ostream & operator<<	(	std::ostream &	,
		Catch_global_namespace_dummy	)