catch_amalgamated.hpp File Reference

This is a convenience header for Catch2. More...

#include <cstddef>
#include <string>
#include <iosfwd>
#include <cassert>
#include <chrono>
#include <vector>
#include <type_traits>
#include <cstdint>
#include <map>
#include <ratio>
#include <algorithm>
#include <iterator>
#include <numeric>
#include <tuple>
#include <cmath>
#include <functional>
#include <string.h>
#include <ostream>
#include <ctime>
#include <memory>
#include <sstream>
#include <exception>
#include <random>
#include <initializer_list>
#include <utility>
#include <limits>
#include <set>
#include <cstdio>
#include <array>
#include <cstring>

Go to the source code of this file.

Classes
class	Catch::Detail::NonCopyable
	Deriving classes become noncopyable and nonmovable. More...
class	Catch::StringRef
	A non-owning string class (similar to the forthcoming std::string_view) Note that, because a StringRef may be a substring of another string, it may not be null terminated. More...
struct	Catch::WarnAbout
struct	Catch::WaitForKeypress
class	Catch::IConfig
class	Catch::IContext
class	Catch::IMutableContext
struct	Catch::SourceLineInfo
struct	Catch::Counts
struct	Catch::Totals
struct	Catch::SectionInfo
struct	Catch::SectionEndInfo
struct	Catch::ResultWas
struct	Catch::ResultDisposition
struct	Catch::AssertionInfo
class	Catch::LazyExpression
struct	Catch::AssertionResultData
class	Catch::AssertionResult
class	Catch::IResultCapture
struct	Catch::MessageInfo
class	Catch::Detail::unique_ptr< T >
	A reimplementation of std::unique_ptr for improved compilation performance. More...
struct	Catch::Benchmark::Estimate< Duration >
struct	Catch::Benchmark::OutlierClassification
struct	Catch::ReporterConfig
struct	Catch::TestRunInfo
struct	Catch::AssertionStats
struct	Catch::SectionStats
struct	Catch::TestCaseStats
struct	Catch::TestRunStats
struct	Catch::BenchmarkInfo
struct	Catch::BenchmarkStats< Duration >
struct	Catch::ReporterPreferences
class	Catch::IEventListener
	The common base for all reporters and event listeners. More...
struct	Catch::Benchmark::now< Clock >
struct	Catch::TestFailureException
	Used to signal that an assertion macro failed. More...
struct	Catch::always_false< T >
struct	Catch::true_given< typename >
struct	Catch::is_callable_tester
struct	Catch::is_callable< Fun(Args...)>
class	Catch::IRegistryHub
class	Catch::IMutableRegistryHub
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::Detail::ChronometerConcept
struct	Catch::Benchmark::Detail::ChronometerModel< Clock >
struct	Catch::Benchmark::Chronometer
struct	Catch::Benchmark::EnvironmentEstimate< Duration >
struct	Catch::Benchmark::Environment< Clock >
struct	Catch::Benchmark::Detail::is_related< T, U >
struct	Catch::Benchmark::Detail::BenchmarkFunction
	We need to reinvent std::function because every piece of code that might add overhead in a measurement context needs to have consistent performance characteristics so that we can account for it in the measurement. More...
struct	Catch::Benchmark::Detail::repeater< Fun >
struct	Catch::Benchmark::Timing< Duration, Result >
struct	Catch::Benchmark::ExecutionPlan< Duration >
struct	Catch::Benchmark::Detail::bootstrap_analysis
struct	Catch::Benchmark::SampleAnalysis< Duration >
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 >
class	Catch::WildcardPattern
class	Catch::TestSpec
struct	Catch::TestSpec::FilterMatch
class	Catch::Optional< T >
struct	Catch::Colour
class	Catch::ColourImpl
class	Catch::ColourImpl::ColourGuard
class	Catch::ReporterSpec
	Structured reporter spec that a reporter can be created from. More...
struct	Catch::ProcessedReporterSpec
	ReporterSpec but with the defaults filled in. More...
struct	Catch::ConfigData
class	Catch::Config
struct	Catch::StreamEndStop
struct	Catch::MessageStream
struct	Catch::MessageBuilder
class	Catch::ScopedMessage
class	Catch::Capturer
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
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::ITestCaseRegistry
class	Catch::TestInvokerAsMethod< C >
struct	Catch::NameAndTags
struct	Catch::AutoReg
struct	Catch::Tag
	A view of a tag string that provides case insensitive comparisons. More...
struct	Catch::TestCaseInfo
	Various metadata about the test case. More...
class	Catch::TestCaseHandle
	Wrapper over the test case information and the test case invoker. More...
class	Catch::IExceptionTranslator
class	Catch::IExceptionTranslatorRegistry
class	Catch::ExceptionTranslatorRegistrar
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
class	Catch::Generators::RandomFloatingGenerator< Float >
class	Catch::Generators::RandomIntegerGenerator< Integer >
class	Catch::Generators::RangeGenerator< T >
class	Catch::Generators::IteratorGenerator< T >
class	Catch::IReporterFactory
class	Catch::EventListenerFactory
struct	Catch::Detail::CaseInsensitiveLess
	Provides case-insensitive op< semantics when called. More...
struct	Catch::Detail::CaseInsensitiveEqualTo
	Provides case-insensitive op== semantics when called. More...
class	Catch::IReporterRegistry
class	Catch::ITagAliasRegistry
class	Catch::Detail::EnumValuesRegistry
class	Catch::ErrnoGuard
class	Catch::ExceptionTranslatorRegistry
class	Catch::FatalConditionHandler
	Wrapper for platform-specific fatal error (signals/SEH) handlers. More...
class	Catch::FatalConditionHandlerGuard
	Simple RAII guard for (dis)engaging the FatalConditionHandler. More...
class	Catch::IStream
struct	Catch::LeakDetector
struct	Catch::ReporterDescription
struct	Catch::ListenerDescription
struct	Catch::TagInfo
class	Catch::RedirectedStream
class	Catch::RedirectedStdOut
class	Catch::RedirectedStdErr
class	Catch::RedirectedStreams
class	Catch::ReporterRegistry
struct	Catch::TestCaseTracking::NameAndLocation
class	Catch::TestCaseTracking::ITracker
class	Catch::TestCaseTracking::TrackerContext
class	Catch::TestCaseTracking::TrackerBase
class	Catch::TestCaseTracking::SectionTracker
class	Catch::RunContext
struct	Catch::ISingleton
class	Catch::Singleton< SingletonImplT, InterfaceT, MutableInterfaceT >
class	Catch::StartupExceptionRegistry
class	Catch::pluralise
	Helper for streaming a "count [maybe-plural-of-label]" human-friendly string. More...
class	Catch::TagAliasRegistry
class	Catch::TestCaseInfoHasher
class	Catch::TestRegistry
class	Catch::TestInvokerAsFunction
class	Catch::TestSpecParser
class	Catch::TextFlow::Column
	Represents a column of text with specific width and indentation. More...
class	Catch::TextFlow::Column::const_iterator
	Iterates "lines" in Column and return sthem. More...
class	Catch::TextFlow::Columns
class	Catch::TextFlow::Columns::iterator
class	Catch::XmlEncode
	Helper for XML-encoding text (escaping angle brackets, quotes, etc). More...
class	Catch::XmlWriter
class	Catch::XmlWriter::ScopedElement
class	Catch::MatchExpr< ArgT, MatcherT >
class	Catch::Matchers::MatcherUntypedBase
class	Catch::Matchers::MatcherBase< T >
class	Catch::Matchers::Detail::MatchAllOf< ArgT >
class	Catch::Matchers::Detail::MatchAnyOf< ArgT >
class	Catch::Matchers::Detail::MatchNotOf< ArgT >
class	Catch::Matchers::MatcherGenericBase
struct	Catch::Matchers::Detail::conjunction< Cond >
struct	Catch::Matchers::Detail::conjunction< Cond, Rest... >
class	Catch::Matchers::Detail::MatchAllOfGeneric< MatcherTs >
class	Catch::Matchers::Detail::MatchAnyOfGeneric< MatcherTs >
class	Catch::Matchers::Detail::MatchNotOfGeneric< MatcherT >
class	Catch::Matchers::IsEmptyMatcher
class	Catch::Matchers::HasSizeMatcher
class	Catch::Matchers::SizeMatchesMatcher< Matcher >
class	Catch::Matchers::ContainsElementMatcher< T, Equality >
	Matcher for checking that an element in range is equal to specific element. More...
class	Catch::Matchers::ContainsMatcherMatcher< Matcher >
	Meta-matcher for checking that an element in a range matches a specific matcher. More...
class	Catch::Matchers::ExceptionMessageMatcher
class	Catch::Matchers::WithinAbsMatcher
class	Catch::Matchers::WithinUlpsMatcher
class	Catch::Matchers::WithinRelMatcher
class	Catch::Matchers::PredicateMatcher< T, Predicate >
class	Catch::Matchers::AllMatchMatcher< Matcher >
class	Catch::Matchers::NoneMatchMatcher< Matcher >
class	Catch::Matchers::AnyMatchMatcher< Matcher >
struct	Catch::Matchers::CasedString
class	Catch::Matchers::StringMatcherBase
class	Catch::Matchers::StringEqualsMatcher
class	Catch::Matchers::StringContainsMatcher
class	Catch::Matchers::StartsWithMatcher
class	Catch::Matchers::EndsWithMatcher
class	Catch::Matchers::RegexMatcher
class	Catch::Matchers::VectorContainsElementMatcher< T, Alloc >
class	Catch::Matchers::ContainsMatcher< T, AllocComp, AllocMatch >
class	Catch::Matchers::EqualsMatcher< T, AllocComp, AllocMatch >
class	Catch::Matchers::ApproxMatcher< T, AllocComp, AllocMatch >
class	Catch::Matchers::UnorderedEqualsMatcher< T, AllocComp, AllocMatch >
class	Catch::ReporterBase
	This is the base class for all reporters. More...
class	Catch::StreamingReporterBase
class	Catch::AutomakeReporter
class	Catch::CompactReporter
class	Catch::ConsoleReporter
class	Catch::Detail::AssertionOrBenchmarkResult
	Represents either an assertion or a benchmark result to be handled by cumulative reporter later. More...
class	Catch::CumulativeReporterBase
	Utility base for reporters that need to handle all results at once. More...
struct	Catch::CumulativeReporterBase::Node< T, ChildNodeT >
struct	Catch::CumulativeReporterBase::SectionNode
class	Catch::EventListenerBase
	Base class to simplify implementing listeners. More...
struct	Catch::lineOfChars
class	Catch::JunitReporter
class	Catch::MultiReporter
struct	Catch::Detail::has_description< T, typename >
struct	Catch::Detail::has_description< T, void_t< decltype(T::getDescription())> >
class	Catch::ReporterFactory< T >
class	Catch::ReporterRegistrar< T >
class	Catch::ListenerRegistrar< T >
class	Catch::SonarQubeReporter
class	Catch::TAPReporter
class	Catch::TeamCityReporter
class	Catch::XmlReporter
class	Catch::ITracker
class	Catch::TrackerContext
class	Catch::SectionTracker

Macros
#define	CATCH_ALL_HPP_INCLUDED
#define	CATCH_BENCHMARK_ALL_HPP_INCLUDED
#define	CATCH_BENCHMARK_HPP_INCLUDED
#define	CATCH_INTERFACES_CONFIG_HPP_INCLUDED
#define	CATCH_NONCOPYABLE_HPP_INCLUDED
#define	CATCH_STRINGREF_HPP_INCLUDED
#define	CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
#define	CATCH_PLATFORM_HPP_INCLUDED
#define	CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
#define	CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
#define	CATCH_CONFIG_POSIX_SIGNALS
#define	CATCH_CONFIG_CPP11_TO_STRING
#define	CATCH_CONFIG_DISABLE_EXCEPTIONS
#define	CATCH_CONFIG_GLOBAL_NEXTAFTER
#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_VARIABLE_WARNINGS
#define	CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
#define	CATCH_INTERNAL_IGNORE_BUT_WARN(...)
#define	CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
#define	CATCH_TRY   if ((true))
#define	CATCH_CATCH_ALL   if ((false))
#define	CATCH_CATCH_ANON(type)
#define	CATCH_CONTEXT_HPP_INCLUDED
#define	CATCH_INTERFACES_REPORTER_HPP_INCLUDED
#define	CATCH_SECTION_INFO_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_SOURCE_LINE_INFO_HPP_INCLUDED
#define	CATCH_INTERNAL_LINEINFO    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
#define	CATCH_TOTALS_HPP_INCLUDED
#define	CATCH_ASSERTION_RESULT_HPP_INCLUDED
#define	CATCH_ASSERTION_INFO_HPP_INCLUDED
#define	CATCH_RESULT_TYPE_HPP_INCLUDED
#define	CATCH_LAZY_EXPR_HPP_INCLUDED
#define	CATCH_MESSAGE_INFO_HPP_INCLUDED
#define	CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
#define	CATCH_UNIQUE_PTR_HPP_INCLUDED
#define	CATCH_ESTIMATE_HPP_INCLUDED
#define	CATCH_OUTLIER_CLASSIFICATION_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_CHRONOMETER_HPP_INCLUDED
#define	CATCH_CLOCK_HPP_INCLUDED
#define	CATCH_OPTIMIZER_HPP_INCLUDED
#define	CATCH_COMPLETE_INVOKE_HPP_INCLUDED
#define	CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
#define	CATCH_META_HPP_INCLUDED
#define	CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
#define	CATCH_ENVIRONMENT_HPP_INCLUDED
#define	CATCH_EXECUTION_PLAN_HPP_INCLUDED
#define	CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
#define	CATCH_REPEAT_HPP_INCLUDED
#define	CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
#define	CATCH_MEASURE_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_CONFIG_HPP_INCLUDED
#define	CATCH_TEST_SPEC_HPP_INCLUDED
#define	CATCH_WILDCARD_PATTERN_HPP_INCLUDED
#define	CATCH_CASE_SENSITIVE_HPP_INCLUDED
#define	CATCH_OPTIONAL_HPP_INCLUDED
#define	CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
#define	CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
#define	CATCH_CONSOLE_COLOUR_HPP_INCLUDED
#define	CATCH_MESSAGE_HPP_INCLUDED
#define	CATCH_STREAM_END_STOP_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_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_INTERNAL_DEFINE_EXPRESSION_OPERATOR(op)
#define	CATCH_INTERNAL_STRINGIFY(...)
#define	INTERNAL_CATCH_TRY
#define	INTERNAL_CATCH_CATCH(capturer)
#define	INTERNAL_CATCH_REACT(handler)
#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_TIMER_HPP_INCLUDED
#define	INTERNAL_CATCH_SECTION(...)
#define	INTERNAL_CATCH_DYNAMIC_SECTION(...)
#define	CATCH_TEST_REGISTRY_HPP_INCLUDED
#define	CATCH_INTERFACES_TESTCASE_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_METHOD_AS_TEST_CASE(QualifiedMethod, ...)
#define	INTERNAL_CATCH_TEST_CASE_METHOD2(TestName, ClassName, ...)
#define	INTERNAL_CATCH_TEST_CASE_METHOD(ClassName, ...)
#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	REGISTER_TEST_CASE(Function, ...)
#define	SECTION(...)
#define	DYNAMIC_SECTION(...)
#define	FAIL(...)
#define	FAIL_CHECK(...)
#define	SUCCEED(...)
#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   0
#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	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_GENERATORS_RANGE_HPP_INCLUDED
#define	CATCH_INTERFACES_ALL_HPP_INCLUDED
#define	CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
#define	CATCH_INTERFACES_REPORTER_REGISTRY_HPP_INCLUDED
#define	CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
#define	CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
#define	CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
#define	CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
#define	CATCH_CONSOLE_WIDTH_HPP_INCLUDED
#define	CATCH_CONFIG_CONSOLE_WIDTH   80
#define	CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
#define	CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
#define	CATCH_DEBUG_CONSOLE_HPP_INCLUDED
#define	CATCH_DEBUGGER_HPP_INCLUDED
#define	CATCH_BREAK_INTO_DEBUGGER()
#define	CATCH_ENFORCE_HPP_INCLUDED
#define	CATCH_MAKE_MSG(...)
#define	CATCH_INTERNAL_ERROR(...)
#define	CATCH_ERROR(...)
#define	CATCH_RUNTIME_ERROR(...)
#define	CATCH_ENFORCE(condition, ...)
#define	CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
#define	CATCH_ERRNO_GUARD_HPP_INCLUDED
#define	CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
#define	CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
#define	CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
#define	CATCH_POLYFILLS_HPP_INCLUDED
#define	CATCH_ISTREAM_HPP_INCLUDED
#define	CATCH_LEAK_DETECTOR_HPP_INCLUDED
#define	CATCH_LIST_HPP_INCLUDED
#define	CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
#define	CATCH_REPORTER_REGISTRY_HPP_INCLUDED
#define	CATCH_RUN_CONTEXT_HPP_INCLUDED
#define	CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
#define	CATCH_SHARDING_HPP_INCLUDED
#define	CATCH_SINGLETONS_HPP_INCLUDED
#define	CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
#define	CATCH_STDSTREAMS_HPP_INCLUDED
#define	CATCH_STRING_MANIP_HPP_INCLUDED
#define	CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
#define	CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
#define	CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
#define	CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
#define	CATCH_TEXTFLOW_HPP_INCLUDED
#define	CATCH_TO_STRING_HPP_INCLUDED
#define	CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
#define	CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
#define	CATCH_XMLWRITER_HPP_INCLUDED
#define	CATCH_MATCHERS_ALL_HPP_INCLUDED
#define	CATCH_MATCHERS_HPP_INCLUDED
#define	CATCH_MATCHERS_IMPL_HPP_INCLUDED
#define	INTERNAL_CHECK_THAT(macroName, matcher, resultDisposition, arg)
#define	INTERNAL_CATCH_THROWS_MATCHES(macroName, exceptionType, resultDisposition, matcher, ...)
#define	REQUIRE_THROWS_WITH(expr, matcher)
#define	REQUIRE_THROWS_MATCHES(expr, exceptionType, matcher)
#define	CHECK_THROWS_WITH(expr, matcher)
#define	CHECK_THROWS_MATCHES(expr, exceptionType, matcher)
#define	CHECK_THAT(arg, matcher)
#define	REQUIRE_THAT(arg, matcher)
#define	CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
#define	CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
#define	CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
#define	CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
#define	CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
#define	CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
#define	CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
#define	CATCH_MATCHERS_STRING_HPP_INCLUDED
#define	CATCH_MATCHERS_VECTOR_HPP_INCLUDED
#define	CATCH_REPORTERS_ALL_HPP_INCLUDED
#define	CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
#define	CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
#define	CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
#define	CATCH_REPORTER_COMPACT_HPP_INCLUDED
#define	CATCH_REPORTER_CONSOLE_HPP_INCLUDED
#define	CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
#define	CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
#define	CATCH_REPORTER_HELPERS_HPP_INCLUDED
#define	CATCH_REPORTER_JUNIT_HPP_INCLUDED
#define	CATCH_REPORTER_MULTI_HPP_INCLUDED
#define	CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
#define	CATCH_REGISTER_REPORTER(name, reporterType)
#define	CATCH_REGISTER_LISTENER(listenerType)
#define	CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
#define	CATCH_REPORTER_TAP_HPP_INCLUDED
#define	CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
#define	CATCH_REPORTER_XML_HPP_INCLUDED

Typedefs
using	Catch::IEventListenerPtr = Detail::unique_ptr<IEventListener>
template<typename Clock>
using	Catch::Benchmark::ClockDuration = typename Clock::duration
template<typename Clock>
using	Catch::Benchmark::FloatDuration = std::chrono::duration<double, typename Clock::period>
template<typename Clock>
using	Catch::Benchmark::TimePoint = typename Clock::time_point
using	Catch::Benchmark::default_clock = std::chrono::steady_clock
using	Catch::Benchmark::fp_seconds = std::chrono::duration<double, std::ratio<1>>
template<typename Func, typename... U>
using	Catch::FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U...)>>>
using	Catch::IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>
template<typename T>
using	Catch::Benchmark::Detail::CompleteType_t = typename CompleteType<T>::type
template<typename Clock, typename Func, typename... Args>
using	Catch::Benchmark::TimingOf = Timing<ClockDuration<Clock>, 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>
using	Catch::exceptionTranslateFunction = std::string(*)()
using	Catch::ExceptionTranslators = std::vector<Detail::unique_ptr<IExceptionTranslator const>>
using	Catch::Generators::GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>
template<typename T>
using	Catch::Generators::GeneratorPtr = Catch::Detail::unique_ptr<IGenerator<T>>
using	Catch::TestCaseTracking::ITrackerPtr = Catch::Detail::unique_ptr<ITracker>
using	Catch::StringMatcher = Matchers::MatcherBase<std::string>
template<typename T>
using	Catch::Matchers::Detail::is_generic_matcher
template<typename... Ts>
using	Catch::Matchers::Detail::are_generic_matchers = conjunction<is_generic_matcher<Ts>...>
template<typename T>
using	Catch::Matchers::Detail::is_matcher
using	Catch::Clara::ParserResult

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

Functions
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
IMutableContext &	Catch::getCurrentMutableContext ()
IContext &	Catch::getCurrentContext ()
void	Catch::cleanUpContext ()
SimplePcg32 &	Catch::sharedRng ()
bool	Catch::isOk (ResultWas::OfType resultType)
bool	Catch::isJustInfo (int flags)
ResultDisposition::Flags	Catch::operator| (ResultDisposition::Flags lhs, ResultDisposition::Flags rhs)
bool	Catch::shouldContinueOnFailure (int flags)
bool	Catch::isFalseTest (int flags)
bool	Catch::shouldSuppressFailure (int flags)
IResultCapture &	Catch::getResultCapture ()
template<typename T, typename... Args>
unique_ptr< T >	Catch::Detail::make_unique (Args &&... args)
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 Fn, typename... Args>
auto	Catch::Benchmark::invoke_deoptimized (Fn &&fn, Args &&... args) -> std::enable_if_t< std::is_same< void, decltype(fn(args...))>::value >
IRegistryHub const &	Catch::getRegistryHub ()
IMutableRegistryHub &	Catch::getMutableRegistryHub ()
void	Catch::cleanUp ()
std::string	Catch::translateActiveException ()
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 Fun>
repeater< std::decay_t< Fun > >	Catch::Benchmark::Detail::repeat (Fun &&fun)
template<typename Clock, typename Fun, typename... Args>
TimingOf< Clock, Fun, Args... >	Catch::Benchmark::Detail::measure (Fun &&fun, Args &&... args)
template<typename Clock, typename Fun>
TimingOf< Clock, Fun, int >	Catch::Benchmark::Detail::measure_one (Fun &&fun, int iters, std::false_type)
template<typename Clock, typename Fun>
TimingOf< Clock, 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< Clock, Fun, run_for_at_least_argument_t< Clock, Fun > >	Catch::Benchmark::Detail::run_for_at_least (ClockDuration< Clock > how_long, const int initial_iterations, Fun &&fun)
bool	Catch::Benchmark::Detail::directCompare (double lhs, double rhs)
double	Catch::Benchmark::Detail::weighted_average_quantile (int k, int q, std::vector< double >::iterator first, std::vector< double >::iterator last)
template<typename Iterator>
OutlierClassification	Catch::Benchmark::Detail::classify_outliers (Iterator first, Iterator last)
template<typename Iterator>
double	Catch::Benchmark::Detail::mean (Iterator first, Iterator last)
template<typename Estimator, typename Iterator>
sample	Catch::Benchmark::Detail::jackknife (Estimator &&estimator, Iterator first, Iterator 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)
template<typename Iterator, typename Estimator>
Estimate< double >	Catch::Benchmark::Detail::bootstrap (double confidence_level, Iterator first, Iterator last, sample const &resample, Estimator &&estimator)
double	Catch::Benchmark::Detail::outlier_variance (Estimate< double > mean, Estimate< double > stddev, int n)
bootstrap_analysis	Catch::Benchmark::Detail::analyse_samples (double confidence_level, unsigned int n_resamples, std::vector< double >::iterator first, std::vector< double >::iterator 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< FloatDuration< Clock > >	Catch::Benchmark::Detail::estimate_clock_resolution (int iterations)
template<typename Clock>
EnvironmentEstimate< FloatDuration< Clock > >	Catch::Benchmark::Detail::estimate_clock_cost (FloatDuration< Clock > resolution)
template<typename Clock>
Environment< FloatDuration< Clock > >	Catch::Benchmark::Detail::measure_environment ()
template<typename Duration, typename Iterator>
SampleAnalysis< Duration >	Catch::Benchmark::Detail::analyse (const IConfig &cfg, Environment< Duration >, Iterator first, Iterator last)
std::ostream &	operator<< (std::ostream &, Catch_global_namespace_dummy)
std::string	Catch::Detail::convertIntoString (StringRef string, bool escapeInvisibles)
	Encases `string in quotes, and optionally escapes invisibles.
std::string	Catch::Detail::convertIntoString (StringRef string)
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)
Detail::unique_ptr< ColourImpl >	Catch::makeColourImpl (ColourMode colourSelection, IStream *stream)
	Provides ColourImpl based on global config and target compilation platform.
bool	Catch::isColourImplAvailable (ColourMode colourSelection)
	Checks if specific colour impl has been compiled into the binary.
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)
	Parses provided reporter spec string into.
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)
template<typename LhsT, typename RhsT>
auto	Catch::compareEqual (LhsT const &lhs, RhsT const &rhs) -> bool
template<typename T>
auto	Catch::compareEqual (T *const &lhs, int rhs) -> bool
template<typename T>
auto	Catch::compareEqual (T *const &lhs, long rhs) -> bool
template<typename T>
auto	Catch::compareEqual (int lhs, T *const &rhs) -> bool
template<typename T>
auto	Catch::compareEqual (long lhs, T *const &rhs) -> bool
template<typename LhsT, typename RhsT>
auto	Catch::compareNotEqual (LhsT const &lhs, RhsT &&rhs) -> bool
template<typename T>
auto	Catch::compareNotEqual (T *const &lhs, int rhs) -> bool
template<typename T>
auto	Catch::compareNotEqual (T *const &lhs, long rhs) -> bool
template<typename T>
auto	Catch::compareNotEqual (int lhs, T *const &rhs) -> bool
template<typename T>
auto	Catch::compareNotEqual (long lhs, T *const &rhs) -> bool
void	Catch::handleExceptionMatchExpr (AssertionHandler &handler, std::string const &str, StringRef matcherString)
bool	Catch::isThrowSafe (TestCaseHandle const &testCase, IConfig const &config)
bool	Catch::matchTest (TestCaseHandle const &testCase, TestSpec const &testSpec, IConfig const &config)
std::vector< TestCaseHandle >	Catch::filterTests (std::vector< TestCaseHandle > const &testCases, TestSpec const &testSpec, IConfig const &config)
std::vector< TestCaseHandle > const &	Catch::getAllTestCasesSorted (IConfig const &config)
Detail::unique_ptr< ITestInvoker >	Catch::makeTestInvoker (void(*testAsFunction)())
template<typename C>
Detail::unique_ptr< ITestInvoker >	Catch::makeTestInvoker (void(C::*testAsMethod)())
Detail::unique_ptr< TestCaseInfo >	Catch::makeTestCaseInfo (StringRef _className, NameAndTags const &nameAndTags, SourceLineInfo const &_lineInfo)
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 >
auto	Catch::Generators::acquireGeneratorTracker (StringRef generatorName, SourceLineInfo const &lineInfo) -> IGeneratorTracker &
template<typename L>
auto	Catch::Generators::generate (StringRef generatorName, SourceLineInfo const &lineInfo, L const &generatorExpression) -> decltype(std::declval< decltype(generatorExpression())>().get())
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)
std::uint32_t	Catch::Generators::Detail::getSeed ()
template<typename T>
std::enable_if_t< std::is_integral< T >::value &&!std::is_same< T, bool >::value, GeneratorWrapper< T > >	Catch::Generators::random (T a, T b)
template<typename T>
std::enable_if_t< std::is_floating_point< T >::value, GeneratorWrapper< T > >	Catch::Generators::random (T a, T b)
template<typename T>
GeneratorWrapper< T >	Catch::Generators::range (T const &start, T const &end, T const &step)
template<typename T>
GeneratorWrapper< T >	Catch::Generators::range (T const &start, T const &end)
template<typename InputIterator, typename InputSentinel, typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
GeneratorWrapper< ResultType >	Catch::Generators::from_range (InputIterator from, InputSentinel to)
template<typename Container, typename ResultType = typename Container::value_type>
GeneratorWrapper< ResultType >	Catch::Generators::from_range (Container const &cnt)
template<typename Container>
constexpr auto	Catch::Detail::empty (Container const &cont) -> decltype(cont.empty())
template<typename T, std::size_t N>
constexpr bool	Catch::Detail::empty (const T(&)[N]) noexcept
template<typename T>
constexpr bool	Catch::Detail::empty (std::initializer_list< T > list) noexcept
template<typename Container>
constexpr auto	Catch::Detail::size (Container const &cont) -> decltype(cont.size())
template<typename T, std::size_t N>
constexpr std::size_t	Catch::Detail::size (const T(&)[N]) noexcept
void	Catch::writeToDebugConsole (std::string const &text)
bool	Catch::isDebuggerActive ()
void	Catch::throw_exception (std::exception const &e)
void	Catch::throw_logic_error (std::string const &msg)
void	Catch::throw_domain_error (std::string const &msg)
void	Catch::throw_runtime_error (std::string const &msg)
Catch::Detail::unique_ptr< EnumInfo >	Catch::Detail::makeEnumInfo (StringRef enumName, StringRef allValueNames, std::vector< int > const &values)
std::vector< StringRef >	Catch::Detail::parseEnums (StringRef enums)
bool	Catch::isnan (float f)
bool	Catch::isnan (double d)
uint32_t	Catch::Detail::convertToBits (float f)
uint64_t	Catch::Detail::convertToBits (double d)
template<typename FP>
uint64_t	Catch::ulpDistance (FP lhs, FP rhs)
	Calculates the ULP distance between two floating point numbers.
auto	Catch::makeStream (std::string const &filename) -> Detail::unique_ptr< IStream >
	Creates a stream wrapper that writes to specific file.
bool	Catch::list (IEventListener &reporter, Config const &config)
void	Catch::seedRng (IConfig const &config)
unsigned int	Catch::rngSeed ()
template<typename Container>
Container	Catch::createShard (Container const &container, std::size_t const shardCount, std::size_t const shardIndex)
void	Catch::addSingleton (ISingleton *singleton)
void	Catch::cleanupSingletons ()
std::ostream &	Catch::cout ()
std::ostream &	Catch::cerr ()
std::ostream &	Catch::clog ()
bool	Catch::startsWith (std::string const &s, std::string const &prefix)
bool	Catch::startsWith (StringRef s, char prefix)
bool	Catch::endsWith (std::string const &s, std::string const &suffix)
bool	Catch::endsWith (std::string const &s, char suffix)
bool	Catch::contains (std::string const &s, std::string const &infix)
void	Catch::toLowerInPlace (std::string &s)
std::string	Catch::toLower (std::string const &s)
char	Catch::toLower (char c)
std::string	Catch::trim (std::string const &str)
	Returns a new string without whitespace at the start/end.
StringRef	Catch::trim (StringRef ref)
	Returns a substring of the original ref without whitespace. Beware lifetimes!
std::vector< StringRef >	Catch::splitStringRef (StringRef str, char delimiter)
bool	Catch::replaceInPlace (std::string &str, std::string const &replaceThis, std::string const &withThis)
std::vector< TestCaseHandle >	Catch::sortTests (IConfig const &config, std::vector< TestCaseHandle > const &unsortedTestCases)
void	Catch::enforceNoDuplicateTestCases (std::vector< TestCaseHandle > const &tests)
TestSpec	Catch::parseTestSpec (std::string const &arg)
Column	Catch::TextFlow::Spacer (size_t spaceWidth)
	Creates a column that serves as an empty space of specific width.
template<typename T>
std::string	Catch::to_string (T const &t)
bool	Catch::uncaught_exceptions ()
XmlFormatting	Catch::operator| (XmlFormatting lhs, XmlFormatting rhs)
XmlFormatting	Catch::operator& (XmlFormatting lhs, XmlFormatting rhs)
void	Catch::handleExceptionMatchExpr (AssertionHandler &handler, StringMatcher const &matcher, StringRef matcherString)
template<typename ArgT, typename MatcherT>
auto	Catch::makeMatchExpr (ArgT &&arg, MatcherT const &matcher, StringRef matcherString) -> MatchExpr< ArgT, MatcherT >
template<typename ArgT>
MatchAllOf< ArgT >	Catch::Matchers::Detail::operator&& (MatchAllOf< ArgT > const &lhs, MatcherBase< ArgT > const &rhs)=delete
template<typename ArgT>
MatchAllOf< ArgT >	Catch::Matchers::Detail::operator&& (MatcherBase< ArgT > const &lhs, MatchAllOf< ArgT > const &rhs)=delete
template<typename ArgT>
MatchAnyOf< ArgT >	Catch::Matchers::Detail::operator|| (MatchAnyOf< ArgT > const &lhs, MatcherBase< ArgT > const &rhs)=delete
template<typename ArgT>
MatchAnyOf< ArgT >	Catch::Matchers::Detail::operator|| (MatcherBase< ArgT > const &lhs, MatchAnyOf< ArgT > const &rhs)=delete
template<typename T>
Detail::MatchAllOf< T >	Catch::Matchers::operator&& (MatcherBase< T > const &lhs, MatcherBase< T > const &rhs)
template<typename T>
Detail::MatchAnyOf< T >	Catch::Matchers::operator|| (MatcherBase< T > const &lhs, MatcherBase< T > const &rhs)
template<typename T>
Detail::MatchNotOf< T >	Catch::Matchers::operator! (MatcherBase< T > const &matcher)
template<std::size_t N, std::size_t M>
std::array< void const *, N+M >	Catch::Matchers::Detail::array_cat (std::array< void const *, N > &&lhs, std::array< void const *, M > &&rhs)
template<std::size_t N>
std::array< void const *, N+1 >	Catch::Matchers::Detail::array_cat (std::array< void const *, N > &&lhs, void const *rhs)
template<std::size_t N>
std::array< void const *, N+1 >	Catch::Matchers::Detail::array_cat (void const *lhs, std::array< void const *, N > &&rhs)
template<std::size_t N, typename Arg>
bool	Catch::Matchers::Detail::match_all_of (Arg &&, std::array< void const *, N > const &, std::index_sequence<>)
template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
bool	Catch::Matchers::Detail::match_all_of (Arg &&arg, std::array< void const *, N > const &matchers, std::index_sequence< Idx, Indices... >)
template<std::size_t N, typename Arg>
bool	Catch::Matchers::Detail::match_any_of (Arg &&, std::array< void const *, N > const &, std::index_sequence<>)
template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
bool	Catch::Matchers::Detail::match_any_of (Arg &&arg, std::array< void const *, N > const &matchers, std::index_sequence< Idx, Indices... >)
std::string	Catch::Matchers::Detail::describe_multi_matcher (StringRef combine, std::string const *descriptions_begin, std::string const *descriptions_end)
template<typename... MatcherTs, std::size_t... Idx>
std::string	Catch::Matchers::Detail::describe_multi_matcher (StringRef combine, std::array< void const *, sizeof...(MatcherTs)> const &matchers, std::index_sequence< Idx... >)
template<typename MatcherLHS, typename MatcherRHS>
std::enable_if_t< Detail::are_generic_matchers< MatcherLHS, MatcherRHS >::value, Detail::MatchAllOfGeneric< MatcherLHS, MatcherRHS > >	Catch::Matchers::operator&& (MatcherLHS const &lhs, MatcherRHS const &rhs)
template<typename MatcherLHS, typename MatcherRHS>
std::enable_if_t< Detail::are_generic_matchers< MatcherLHS, MatcherRHS >::value, Detail::MatchAnyOfGeneric< MatcherLHS, MatcherRHS > >	Catch::Matchers::operator|| (MatcherLHS const &lhs, MatcherRHS const &rhs)
template<typename MatcherT>
std::enable_if_t< Detail::is_generic_matcher< MatcherT >::value, Detail::MatchNotOfGeneric< MatcherT > >	Catch::Matchers::operator! (MatcherT const &matcher)
	Wrap provided generic matcher in generic negator.
template<typename MatcherLHS, typename ArgRHS>
std::enable_if_t< Detail::is_generic_matcher< MatcherLHS >::value, Detail::MatchAllOfGeneric< MatcherLHS, MatcherBase< ArgRHS > > >	Catch::Matchers::operator&& (MatcherLHS const &lhs, MatcherBase< ArgRHS > const &rhs)
template<typename ArgLHS, typename MatcherRHS>
std::enable_if_t< Detail::is_generic_matcher< MatcherRHS >::value, Detail::MatchAllOfGeneric< MatcherBase< ArgLHS >, MatcherRHS > >	Catch::Matchers::operator&& (MatcherBase< ArgLHS > const &lhs, MatcherRHS const &rhs)
template<typename MatcherLHS, typename ArgRHS>
std::enable_if_t< Detail::is_generic_matcher< MatcherLHS >::value, Detail::MatchAnyOfGeneric< MatcherLHS, MatcherBase< ArgRHS > > >	Catch::Matchers::operator|| (MatcherLHS const &lhs, MatcherBase< ArgRHS > const &rhs)
template<typename ArgLHS, typename MatcherRHS>
std::enable_if_t< Detail::is_generic_matcher< MatcherRHS >::value, Detail::MatchAnyOfGeneric< MatcherBase< ArgLHS >, MatcherRHS > >	Catch::Matchers::operator|| (MatcherBase< ArgLHS > const &lhs, MatcherRHS const &rhs)
IsEmptyMatcher	Catch::Matchers::IsEmpty ()
	Creates a matcher that accepts empty ranges/containers.
HasSizeMatcher	Catch::Matchers::SizeIs (std::size_t sz)
	Creates a matcher that accepts ranges/containers with specific size.
template<typename Matcher>
std::enable_if_t< Detail::is_matcher< Matcher >::value, SizeMatchesMatcher< Matcher > >	Catch::Matchers::SizeIs (Matcher &&m)
template<typename T>
std::enable_if_t<!Detail::is_matcher< T >::value, ContainsElementMatcher< T, std::equal_to<> > >	Catch::Matchers::Contains (T &&elem)
	Creates a matcher that checks whether a range contains a specific element.
template<typename Matcher>
std::enable_if_t< Detail::is_matcher< Matcher >::value, ContainsMatcherMatcher< Matcher > >	Catch::Matchers::Contains (Matcher &&matcher)
	Creates a matcher that checks whether a range contains element matching a matcher.
template<typename T, typename Equality>
ContainsElementMatcher< T, Equality >	Catch::Matchers::Contains (T &&elem, Equality &&eq)
	Creates a matcher that checks whether a range contains a specific element.
ExceptionMessageMatcher	Catch::Matchers::Message (std::string const &message)
	Creates a matcher that checks whether a std derived exception has the provided message.
WithinUlpsMatcher	Catch::Matchers::WithinULP (double target, uint64_t maxUlpDiff)
	Creates a matcher that accepts doubles within certain ULP range of target.
WithinUlpsMatcher	Catch::Matchers::WithinULP (float target, uint64_t maxUlpDiff)
	Creates a matcher that accepts floats within certain ULP range of target.
WithinAbsMatcher	Catch::Matchers::WithinAbs (double target, double margin)
	Creates a matcher that accepts numbers within certain range of target.
WithinRelMatcher	Catch::Matchers::WithinRel (double target, double eps)
	Creates a matcher that accepts doubles within certain relative range of target.
WithinRelMatcher	Catch::Matchers::WithinRel (double target)
	Creates a matcher that accepts doubles within 100*DBL_EPS relative range of target.
WithinRelMatcher	Catch::Matchers::WithinRel (float target, float eps)
	Creates a matcher that accepts doubles within certain relative range of target.
WithinRelMatcher	Catch::Matchers::WithinRel (float target)
	Creates a matcher that accepts floats within 100*FLT_EPS relative range of target.
std::string	Catch::Matchers::Detail::finalizeDescription (const std::string &desc)
template<typename T, typename Pred>
PredicateMatcher< T, Pred >	Catch::Matchers::Predicate (Pred &&predicate, std::string const &description="")
	Creates a matcher that calls delegates match to the provided predicate.
template<typename Matcher>
AllMatchMatcher< Matcher >	Catch::Matchers::AllMatch (Matcher &&matcher)
template<typename Matcher>
NoneMatchMatcher< Matcher >	Catch::Matchers::NoneMatch (Matcher &&matcher)
template<typename Matcher>
AnyMatchMatcher< Matcher >	Catch::Matchers::AnyMatch (Matcher &&matcher)
StringEqualsMatcher	Catch::Matchers::Equals (std::string const &str, CaseSensitive caseSensitivity=CaseSensitive::Yes)
	Creates matcher that accepts strings that are exactly equal to str.
StringContainsMatcher	Catch::Matchers::ContainsSubstring (std::string const &str, CaseSensitive caseSensitivity=CaseSensitive::Yes)
	Creates matcher that accepts strings that contain str.
EndsWithMatcher	Catch::Matchers::EndsWith (std::string const &str, CaseSensitive caseSensitivity=CaseSensitive::Yes)
	Creates matcher that accepts strings that end with str.
StartsWithMatcher	Catch::Matchers::StartsWith (std::string const &str, CaseSensitive caseSensitivity=CaseSensitive::Yes)
	Creates matcher that accepts strings that start with str.
RegexMatcher	Catch::Matchers::Matches (std::string const &regex, CaseSensitive caseSensitivity=CaseSensitive::Yes)
	Creates matcher that accepts strings matching regex.
template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
ContainsMatcher< T, AllocComp, AllocMatch >	Catch::Matchers::Contains (std::vector< T, AllocComp > const &comparator)
	Creates a matcher that matches vectors that contain all elements in comparator.
template<typename T, typename Alloc = std::allocator<T>>
VectorContainsElementMatcher< T, Alloc >	Catch::Matchers::VectorContains (T const &comparator)
	Creates a matcher that matches vectors that contain comparator as an element.
template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
EqualsMatcher< T, AllocComp, AllocMatch >	Catch::Matchers::Equals (std::vector< T, AllocComp > const &comparator)
	Creates a matcher that matches vectors that are exactly equal to comparator.
template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
ApproxMatcher< T, AllocComp, AllocMatch >	Catch::Matchers::Approx (std::vector< T, AllocComp > const &comparator)
	Creates a matcher that matches vectors that comparator as an element.
template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
UnorderedEqualsMatcher< T, AllocComp, AllocMatch >	Catch::Matchers::UnorderedEquals (std::vector< T, AllocComp > const &target)
	Creates a matcher that matches vectors that is equal to target modulo permutation.
std::string	Catch::getFormattedDuration (double duration)
bool	Catch::shouldShowDuration (IConfig const &config, double duration)
	Should the reporter show duration of test given current configuration?
std::string	Catch::serializeFilters (std::vector< std::string > const &filters)
void	Catch::defaultListReporters (std::ostream &out, std::vector< ReporterDescription > const &descriptions, Verbosity verbosity)
	Lists reporter descriptions to the provided stream in user-friendly format.
void	Catch::defaultListListeners (std::ostream &out, std::vector< ListenerDescription > const &descriptions)
	Lists listeners descriptions to the provided stream in user-friendly format.
void	Catch::defaultListTags (std::ostream &out, std::vector< TagInfo > const &tags, bool isFiltered)
	Lists tag information to the provided stream in user-friendly format.
void	Catch::defaultListTests (std::ostream &out, ColourImpl *streamColour, std::vector< TestCaseHandle > const &tests, bool isFiltered, Verbosity verbosity)
	Lists test case information to the provided stream in user-friendly format.
void	Catch::Detail::registerReporterImpl (std::string const &name, IReporterFactoryPtr reporterPtr)

Variables
const auto	Catch::Benchmark::Detail::warmup_iterations = 10000
const auto	Catch::Benchmark::Detail::warmup_time = std::chrono::milliseconds(100)
const auto	Catch::Benchmark::Detail::minimum_ticks = 1000
const auto	Catch::Benchmark::Detail::warmup_seed = 10000
const auto	Catch::Benchmark::Detail::clock_resolution_estimation_time = std::chrono::milliseconds(500)
const auto	Catch::Benchmark::Detail::clock_cost_estimation_time_limit = std::chrono::seconds(1)
const auto	Catch::Benchmark::Detail::clock_cost_estimation_tick_limit = 100000
const auto	Catch::Benchmark::Detail::clock_cost_estimation_time = std::chrono::milliseconds(10)
const 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.

This is a convenience header for Catch2's Reporter support.

This is a convenience header for Catch2's Matcher support.

Wrapper for UNCAUGHT_EXCEPTIONS configuration option.

Wrapper for ANDROID_LOGWRITE configuration option.

This is a convenience header for Catch2's interfaces.

This is a convenience header for Catch2's Generator support.

Wrapper for the WCHAR configuration option.

Wrapper for the CONFIG configuration option.

This is a convenience header for Catch2's benchmarking.

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.

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.

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.

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.

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.

It includes all of Catch2 headers related to interfaces.

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 somewhat increased compilation times.

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

We want to default to enabling it when compiled for android, but users of the library should also be able to disable it if they want to.

For some functionality, Catch2 requires to know whether there is an active exception. Because std::uncaught_exception is deprecated in C++17, we want to use std::uncaught_exceptions if possible.

It includes all of Catch2 headers related to matchers.

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 increased compilation times.

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

It includes all of Catch2 headers related to reporters, including all reporters.

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 (reporter) is added to either the reporter 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__ )

CATCH_BREAK_INTO_DEBUGGER

#define CATCH_BREAK_INTO_DEBUGGER

(

)

Value:

[]{}()

CATCH_CATCH_ANON

#define CATCH_CATCH_ANON

(

type

)

Value:

if ((false))

CATCH_DEFER

#define CATCH_DEFER

(

id

)

Value:

id CATCH_EMPTY()

CATCH_ENFORCE

#define CATCH_ENFORCE	(		condition,
			... )

Value:

    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)

CATCH_ERROR

#define CATCH_ERROR

(

...

)

Value:

    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))

CATCH_FORWARD

#define CATCH_FORWARD

(

...

)

Value:

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

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

CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR

#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR

(

op

)

Value:

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

CATCH_INTERNAL_ERROR

#define CATCH_INTERNAL_ERROR

(

...

)

Value:

    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))

CATCH_INTERNAL_STRINGIFY

#define CATCH_INTERNAL_STRINGIFY

(

...

)

Value:

#__VA_ARGS__

CATCH_MAKE_MSG

#define CATCH_MAKE_MSG

(

...

)

Value:

    (Catch::ReusableStringStream() << __VA_ARGS__).str()

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_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_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_LISTENER

#define CATCH_REGISTER_LISTENER

(

listenerType

)

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                              \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                               \
        namespace {                                                            \
            Catch::ListenerRegistrar<listenerType> INTERNAL_CATCH_UNIQUE_NAME( \
                catch_internal_RegistrarFor )( #listenerType );                \
        }                                                                      \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

CATCH_REGISTER_REPORTER

#define CATCH_REGISTER_REPORTER	(		name,
			reporterType )

Value:

        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                              \
        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                               \
        namespace {                                                            \
            Catch::ReporterRegistrar<reporterType> INTERNAL_CATCH_UNIQUE_NAME( \
                catch_internal_RegistrarFor )( name );                         \
        }                                                                      \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION

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_RUNTIME_ERROR

#define CATCH_RUNTIME_ERROR

(

...

)

Value:

    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))

CATCH_TRANSLATE_EXCEPTION

#define CATCH_TRANSLATE_EXCEPTION

(

signature

)

Value:

INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )

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_THAT

#define CHECK_THAT	(		arg,
			matcher )

Value:

INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )

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 )

CHECK_THROWS_MATCHES

#define CHECK_THROWS_MATCHES	(		expr,
			exceptionType,
			matcher )

Value:

INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )

CHECK_THROWS_WITH

#define CHECK_THROWS_WITH	(		expr,
			matcher )

Value:

INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, 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( INTERNAL_CATCH_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( INTERNAL_CATCH_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( INTERNAL_CATCH_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_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
    varName.captureValues( 0, __VA_ARGS__ )

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_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_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_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_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:

    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 \
        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, 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() ); \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } 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 { \
            static_cast<void>(__VA_ARGS__); \
            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
        } \
        catch( ... ) { \
            catchAssertionHandler.handleUnexpectedInflightException(); \
        } \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

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_REACT

#define INTERNAL_CATCH_REACT

(

handler

)

Value:

handler.complete();

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::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::SectionInfo( 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 \
        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 " - " + std::string(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 \
        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::NameAndTags{ Name " - " + std::string(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_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_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 \
        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__)};\
                    using expander = size_t[];\
                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
                }\
            };\
            static 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__ ); \
            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } 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 \
        namespace{ \
            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                void test(); \
            }; \
            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
        } \
        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
        void TestName::test()

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 \
        namespace{ 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 { \
                static_cast<void>(__VA_ARGS__); \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleExceptionThrownAsExpected(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } 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 { \
                static_cast<void>(expr); \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( exceptionType const& ) { \
                catchAssertionHandler.handleExceptionThrownAsExpected(); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleUnexpectedInflightException(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

INTERNAL_CATCH_THROWS_MATCHES

#define INTERNAL_CATCH_THROWS_MATCHES	(		macroName,
			exceptionType,
			resultDisposition,
			matcher,
			... )

Value:

    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        if( catchAssertionHandler.allowThrows() ) \
            try { \
                static_cast<void>(__VA_ARGS__ ); \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( exceptionType const& ex ) { \
                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
            } \
            catch( ... ) { \
                catchAssertionHandler.handleUnexpectedInflightException(); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } 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 { \
                static_cast<void>(__VA_ARGS__); \
                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
            } \
            catch( ... ) { \
                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
            } \
        else \
            catchAssertionHandler.handleThrowingCallSkipped(); \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } 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_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

INTERNAL_CHECK_THAT

#define INTERNAL_CHECK_THAT	(		macroName,
			matcher,
			resultDisposition,
			arg )

Value:

    do { \
        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
        INTERNAL_CATCH_TRY { \
            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
    } while( false )

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_THAT

#define REQUIRE_THAT	(		arg,
			matcher )

Value:

INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )

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 )

REQUIRE_THROWS_MATCHES

#define REQUIRE_THROWS_MATCHES	(		expr,
			exceptionType,
			matcher )

Value:

INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )

REQUIRE_THROWS_WITH

#define REQUIRE_THROWS_WITH	(		expr,
			matcher )

Value:

INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, 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__ )

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__ )

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 )

Typedef Documentation

is_generic_matcher

template<typename T>

using Catch::Matchers::Detail::is_generic_matcher

Initial value:

 std::is_base_of<
            Catch::Matchers::MatcherGenericBase,
            std::remove_cv_t<std::remove_reference_t<T>>
        >

is_matcher

template<typename T>

using Catch::Matchers::Detail::is_matcher

Initial value:

 std::is_base_of<
            Catch::Matchers::MatcherUntypedBase,
            std::remove_cv_t<std::remove_reference_t<T>>
        >

Enumeration Type Documentation

ColourMode

enum class Catch::ColourMode : std::uint8_t

strong

Enumerator
PlatformDefault	Let Catch2 pick implementation based on platform detection.
ANSI	Use ANSI colour code escapes.
Win32	Use Win32 console colour API.
None	Don't use any colour.

GenerateFrom

enum class Catch::GenerateFrom

strong

Enumerator
Default	Currently equivalent to RandomDevice, but can change at any point.

ResultType

enum class Catch::Clara::Detail::ResultType

strong

Denotes type of a parsing result.

Enumerator
Ok	No errors.
LogicError	Error in user-specified arguments for construction.
RuntimeError	Error in parsing inputs.

Function Documentation

Contains() [1/2]

template<typename T>

std::enable_if_t<!Detail::is_matcher< T >::value, ContainsElementMatcher< T, std::equal_to<> > > Catch::Matchers::Contains

(

T &&

elem

)

Creates a matcher that checks whether a range contains a specific element.

Uses std::equal_to to do the comparison

Contains() [2/2]

template<typename T, typename Equality>

ContainsElementMatcher< T, Equality > Catch::Matchers::Contains	(	T &&	elem,
		Equality &&	eq )

Creates a matcher that checks whether a range contains a specific element.

Uses eq to do the comparisons

convertIntoString()

std::string Catch::Detail::convertIntoString

(

StringRef

string

)

Encases string in quotes, and escapes invisibles if user requested it via CLI

defaultListReporters()

void Catch::defaultListReporters	(	std::ostream &	out,
		std::vector< ReporterDescription > const &	descriptions,
		Verbosity	verbosity )

Lists reporter descriptions to the provided stream in user-friendly format.

Used as the default listing implementation by the first party reporter bases. The output should be backwards compatible with the output of Catch2 v2 binaries.

defaultListTags()

void Catch::defaultListTags	(	std::ostream &	out,
		std::vector< TagInfo > const &	tags,
		bool	isFiltered )

Lists tag information to the provided stream in user-friendly format.

Used as the default listing implementation by the first party reporter bases. The output should be backwards compatible with the output of Catch2 v2 binaries.

defaultListTests()

void Catch::defaultListTests	(	std::ostream &	out,
		ColourImpl *	streamColour,
		std::vector< TestCaseHandle > const &	tests,
		bool	isFiltered,
		Verbosity	verbosity )

Lists test case information to the provided stream in user-friendly format.

Used as the default listing implementation by the first party reporter bases. The output is backwards compatible with the output of Catch2 v2 binaries, and also supports the format specific to the old --list-test-names-only option, for people who used it in integrations.

makeStream()

auto Catch::makeStream

(

std::string const &

filename

)

->Detail::unique_ptr< IStream >

Creates a stream wrapper that writes to specific file.

Also recognizes 4 special filenames

• - for stdout
• stdout for stdout
• stderr for stderr
• debug for platform specific debugging output

Exceptions

if	passed an unrecognized %-prefixed stream

operator&&() [1/2]

template<typename ArgT>

MatchAllOf< ArgT > Catch::Matchers::Detail::operator&& ( MatchAllOf< ArgT > const & lhs, MatcherBase< ArgT > const & rhs )

delete

lvalue overload is intentionally deleted, users should not be trying to compose stored composition matchers

operator&&() [2/2]

template<typename ArgT>

MatchAllOf< ArgT > Catch::Matchers::Detail::operator&& ( MatcherBase< ArgT > const & lhs, MatchAllOf< ArgT > const & rhs )

delete

lvalue overload is intentionally deleted, users should not be trying to compose stored composition matchers

operator||() [1/2]

template<typename ArgT>

MatchAnyOf< ArgT > Catch::Matchers::Detail::operator|| ( MatchAnyOf< ArgT > const & lhs, MatcherBase< ArgT > const & rhs )

delete

lvalue overload is intentionally deleted, users should not be trying to compose stored composition matchers

operator||() [2/2]

template<typename ArgT>

MatchAnyOf< ArgT > Catch::Matchers::Detail::operator|| ( MatcherBase< ArgT > const & lhs, MatchAnyOf< ArgT > const & rhs )

delete

lvalue overload is intentionally deleted, users should not be trying to compose stored composition matchers

parseReporterSpec()

Optional< ReporterSpec > Catch::parseReporterSpec

(

StringRef

reporterSpec

)

Parses provided reporter spec string into.

Returns empty optional on errors, e.g.

• field that is not first and not a key+value pair
• duplicated keys in kv pair
• unknown catch reporter option
• empty key/value in an custom kv pair
• ...

Predicate()

template<typename T, typename Pred>

PredicateMatcher< T, Pred > Catch::Matchers::Predicate	(	Pred &&	predicate,
		std::string const &	description = "" )

Creates a matcher that calls delegates match to the provided predicate.

The user has to explicitly specify the argument type to the matcher

registerReporterImpl()

void Catch::Detail::registerReporterImpl	(	std::string const &	name,
		IReporterFactoryPtr	reporterPtr )

Indirection for reporter registration, so that the error handling is independent on the reporter's concrete type

ulpDistance()

template<typename FP>

uint64_t Catch::ulpDistance	(	FP	lhs,
		FP	rhs )

Calculates the ULP distance between two floating point numbers.

The ULP distance of two floating point numbers is the count of valid floating point numbers representable between them.

There are some exceptions between how this function counts the distance, and the interpretation of the standard as implemented. by e.g. nextafter. For this function it always holds that:

• (x == y) => ulpDistance(x, y) == 0 (so ulpDistance(-0, 0) == 0)
• ulpDistance(maxFinite, INF) == 1
• ulpDistance(x, -x) == 2 * ulpDistance(x, 0)

Precondition

!isnan( lhs )

!isnan( rhs )

floating point numbers are represented in IEEE-754 format