Catch Namespace Reference

Namespaces
namespace	clara
namespace	Detail
namespace	detail
namespace	Generators
namespace	literals
namespace	Matchers
namespace	TestCaseTracking

Classes
struct	always_false
struct	append
struct	append< L1< E1... >, L2< E2... > >
struct	append< L1< E1... >, L2< E2... >, Rest... >
class	AssertionHandler
struct	AssertionInfo
struct	AssertionReaction
class	AssertionResult
struct	AssertionResultData
struct	AssertionStats
struct	AutomakeReporter
struct	AutoReg
struct	BenchmarkInfo
class	BenchmarkLooper
struct	BenchmarkStats
class	BinaryExpr
class	Capturer
struct	CaseSensitive
struct	Colour
struct	combine
struct	CompactReporter
class	Config
struct	ConfigData
struct	ConsoleReporter
class	Context
struct	Counts
struct	CumulativeReporterBase
struct	Decomposer
class	ErrnoGuard
class	ExceptionTranslatorRegistrar
class	ExceptionTranslatorRegistry
class	ExprLhs
struct	FatalConditionHandler
class	GeneratorException
struct	GroupInfo
struct	IConfig
struct	IContext
struct	IExceptionTranslator
struct	IExceptionTranslatorRegistry
struct	IGeneratorTracker
struct	IMutableContext
struct	IMutableEnumValuesRegistry
struct	IMutableRegistryHub
struct	IRegistryHub
struct	IReporterFactory
struct	IReporterRegistry
struct	IResultCapture
struct	IRunner
struct	is_range
struct	is_range< disabled_range >
struct	is_unique
struct	is_unique< T0, T1, Rest... >
struct	ISingleton
struct	IStream
struct	IStreamingReporter
struct	ITagAliasRegistry
struct	ITestCaseRegistry
struct	ITestInvoker
struct	ITransientExpression
class	JunitReporter
class	LazyExpression
struct	LazyStat
struct	LeakDetector
class	ListenerRegistrar
class	ListeningReporter
class	MatchExpr
struct	MessageBuilder
struct	MessageInfo
struct	MessageStream
struct	NameAndTags
class	NonCopyable
struct	not_this_one
class	OcMethod
class	Option
struct	pluralise
class	RedirectedStdErr
class	RedirectedStdOut
class	RedirectedStream
class	RedirectedStreams
struct	RegistrarForTagAliases
struct	ReporterConfig
struct	ReporterPreferences
class	ReporterRegistrar
class	ReporterRegistry
struct	ResultDisposition
struct	ResultWas
class	ReusableStringStream
struct	rewrap
struct	rewrap< Container, List< elems... > >
struct	rewrap< Container, List< Elems... >, Elements... >
class	RunContext
struct	RunTests
class	ScopedMessage
class	Section
struct	SectionEndInfo
struct	SectionInfo
struct	SectionStats
class	Session
struct	ShowDurations
struct	SignalDefs
class	Singleton
struct	SourceLineInfo
class	StartupExceptionRegistry
struct	StreamEndStop
struct	StreamingReporterBase
struct	StringMaker
struct	StringMaker< bool >
struct	StringMaker< Catch::Detail::Approx >
struct	StringMaker< char * >
struct	StringMaker< char >
struct	StringMaker< char const * >
struct	StringMaker< char[SZ]>
struct	StringMaker< double >
struct	StringMaker< float >
struct	StringMaker< has_maker >
struct	StringMaker< has_maker_and_operator >
struct	StringMaker< int >
struct	StringMaker< long >
struct	StringMaker< long long >
struct	StringMaker< R C::* >
struct	StringMaker< R, typename std::enable_if< is_range< R >::value &&!::Catch::Detail::IsStreamInsertable< R >::value >::type >
struct	StringMaker< signed char >
struct	StringMaker< signed char[SZ]>
struct	StringMaker< std::nullptr_t >
struct	StringMaker< std::string >
struct	StringMaker< std::wstring >
struct	StringMaker< stringmaker_range >
struct	StringMaker< StringMakerException >
struct	StringMaker< T * >
struct	StringMaker< T[SZ]>
struct	StringMaker< unsigned char >
struct	StringMaker< unsigned char[SZ]>
struct	StringMaker< unsigned int >
struct	StringMaker< unsigned long >
struct	StringMaker< unsigned long long >
struct	StringMaker< wchar_t * >
struct	StringMaker< wchar_t const * >
class	StringRef
struct	StringRefTestAccess
struct	StringStreams
struct	SummaryColumn
class	TablePrinter
struct	TagAlias
class	TagAliasRegistry
struct	TagInfo
struct	TAPReporter
struct	TeamCityReporter
class	TestCase
struct	TestCaseInfo
struct	TestCaseStats
struct	TestEventListenerBase
struct	TestFailureException
struct	TestGroupStats
class	TestInvokerAsFunction
class	TestInvokerAsMethod
class	TestRegistry
struct	TestRunInfo
struct	TestRunStats
class	TestSpec
class	TestSpecParser
class	Timer
struct	Totals
struct	TypeList
class	UnaryExpr
struct	UseColour
struct	Version
struct	WaitForKeypress
struct	WarnAbout
class	WildcardPattern
class	XmlEncode
class	XmlReporter
class	XmlWriter

Typedefs
using	StringMatcher = Matchers::Impl::MatcherBase<std::string>
using	IConfigPtr = std::shared_ptr<IConfig const>
using	exceptionTranslateFunction = std::string(*)()
using	ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>
using	IReporterFactoryPtr = std::shared_ptr<IReporterFactory>
using	IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>
using	RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>

Enumerations
enum class	Verbosity {   Quiet = 0 , Normal , High , Quiet = 0 ,   Normal , High }
enum class	Verbosity {   Quiet = 0 , Normal , High , Quiet = 0 ,   Normal , High }

Functions
std::ostream &	cout ()
std::ostream &	clog ()
std::ostream &	cerr ()
auto	operator<< (std::ostream &os, LazyExpression const &lazyExpr) -> std::ostream &
void	handleExceptionMatchExpr (AssertionHandler &handler, std::string const &str, StringRef const &matcherString)
void	handleExceptionMatchExpr (AssertionHandler &handler, StringMatcher const &matcher, StringRef const &matcherString)
template<typename ArgT , typename MatcherT >
auto	makeMatchExpr (ArgT const &arg, MatcherT const &matcher, StringRef const &matcherString) -> MatchExpr< ArgT, MatcherT >
clara::Parser	makeCommandLineParser (ConfigData &config)
std::ostream &	operator<< (std::ostream &os, SourceLineInfo const &info)
template<typename T >
T const &	operator+ (T const &value, StreamEndStop)
std::ostream &	operator<< (std::ostream &os, Colour const &)
void	cleanUpContext ()
IMutableContext &	getCurrentMutableContext ()
IContext &	getCurrentContext ()
void	writeToDebugConsole (std::string const &text)
bool	isDebuggerActive ()
void	formatReconstructedExpression (std::ostream &os, std::string const &lhs, StringRef op, std::string const &rhs)
template<typename LhsT , typename RhsT >
auto	compareEqual (LhsT const &lhs, RhsT const &rhs) -> bool
template<typename T >
auto	compareEqual (T *const &lhs, int rhs) -> bool
template<typename T >
auto	compareEqual (T *const &lhs, long rhs) -> bool
template<typename T >
auto	compareEqual (int lhs, T *const &rhs) -> bool
template<typename T >
auto	compareEqual (long lhs, T *const &rhs) -> bool
template<typename LhsT , typename RhsT >
auto	compareNotEqual (LhsT const &lhs, RhsT &&rhs) -> bool
template<typename T >
auto	compareNotEqual (T *const &lhs, int rhs) -> bool
template<typename T >
auto	compareNotEqual (T *const &lhs, long rhs) -> bool
template<typename T >
auto	compareNotEqual (int lhs, T *const &rhs) -> bool
template<typename T >
auto	compareNotEqual (long lhs, T *const &rhs) -> bool
void	handleExpression (ITransientExpression const &expr)
template<typename T >
void	handleExpression (ExprLhs< T > const &expr)
void	throw_exception (std::exception const &e)
IResultCapture &	getResultCapture ()
IRegistryHub const &	getRegistryHub ()
IMutableRegistryHub &	getMutableRegistryHub ()
void	cleanUp ()
std::string	translateActiveException ()
bool	matchTest (TestCase const &testCase, TestSpec const &testSpec, IConfig const &config)
std::vector< TestCase >	filterTests (std::vector< TestCase > const &testCases, TestSpec const &testSpec, IConfig const &config)
std::vector< TestCase > const &	getAllTestCasesSorted (IConfig const &config)
std::size_t	listTests (Config const &config)
std::size_t	listTestsNamesOnly (Config const &config)
std::size_t	listTags (Config const &config)
std::size_t	listReporters ()
Option< std::size_t >	list (std::shared_ptr< Config > const &config)
std::size_t	registerTestMethods ()
bool	isnan (float f)
bool	isnan (double d)
std::mt19937 &	rng ()
void	seedRng (IConfig const &config)
unsigned int	rngSeed ()
bool	isOk (ResultWas::OfType resultType)
bool	isJustInfo (int flags)
ResultDisposition::Flags	operator| (ResultDisposition::Flags lhs, ResultDisposition::Flags rhs)
bool	shouldContinueOnFailure (int flags)
bool	shouldSuppressFailure (int flags)
bool	isFalseTest (int flags)
void	addSingleton (ISingleton *singleton)
void	cleanupSingletons ()
auto	makeStream (StringRef const &filename) -> IStream const *
bool	startsWith (std::string const &s, std::string const &prefix)
bool	startsWith (std::string const &s, char prefix)
bool	endsWith (std::string const &s, std::string const &suffix)
bool	endsWith (std::string const &s, char suffix)
bool	contains (std::string const &s, std::string const &infix)
void	toLowerInPlace (std::string &s)
std::string	toLower (std::string const &s)
std::string	trim (std::string const &str)
bool	replaceInPlace (std::string &str, std::string const &replaceThis, std::string const &withThis)
std::vector< StringRef >	splitStringRef (StringRef str, char delimiter)
std::ostream &	operator<< (std::ostream &os, pluralise const &pluraliser)
auto	operator+ (StringRef const &lhs, StringRef const &rhs) -> std::string
auto	operator+ (StringRef const &lhs, const char *rhs) -> std::string
auto	operator+ (char const *lhs, StringRef const &rhs) -> std::string
auto	operator<< (std::ostream &os, StringRef const &str) -> std::ostream &
auto	operator+= (std::string &lhs, StringRef const &rhs) -> std::string &
auto	operator""_sr (char const *rawChars, std::size_t size) noexcept -> StringRef
TestCase	makeTestCase (ITestInvoker *_testCase, std::string const &_className, NameAndTags const &nameAndTags, SourceLineInfo const &_lineInfo)
void	setTags (TestCaseInfo &testCaseInfo, std::vector< std::string > tags)
std::vector< TestCase >	sortTests (IConfig const &config, std::vector< TestCase > const &unsortedTestCases)
void	enforceNoDuplicateTestCases (std::vector< TestCase > const &functions)
std::string	extractClassName (StringRef const &classOrQualifiedMethodName)
auto	makeTestInvoker (void(*testAsFunction)()) noexcept -> ITestInvoker *
template<typename C >
auto	makeTestInvoker (void(C::*testAsMethod)()) noexcept -> ITestInvoker *
TestSpec	parseTestSpec (std::string const &arg)
auto	getCurrentNanosecondsSinceEpoch () -> uint64_t
auto	getEstimatedClockResolution () -> uint64_t
template<typename T >
std::string	to_string (T const &t)
template<typename T >
std::string	fpToString (T value, int precision)
template<typename Range >
std::string	rangeToString (Range const &range)
template<typename Allocator >
std::string	rangeToString (std::vector< bool, Allocator > const &v)
bool	uncaught_exceptions ()
std::ostream &	operator<< (std::ostream &os, Version const &version)
Version const &	libraryVersion ()
std::ostream &	operator<< (std::ostream &os, XmlEncode const &xmlEncode)
void	prepareExpandedExpression (AssertionResult &result)
std::string	getFormattedDuration (double duration)
std::string	serializeFilters (std::vector< std::string > const &container)
template<char C>
char const *	getLineOfChars ()

Variables
LeakDetector	leakDetector
not_this_one	begin (...)
not_this_one	end (...)

Typedef Documentation

exceptionTranslateFunction

typedef std::string(* Catch::exceptionTranslateFunction)() = std::string(*)()

Definition at line 23 of file catch_interfaces_exception.h.

ExceptionTranslators

using Catch::ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>

Definition at line 26 of file catch_interfaces_exception.h.

IConfigPtr

typedef std::shared_ptr< IConfig const > Catch::IConfigPtr = std::shared_ptr<IConfig const>

Definition at line 20 of file catch_context.h.

IReporterFactoryPtr

typedef std::shared_ptr< IReporterFactory > Catch::IReporterFactoryPtr = std::shared_ptr<IReporterFactory>

Definition at line 29 of file catch_interfaces_registry_hub.h.

IStreamingReporterPtr

using Catch::IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>

Definition at line 211 of file catch_interfaces_reporter.h.

RegistryHubSingleton

using Catch::RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>

Definition at line 78 of file catch_registry_hub.cpp.

StringMatcher

typedef Matchers::Impl::MatcherBase< std::string > Catch::StringMatcher = Matchers::Impl::MatcherBase<std::string>

Definition at line 13 of file catch_capture_matchers.cpp.

Enumeration Type Documentation

Verbosity [1/2]

enum class Catch::Verbosity

strong

Enumerator
Quiet
Normal
High
Quiet
Normal
High

Definition at line 20 of file catch_interfaces_config.h.

                         {
        Quiet = 0,
        Normal,
        High
    };

Verbosity [2/2]

enum class Catch::Verbosity

strong

Enumerator
Quiet
Normal
High
Quiet
Normal
High

Definition at line 3987 of file catch.hpp.

                         {
        Quiet = 0,
        Normal,
        High
    };

Function Documentation

addSingleton()

void Catch::addSingleton

(

ISingleton *

singleton

)

Definition at line 25 of file catch_singletons.cpp.

                                              {
        getSingletons()->push_back( singleton );
    }

cerr()

std::ostream & Catch::cerr

(

)

Definition at line 41 of file 231-Cfg-OutputStreams.cpp.

                       {
        return clog();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

cleanUp()

void Catch::cleanUp

(

)

Definition at line 86 of file catch_registry_hub.cpp.

                   {
        cleanupSingletons();
        cleanUpContext();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

cleanUpContext()

void Catch::cleanUpContext

(

)

Definition at line 55 of file catch_context.cpp.

                          {
        delete IMutableContext::currentContext;
        IMutableContext::currentContext = nullptr;
    }

Here is the caller graph for this function:

cleanupSingletons()

void Catch::cleanupSingletons

(

)

Definition at line 28 of file catch_singletons.cpp.

                             {
        auto& singletons = getSingletons();
        for( auto singleton : *singletons )
            delete singleton;
        delete singletons;
        singletons = nullptr;
    }

Here is the caller graph for this function:

clog()

std::ostream & Catch::clog

(

)

Definition at line 37 of file 231-Cfg-OutputStreams.cpp.

                       {
        static std::ostream ret(new out_buff(stderr));
        return ret;
    }

Here is the caller graph for this function:

compareEqual() [1/5]

template<typename T >

auto Catch::compareEqual	(	int	lhs,
		T *const &	rhs ) -> bool

Definition at line 149 of file catch_decomposer.h.

{ return reinterpret_cast<void const*>( lhs ) == rhs; }

compareEqual() [2/5]

template<typename LhsT , typename RhsT >

auto Catch::compareEqual	(	LhsT const &	lhs,
		RhsT const &	rhs ) -> bool

Definition at line 143 of file catch_decomposer.h.

{ return static_cast<bool>(lhs == rhs); }

Here is the caller graph for this function:

compareEqual() [3/5]

template<typename T >

auto Catch::compareEqual	(	long	lhs,
		T *const &	rhs ) -> bool

Definition at line 151 of file catch_decomposer.h.

{ return reinterpret_cast<void const*>( lhs ) == rhs; }

compareEqual() [4/5]

template<typename T >

auto Catch::compareEqual	(	T *const &	lhs,
		int	rhs ) -> bool

Definition at line 145 of file catch_decomposer.h.

{ return lhs == reinterpret_cast<void const*>( rhs ); }

compareEqual() [5/5]

template<typename T >

auto Catch::compareEqual	(	T *const &	lhs,
		long	rhs ) -> bool

Definition at line 147 of file catch_decomposer.h.

{ return lhs == reinterpret_cast<void const*>( rhs ); }

compareNotEqual() [1/5]

template<typename T >

auto Catch::compareNotEqual	(	int	lhs,
		T *const &	rhs ) -> bool

Definition at line 160 of file catch_decomposer.h.

{ return reinterpret_cast<void const*>( lhs ) != rhs; }

compareNotEqual() [2/5]

template<typename LhsT , typename RhsT >

auto Catch::compareNotEqual	(	LhsT const &	lhs,
		RhsT &&	rhs ) -> bool

Definition at line 154 of file catch_decomposer.h.

{ return static_cast<bool>(lhs != rhs); }

Here is the caller graph for this function:

compareNotEqual() [3/5]

template<typename T >

auto Catch::compareNotEqual	(	long	lhs,
		T *const &	rhs ) -> bool

Definition at line 162 of file catch_decomposer.h.

{ return reinterpret_cast<void const*>( lhs ) != rhs; }

compareNotEqual() [4/5]

template<typename T >

auto Catch::compareNotEqual	(	T *const &	lhs,
		int	rhs ) -> bool

Definition at line 156 of file catch_decomposer.h.

{ return lhs != reinterpret_cast<void const*>( rhs ); }

compareNotEqual() [5/5]

template<typename T >

auto Catch::compareNotEqual	(	T *const &	lhs,
		long	rhs ) -> bool

Definition at line 158 of file catch_decomposer.h.

{ return lhs != reinterpret_cast<void const*>( rhs ); }

contains()

bool Catch::contains	(	std::string const &	s,
		std::string const &	infix )

Definition at line 37 of file catch_string_manip.cpp.

                                                                {
        return s.find( infix ) != std::string::npos;
    }

Here is the caller graph for this function:

cout()

std::ostream & Catch::cout

(

)

Definition at line 33 of file 231-Cfg-OutputStreams.cpp.

                       {
        static std::ostream ret(new out_buff(stdout));
        return ret;
    }

Here is the caller graph for this function:

endsWith() [1/2]

bool Catch::endsWith	(	std::string const &	s,
		char	suffix )

Definition at line 34 of file catch_string_manip.cpp.

                                                     {
        return !s.empty() && s[s.size()-1] == suffix;
    }

endsWith() [2/2]

bool Catch::endsWith	(	std::string const &	s,
		std::string const &	suffix )

Definition at line 31 of file catch_string_manip.cpp.

                                                                 {
        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
    }

Here is the caller graph for this function:

enforceNoDuplicateTestCases()

void Catch::enforceNoDuplicateTestCases

(

std::vector< TestCase > const &

functions

)

Definition at line 43 of file catch_test_case_registry_impl.cpp.

                                                                             {
        std::set<TestCase> seenFunctions;
        for( auto const& function : functions ) {
            auto prev = seenFunctions.insert( function );
            CATCH_ENFORCE( prev.second,
                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
        }
    }

Here is the caller graph for this function:

extractClassName()

std::string Catch::extractClassName

(

StringRef const &

classOrQualifiedMethodName

)

Definition at line 102 of file catch_test_case_registry_impl.cpp.

                                                                              {
        std::string className = classOrQualifiedMethodName;
        if( startsWith( className, '&' ) )
        {
            std::size_t lastColons = className.rfind( "::" );
            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
            if( penultimateColons == std::string::npos )
                penultimateColons = 1;
            className = className.substr( penultimateColons, lastColons-penultimateColons );
        }
        return className;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

filterTests()

std::vector< TestCase > Catch::filterTests	(	std::vector< TestCase > const &	testCases,
		TestSpec const &	testSpec,
		IConfig const &	config )

Definition at line 54 of file catch_test_case_registry_impl.cpp.

                                                                                                                             {
        std::vector<TestCase> filtered;
        filtered.reserve( testCases.size() );
        for (auto const& testCase : testCases) {
            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
                filtered.push_back(testCase);
            }
        }
        return filtered;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

formatReconstructedExpression()

void Catch::formatReconstructedExpression	(	std::ostream &	os,
		std::string const &	lhs,
		StringRef	op,
		std::string const &	rhs )

Definition at line 16 of file catch_decomposer.cpp.

                                                                                                                   {
        if( lhs.size() + rhs.size() < 40 &&
                lhs.find('\n') == std::string::npos &&
                rhs.find('\n') == std::string::npos )
            os << lhs << " " << op << " " << rhs;
        else
            os << lhs << "\n" << op << "\n" << rhs;
    }

fpToString()

template<typename T >

std::string Catch::fpToString	(	T	value,
		int	precision )

Definition at line 71 of file catch_tostring.cpp.

                                               {
    if (Catch::isnan(value)) {
        return "nan";
    }
 
    ReusableStringStream rss;
    rss << std::setprecision( precision )
        << std::fixed
        << value;
    std::string d = rss.str();
    std::size_t i = d.find_last_not_of( '0' );
    if( i != std::string::npos && i != d.size()-1 ) {
        if( d[i] == '.' )
            i++;
        d = d.substr( 0, i+1 );
    }
    return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

getAllTestCasesSorted()

std::vector< TestCase > const & Catch::getAllTestCasesSorted

(

IConfig const &

config

)

Definition at line 65 of file catch_test_case_registry_impl.cpp.

                                                                              {
        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getCurrentContext()

IContext & Catch::getCurrentContext ( )

inline

Definition at line 52 of file catch_context.h.

    {
        return getCurrentMutableContext();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getCurrentMutableContext()

IMutableContext & Catch::getCurrentMutableContext ( )

inline

Definition at line 45 of file catch_context.h.

    {
        if( !IMutableContext::currentContext )
            IMutableContext::createContext();
        return *IMutableContext::currentContext;
    }

Here is the caller graph for this function:

getCurrentNanosecondsSinceEpoch()

auto Catch::getCurrentNanosecondsSinceEpoch

(

)

-> uint64_t

Definition at line 17 of file catch_timer.cpp.

                                                       {
        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
    }

Here is the caller graph for this function:

getEstimatedClockResolution()

auto Catch::getEstimatedClockResolution

(

)

-> uint64_t

Definition at line 52 of file catch_timer.cpp.

                                                   {
        static auto s_resolution = estimateClockResolution();
        return s_resolution;
    }

getFormattedDuration()

std::string Catch::getFormattedDuration

(

double

duration

)

Definition at line 26 of file catch_reporter_bases.cpp.

                                                      {
        // Max exponent + 1 is required to represent the whole part
        // + 1 for decimal point
        // + 3 for the 3 decimal places
        // + 1 for null terminator
        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
        char buffer[maxDoubleSize];
 
        // Save previous errno, to prevent sprintf from overwriting it
        ErrnoGuard guard;
#ifdef _MSC_VER
        sprintf_s(buffer, "%.3f", duration);
#else
        std::sprintf(buffer, "%.3f", duration);
#endif
        return std::string(buffer);
    }

Here is the caller graph for this function:

getLineOfChars()

template<char C>

char const * Catch::getLineOfChars

(

)

Definition at line 259 of file catch_reporter_bases.hpp.

                                 {
        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
        if( !*line ) {
            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
        }
        return line;
    }

Here is the caller graph for this function:

getMutableRegistryHub()

IMutableRegistryHub & Catch::getMutableRegistryHub

(

)

Definition at line 83 of file catch_registry_hub.cpp.

                                                 {
        return RegistryHubSingleton::getMutable();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getRegistryHub()

IRegistryHub const & Catch::getRegistryHub

(

)

Definition at line 80 of file catch_registry_hub.cpp.

                                         {
        return RegistryHubSingleton::get();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getResultCapture()

IResultCapture & Catch::getResultCapture

(

)

Definition at line 494 of file catch_run_context.cpp.

                                       {
        if (auto* capture = getCurrentContext().getResultCapture())
            return *capture;
        else
            CATCH_INTERNAL_ERROR("No result capture instance");
    }

Here is the call graph for this function:

Here is the caller graph for this function:

handleExceptionMatchExpr() [1/2]

void Catch::handleExceptionMatchExpr	(	AssertionHandler &	handler,
		std::string const &	str,
		StringRef const &	matcherString )

Definition at line 117 of file catch_assertionhandler.cpp.

                                                                                                                      {
        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

handleExceptionMatchExpr() [2/2]

void Catch::handleExceptionMatchExpr	(	AssertionHandler &	handler,
		StringMatcher const &	matcher,
		StringRef const &	matcherString )

Definition at line 18 of file catch_capture_matchers.cpp.

                                                                                                                              {
        std::string exceptionMessage = Catch::translateActiveException();
        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
        handler.handleExpr( expr );
    }

Here is the call graph for this function:

handleExpression() [1/2]

template<typename T >

void Catch::handleExpression

(

ExprLhs< T > const &

expr

)

Definition at line 226 of file catch_decomposer.h.

                                                    {
        handleExpression( expr.makeUnaryExpr() );
    }

Here is the call graph for this function:

handleExpression() [2/2]

void Catch::handleExpression

(

ITransientExpression const &

expr

)

Here is the caller graph for this function:

isDebuggerActive()

bool Catch::isDebuggerActive

(

)

Definition at line 121 of file catch_debugger.cpp.

{ return false; }

isFalseTest()

bool Catch::isFalseTest ( int flags )

inline

Definition at line 50 of file catch_result_type.h.

{ return ( flags & ResultDisposition::FalseTest ) != 0; }

Here is the caller graph for this function:

isJustInfo()

bool Catch::isJustInfo

(

int

flags

)

Definition at line 16 of file catch_result_type.cpp.

                                 {
        return flags == ResultWas::Info;
    }

isnan() [1/2]

bool Catch::isnan

(

double

d

)

Definition at line 18 of file catch_polyfills.cpp.

                         {
        return std::isnan(d);
    }

isnan() [2/2]

bool Catch::isnan

(

float

f

)

Definition at line 15 of file catch_polyfills.cpp.

                        {
        return std::isnan(f);
    }

Here is the caller graph for this function:

isOk()

bool Catch::isOk

(

ResultWas::OfType

resultType

)

Definition at line 13 of file catch_result_type.cpp.

                                            {
        return ( resultType & ResultWas::FailureBit ) == 0;
    }

Here is the caller graph for this function:

libraryVersion()

Version const & Catch::libraryVersion

(

)

Definition at line 39 of file catch_version.cpp.

                                    {
        static Version version( 2, 7, 2, "", 0 );
        return version;
    }

Here is the caller graph for this function:

list()

Option< std::size_t > Catch::list

(

std::shared_ptr< Config > const &

config

)

Definition at line 150 of file catch_list.cpp.

                                                                  {
        Option<std::size_t> listedCount;
        getCurrentMutableContext().setConfig( config );
        if( config->listTests() )
            listedCount = listedCount.valueOr(0) + listTests( *config );
        if( config->listTestNamesOnly() )
            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
        if( config->listTags() )
            listedCount = listedCount.valueOr(0) + listTags( *config );
        if( config->listReporters() )
            listedCount = listedCount.valueOr(0) + listReporters();
        return listedCount;
    }

Here is the call graph for this function:

listReporters()

std::size_t Catch::listReporters

(

)

Definition at line 128 of file catch_list.cpp.

                              {
        Catch::cout() << "Available reporters:\n";
        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
        std::size_t maxNameLen = 0;
        for( auto const& factoryKvp : factories )
            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
 
        for( auto const& factoryKvp : factories ) {
            Catch::cout()
                    << Column( factoryKvp.first + ":" )
                            .indent(2)
                            .width( 5+maxNameLen )
                    +  Column( factoryKvp.second->getDescription() )
                            .initialIndent(0)
                            .indent(2)
                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
                    << "\n";
        }
        Catch::cout() << std::endl;
        return factories.size();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

listTags()

std::size_t Catch::listTags

(

Config const &

config

)

Definition at line 93 of file catch_list.cpp.

                                               {
        TestSpec testSpec = config.testSpec();
        if( config.hasTestFilters() )
            Catch::cout() << "Tags for matching test cases:\n";
        else {
            Catch::cout() << "All available tags:\n";
        }
 
        std::map<std::string, TagInfo> tagCounts;
 
        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
        for( auto const& testCase : matchedTestCases ) {
            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
                std::string lcaseTagName = toLower( tagName );
                auto countIt = tagCounts.find( lcaseTagName );
                if( countIt == tagCounts.end() )
                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
                countIt->second.add( tagName );
            }
        }
 
        for( auto const& tagCount : tagCounts ) {
            ReusableStringStream rss;
            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
            auto str = rss.str();
            auto wrapper = Column( tagCount.second.all() )
                                                    .initialIndent( 0 )
                                                    .indent( str.size() )
                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
            Catch::cout() << str << wrapper << '\n';
        }
        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
        return tagCounts.size();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

listTests()

std::size_t Catch::listTests

(

Config const &

config

)

Definition at line 30 of file catch_list.cpp.

                                                {
        TestSpec testSpec = config.testSpec();
        if( config.hasTestFilters() )
            Catch::cout() << "Matching test cases:\n";
        else {
            Catch::cout() << "All available test cases:\n";
        }
 
        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
        for( auto const& testCaseInfo : matchedTestCases ) {
            Colour::Code colour = testCaseInfo.isHidden()
                ? Colour::SecondaryText
                : Colour::None;
            Colour colourGuard( colour );
 
            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
            if( config.verbosity() >= Verbosity::High ) {
                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
                std::string description = testCaseInfo.description;
                if( description.empty() )
                    description = "(NO DESCRIPTION)";
                Catch::cout() << Column( description ).indent(4) << std::endl;
            }
            if( !testCaseInfo.tags.empty() )
                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
        }
 
        if( !config.hasTestFilters() )
            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
        else
            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
        return matchedTestCases.size();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

listTestsNamesOnly()

std::size_t Catch::listTestsNamesOnly

(

Config const &

config

)

Definition at line 64 of file catch_list.cpp.

                                                         {
        TestSpec testSpec = config.testSpec();
        std::size_t matchedTests = 0;
        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
        for( auto const& testCaseInfo : matchedTestCases ) {
            matchedTests++;
            if( startsWith( testCaseInfo.name, '#' ) )
               Catch::cout() << '"' << testCaseInfo.name << '"';
            else
               Catch::cout() << testCaseInfo.name;
            if ( config.verbosity() >= Verbosity::High )
                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
            Catch::cout() << std::endl;
        }
        return matchedTests;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

makeCommandLineParser()

clara::Parser Catch::makeCommandLineParser

(

ConfigData &

config

)

Definition at line 21 of file catch_commandline.cpp.

                                                            {
 
        using namespace clara;
 
        auto const setWarning = [&]( std::string const& warning ) {
                auto warningSet = [&]() {
                    if( warning == "NoAssertions" )
                        return WarnAbout::NoAssertions;
 
                    if ( warning == "NoTests" )
                        return WarnAbout::NoTests;
 
                    return WarnAbout::Nothing;
                }();
 
                if (warningSet == WarnAbout::Nothing)
                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
                return ParserResult::ok( ParseResultType::Matched );
            };
        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
                std::ifstream f( filename.c_str() );
                if( !f.is_open() )
                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
 
                std::string line;
                while( std::getline( f, line ) ) {
                    line = trim(line);
                    if( !line.empty() && !startsWith( line, '#' ) ) {
                        if( !startsWith( line, '"' ) )
                            line = '"' + line + '"';
                        config.testsOrTags.push_back( line + ',' );
                    }
                }
                return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setTestOrder = [&]( std::string const& order ) {
                if( startsWith( "declared", order ) )
                    config.runOrder = RunTests::InDeclarationOrder;
                else if( startsWith( "lexical", order ) )
                    config.runOrder = RunTests::InLexicographicalOrder;
                else if( startsWith( "random", order ) )
                    config.runOrder = RunTests::InRandomOrder;
                else
                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
                return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setRngSeed = [&]( std::string const& seed ) {
                if( seed != "time" )
                    return clara::detail::convertInto( seed, config.rngSeed );
                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
                return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setColourUsage = [&]( std::string const& useColour ) {
                    auto mode = toLower( useColour );
 
                    if( mode == "yes" )
                        config.useColour = UseColour::Yes;
                    else if( mode == "no" )
                        config.useColour = UseColour::No;
                    else if( mode == "auto" )
                        config.useColour = UseColour::Auto;
                    else
                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
                return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
                auto keypressLc = toLower( keypress );
                if( keypressLc == "start" )
                    config.waitForKeypress = WaitForKeypress::BeforeStart;
                else if( keypressLc == "exit" )
                    config.waitForKeypress = WaitForKeypress::BeforeExit;
                else if( keypressLc == "both" )
                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
                else
                    return ParserResult::runtimeError( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
            return ParserResult::ok( ParseResultType::Matched );
            };
        auto const setVerbosity = [&]( std::string const& verbosity ) {
            auto lcVerbosity = toLower( verbosity );
            if( lcVerbosity == "quiet" )
                config.verbosity = Verbosity::Quiet;
            else if( lcVerbosity == "normal" )
                config.verbosity = Verbosity::Normal;
            else if( lcVerbosity == "high" )
                config.verbosity = Verbosity::High;
            else
                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
            return ParserResult::ok( ParseResultType::Matched );
        };
        auto const setReporter = [&]( std::string const& reporter ) {
            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
 
            auto lcReporter = toLower( reporter );
            auto result = factories.find( lcReporter );
 
            if( factories.end() != result )
                config.reporterName = lcReporter;
            else
                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
            return ParserResult::ok( ParseResultType::Matched );
        };
 
        auto cli
            = ExeName( config.processName )
            | Help( config.showHelp )
            | Opt( config.listTests )
                ["-l"]["--list-tests"]
                ( "list all/matching test cases" )
            | Opt( config.listTags )
                ["-t"]["--list-tags"]
                ( "list all/matching tags" )
            | Opt( config.showSuccessfulTests )
                ["-s"]["--success"]
                ( "include successful tests in output" )
            | Opt( config.shouldDebugBreak )
                ["-b"]["--break"]
                ( "break into debugger on failure" )
            | Opt( config.noThrow )
                ["-e"]["--nothrow"]
                ( "skip exception tests" )
            | Opt( config.showInvisibles )
                ["-i"]["--invisibles"]
                ( "show invisibles (tabs, newlines)" )
            | Opt( config.outputFilename, "filename" )
                ["-o"]["--out"]
                ( "output filename" )
            | Opt( setReporter, "name" )
                ["-r"]["--reporter"]
                ( "reporter to use (defaults to console)" )
            | Opt( config.name, "name" )
                ["-n"]["--name"]
                ( "suite name" )
            | Opt( [&]( bool ){ config.abortAfter = 1; } )
                ["-a"]["--abort"]
                ( "abort at first failure" )
            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
                ["-x"]["--abortx"]
                ( "abort after x failures" )
            | Opt( setWarning, "warning name" )
                ["-w"]["--warn"]
                ( "enable warnings" )
            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
                ["-d"]["--durations"]
                ( "show test durations" )
            | Opt( loadTestNamesFromFile, "filename" )
                ["-f"]["--input-file"]
                ( "load test names to run from a file" )
            | Opt( config.filenamesAsTags )
                ["-#"]["--filenames-as-tags"]
                ( "adds a tag for the filename" )
            | Opt( config.sectionsToRun, "section name" )
                ["-c"]["--section"]
                ( "specify section to run" )
            | Opt( setVerbosity, "quiet|normal|high" )
                ["-v"]["--verbosity"]
                ( "set output verbosity" )
            | Opt( config.listTestNamesOnly )
                ["--list-test-names-only"]
                ( "list all/matching test cases names only" )
            | Opt( config.listReporters )
                ["--list-reporters"]
                ( "list all reporters" )
            | Opt( setTestOrder, "decl|lex|rand" )
                ["--order"]
                ( "test case order (defaults to decl)" )
            | Opt( setRngSeed, "'time'|number" )
                ["--rng-seed"]
                ( "set a specific seed for random numbers" )
            | Opt( setColourUsage, "yes|no" )
                ["--use-colour"]
                ( "should output be colourised" )
            | Opt( config.libIdentify )
                ["--libidentify"]
                ( "report name and version according to libidentify standard" )
            | Opt( setWaitForKeypress, "start|exit|both" )
                ["--wait-for-keypress"]
                ( "waits for a keypress before exiting" )
            | Opt( config.benchmarkResolutionMultiple, "multiplier" )
                ["--benchmark-resolution-multiple"]
                ( "multiple of clock resolution to run benchmarks" )
 
            | Arg( config.testsOrTags, "test name|pattern|tags" )
                ( "which test or tests to use" );
 
        return cli;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

makeMatchExpr()

template<typename ArgT , typename MatcherT >

auto Catch::makeMatchExpr	(	ArgT const &	arg,
		MatcherT const &	matcher,
		StringRef const &	matcherString ) -> MatchExpr<ArgT, MatcherT>

Definition at line 49 of file catch_capture_matchers.h.

                                                                                                                                 {
        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
    }

makeStream()

auto Catch::makeStream

(

StringRef const &

filename

)

-> IStream const *

Definition at line 125 of file catch_stream.cpp.

                                                                   {
        if( filename.empty() )
            return new detail::CoutStream();
        else if( filename[0] == '%' ) {
            if( filename == "%debug" )
                return new detail::DebugOutStream();
            else
                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
        }
        else
            return new detail::FileStream( filename );
    }

makeTestCase()

TestCase Catch::makeTestCase	(	ITestInvoker *	_testCase,
		std::string const &	_className,
		NameAndTags const &	nameAndTags,
		SourceLineInfo const &	_lineInfo )

Definition at line 51 of file catch_test_case_info.cpp.

    {
        bool isHidden = false;
 
        // Parse out tags
        std::vector<std::string> tags;
        std::string desc, tag;
        bool inTag = false;
        std::string _descOrTags = nameAndTags.tags;
        for (char c : _descOrTags) {
            if( !inTag ) {
                if( c == '[' )
                    inTag = true;
                else
                    desc += c;
            }
            else {
                if( c == ']' ) {
                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
                        isHidden = true;
                    else if( prop == TestCaseInfo::None )
                        enforceNotReservedTag( tag, _lineInfo );
 
                    // Merged hide tags like `[.approvals]` should be added as
                    // `[.][approvals]`. The `[.]` is added at later point, so
                    // we only strip the prefix
                    if (startsWith(tag, '.') && tag.size() > 1) {
                        tag.erase(0, 1);
                    }
                    tags.push_back( tag );
                    tag.clear();
                    inTag = false;
                }
                else
                    tag += c;
            }
        }
        if( isHidden ) {
            tags.push_back( "." );
        }
 
        TestCaseInfo info( nameAndTags.name, _className, desc, tags, _lineInfo );
        return TestCase( _testCase, std::move(info) );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

makeTestInvoker() [1/2]

auto Catch::makeTestInvoker ( void(* testAsFunction )() ) -> ITestInvoker *

noexcept

Definition at line 15 of file catch_test_registry.cpp.

                                                                              {
        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
    }

makeTestInvoker() [2/2]

template<typename C >

auto Catch::makeTestInvoker ( void(C::* testAsMethod )() ) -> ITestInvoker*

noexcept

Definition at line 36 of file catch_test_registry.h.

                                                                          {
    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
}

matchTest()

bool Catch::matchTest	(	TestCase const &	testCase,
		TestSpec const &	testSpec,
		IConfig const &	config )

Definition at line 39 of file catch_test_case_registry_impl.cpp.

                                                                                                {
        return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

operator""_sr()

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

inlinenoexcept

Definition at line 122 of file catch_stringref.h.

                                                                                              {
        return StringRef( rawChars, size );
    }

Here is the call graph for this function:

operator+() [1/4]

auto Catch::operator+	(	char const *	lhs,
		StringRef const &	rhs ) -> std::string

Definition at line 110 of file catch_stringref.cpp.

                                                                           {
        return std::string( lhs ) + std::string( rhs );
    }

operator+() [2/4]

auto Catch::operator+	(	StringRef const &	lhs,
		const char *	rhs ) -> std::string

Definition at line 107 of file catch_stringref.cpp.

                                                                           {
        return std::string( lhs ) + std::string( rhs );
    }

operator+() [3/4]

auto Catch::operator+	(	StringRef const &	lhs,
		StringRef const &	rhs ) -> std::string

Definition at line 100 of file catch_stringref.cpp.

                                                                                {
        std::string str;
        str.reserve( lhs.size() + rhs.size() );
        str += lhs;
        str += rhs;
        return str;
    }

operator+() [4/4]

template<typename T >

T const & Catch::operator+	(	T const &	value,
		StreamEndStop	)

Definition at line 83 of file catch_common.h.

                                                          {
        return value;
    }

operator+=()

auto Catch::operator+=	(	std::string &	lhs,
		StringRef const &	rhs ) -> std::string &

Definition at line 118 of file catch_stringref.cpp.

                                                                          {
        lhs.append(rhs.currentData(), rhs.size());
        return lhs;
    }

operator<<() [1/7]

std::ostream & Catch::operator<<	(	std::ostream &	os,
		Colour const &	)

Definition at line 228 of file catch_console_colour.cpp.

                                                              {
        return os;
    }

operator<<() [2/7]

auto Catch::operator<<	(	std::ostream &	os,
		LazyExpression const &	lazyExpr ) -> std::ostream&

Definition at line 38 of file catch_assertionhandler.cpp.

                                                                                       {
        if( lazyExpr.m_isNegated )
            os << "!";
 
        if( lazyExpr ) {
            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
                os << "(" << *lazyExpr.m_transientExpression << ")";
            else
                os << *lazyExpr.m_transientExpression;
        }
        else {
            os << "{** error - unchecked empty expression requested **}";
        }
        return os;
    }

operator<<() [3/7]

std::ostream & Catch::operator<<	(	std::ostream &	os,
		pluralise const &	pluraliser )

Definition at line 90 of file catch_string_manip.cpp.

                                                                            {
        os << pluraliser.m_count << ' ' << pluraliser.m_label;
        if( pluraliser.m_count != 1 )
            os << 's';
        return os;
    }

operator<<() [4/7]

std::ostream & Catch::operator<<	(	std::ostream &	os,
		SourceLineInfo const &	info )

Definition at line 30 of file catch_common.cpp.

                                                                           {
#ifndef __GNUG__
        os << info.file << '(' << info.line << ')';
#else
        os << info.file << ':' << info.line;
#endif
        return os;
    }

operator<<() [5/7]

auto Catch::operator<<	(	std::ostream &	os,
		StringRef const &	str ) -> std::ostream &

Definition at line 114 of file catch_stringref.cpp.

                                                                             {
        return os.write(str.currentData(), str.size());
    }

operator<<() [6/7]

std::ostream & Catch::operator<<	(	std::ostream &	os,
		Version const &	version )

Definition at line 27 of file catch_version.cpp.

                                                                       {
        os  << version.majorVersion << '.'
            << version.minorVersion << '.'
            << version.patchNumber;
        // branchName is never null -> 0th char is \0 if it is empty
        if (version.branchName[0]) {
            os << '-' << version.branchName
               << '.' << version.buildNumber;
        }
        return os;
    }

operator<<() [7/7]

std::ostream & Catch::operator<<	(	std::ostream &	os,
		XmlEncode const &	xmlEncode )

Definition at line 155 of file catch_xmlwriter.cpp.

                                                                           {
        xmlEncode.encodeTo( os );
        return os;
    }

operator|()

ResultDisposition::Flags Catch::operator|	(	ResultDisposition::Flags	lhs,
		ResultDisposition::Flags	rhs )

Definition at line 20 of file catch_result_type.cpp.

                                                                                                 {
        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
    }

parseTestSpec()

TestSpec Catch::parseTestSpec

(

std::string const &

arg

)

Definition at line 83 of file catch_test_spec_parser.cpp.

                                                   {
        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

prepareExpandedExpression()

void Catch::prepareExpandedExpression

(

AssertionResult &

result

)

Definition at line 20 of file catch_reporter_bases.cpp.

                                                            {
        result.getExpandedExpression();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

rangeToString() [1/2]

template<typename Range >

std::string Catch::rangeToString

(

Range const &

range

)

Definition at line 487 of file catch_tostring.h.

                                                  {
        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
    }

Here is the caller graph for this function:

rangeToString() [2/2]

template<typename Allocator >

std::string Catch::rangeToString

(

std::vector< bool, Allocator > const &

v

)

Definition at line 493 of file catch_tostring.h.

                                                                   {
        ReusableStringStream rss;
        rss << "{ ";
        bool first = true;
        for( bool b : v ) {
            if( first )
                first = false;
            else
                rss << ", ";
            rss << ::Catch::Detail::stringify( b );
        }
        rss << " }";
        return rss.str();
    }

Here is the call graph for this function:

registerTestMethods()

std::size_t Catch::registerTestMethods ( )

inline

Definition at line 75 of file catch_objc.hpp.

                                           {
        std::size_t noTestMethods = 0;
        int noClasses = objc_getClassList( nullptr, 0 );
 
        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
        objc_getClassList( classes, noClasses );
 
        for( int c = 0; c < noClasses; c++ ) {
            Class cls = classes[c];
            {
                u_int count;
                Method* methods = class_copyMethodList( cls, &count );
                for( u_int m = 0; m < count ; m++ ) {
                    SEL selector = method_getName(methods[m]);
                    std::string methodName = sel_getName(selector);
                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
                        std::string testCaseName = methodName.substr( 15 );
                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
                        const char* className = class_getName( cls );
 
                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
                        noTestMethods++;
                    }
                }
                free(methods);
            }
        }
        return noTestMethods;
    }

Here is the call graph for this function:

replaceInPlace()

bool Catch::replaceInPlace	(	std::string &	str,
		std::string const &	replaceThis,
		std::string const &	withThis )

Definition at line 56 of file catch_string_manip.cpp.

                                                                                                   {
        bool replaced = false;
        std::size_t i = str.find( replaceThis );
        while( i != std::string::npos ) {
            replaced = true;
            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
            if( i < str.size()-withThis.size() )
                i = str.find( replaceThis, i+withThis.size() );
            else
                i = std::string::npos;
        }
        return replaced;
    }

Here is the caller graph for this function:

rng()

std::mt19937 & Catch::rng

(

)

Definition at line 14 of file catch_random_number_generator.cpp.

                      {
        static std::mt19937 s_rng;
        return s_rng;
    }

Here is the caller graph for this function:

rngSeed()

unsigned int Catch::rngSeed

(

)

Definition at line 26 of file catch_random_number_generator.cpp.

                           {
        return getCurrentContext().getConfig()->rngSeed();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

seedRng()

void Catch::seedRng

(

IConfig const &

config

)

Definition at line 19 of file catch_random_number_generator.cpp.

                                          {
        if( config.rngSeed() != 0 ) {
            std::srand( config.rngSeed() );
            rng().seed( config.rngSeed() );
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeFilters()

std::string Catch::serializeFilters

(

std::vector< std::string > const &

container

)

Definition at line 44 of file catch_reporter_bases.cpp.

                                                                        {
        ReusableStringStream oss;
        bool first = true;
        for (auto&& filter : container)
        {
            if (!first)
                oss << ' ';
            else
                first = false;
 
            oss << filter;
        }
        return oss.str();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

setTags()

void Catch::setTags	(	TestCaseInfo &	testCaseInfo,
		std::vector< std::string >	tags )

Definition at line 100 of file catch_test_case_info.cpp.

                                                                          {
        std::sort(begin(tags), end(tags));
        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
        testCaseInfo.lcaseTags.clear();
 
        for( auto const& tag : tags ) {
            std::string lcaseTag = toLower( tag );
            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
            testCaseInfo.lcaseTags.push_back( lcaseTag );
        }
        testCaseInfo.tags = std::move(tags);
    }

Here is the caller graph for this function:

shouldContinueOnFailure()

bool Catch::shouldContinueOnFailure

(

int

flags

)

Definition at line 24 of file catch_result_type.cpp.

{ return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }

shouldSuppressFailure()

bool Catch::shouldSuppressFailure

(

int

flags

)

Definition at line 25 of file catch_result_type.cpp.

{ return ( flags & ResultDisposition::SuppressFail ) != 0; }

Here is the caller graph for this function:

sortTests()

std::vector< TestCase > Catch::sortTests	(	IConfig const &	config,
		std::vector< TestCase > const &	unsortedTestCases )

Definition at line 21 of file catch_test_case_registry_impl.cpp.

                                                                                                         {
 
        std::vector<TestCase> sorted = unsortedTestCases;
 
        switch( config.runOrder() ) {
            case RunTests::InLexicographicalOrder:
                std::sort( sorted.begin(), sorted.end() );
                break;
            case RunTests::InRandomOrder:
                seedRng( config );
                std::shuffle( sorted.begin(), sorted.end(), rng() );
                break;
            case RunTests::InDeclarationOrder:
                // already in declaration order
                break;
        }
        return sorted;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

splitStringRef()

std::vector< StringRef > Catch::splitStringRef	(	StringRef	str,
		char	delimiter )

Definition at line 70 of file catch_string_manip.cpp.

                                                                         {
        std::vector<StringRef> subStrings;
        std::size_t start = 0;
        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
            if( str[pos] == delimiter ) {
                if( pos - start > 1 )
                    subStrings.push_back( str.substr( start, pos-start ) );
                start = pos+1;
            }
        }
        if( start < str.size() )
            subStrings.push_back( str.substr( start, str.size()-start ) );
        return subStrings;
    }

Here is the caller graph for this function:

startsWith() [1/2]

bool Catch::startsWith	(	std::string const &	s,
		char	prefix )

Definition at line 28 of file catch_string_manip.cpp.

                                                       {
        return !s.empty() && s[0] == prefix;
    }

startsWith() [2/2]

bool Catch::startsWith	(	std::string const &	s,
		std::string const &	prefix )

Definition at line 25 of file catch_string_manip.cpp.

                                                                   {
        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
    }

Here is the caller graph for this function:

throw_exception()

void Catch::throw_exception

(

std::exception const &

e

)

Definition at line 13 of file catch_enforce.cpp.

                                                {
        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
                      << "The message was: " << e.what() << '\n';
        std::terminate();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

to_string()

template<typename T >

std::string Catch::to_string

(

T const &

t

)

Definition at line 17 of file catch_to_string.hpp.

                                    {
#if defined(CATCH_CONFIG_CPP11_TO_STRING)
        return std::to_string(t);
#else
        ReusableStringStream rss;
        rss << t;
        return rss.str();
#endif
    }

Here is the call graph for this function:

Here is the caller graph for this function:

toLower()

std::string Catch::toLower

(

std::string const &

s

)

Definition at line 43 of file catch_string_manip.cpp.

                                            {
        std::string lc = s;
        toLowerInPlace( lc );
        return lc;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

toLowerInPlace()

void Catch::toLowerInPlace

(

std::string &

s

)

Definition at line 40 of file catch_string_manip.cpp.

                                        {
        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
    }

Here is the caller graph for this function:

translateActiveException()

std::string Catch::translateActiveException

(

)

Definition at line 90 of file catch_registry_hub.cpp.

                                         {
        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

trim()

std::string Catch::trim

(

std::string const &

str

)

Definition at line 48 of file catch_string_manip.cpp.

                                           {
        static char const* whitespaceChars = "\n\r\t ";
        std::string::size_type start = str.find_first_not_of( whitespaceChars );
        std::string::size_type end = str.find_last_not_of( whitespaceChars );
 
        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
    }

Here is the caller graph for this function:

uncaught_exceptions()

bool Catch::uncaught_exceptions

(

)

Definition at line 14 of file catch_uncaught_exceptions.cpp.

                               {
#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
        return std::uncaught_exceptions() > 0;
#else
        return std::uncaught_exception();
#endif
  }

Here is the caller graph for this function:

writeToDebugConsole()

void Catch::writeToDebugConsole

(

std::string const &

text

)

Definition at line 25 of file catch_debug_console.cpp.

                                                          {
            // !TBD: Need a version for Mac/ XCode and other IDEs
            Catch::cout() << text;
        }

Here is the call graph for this function:

Variable Documentation

begin

not_this_one Catch::begin

(

...

)

end

not_this_one Catch::end

(

...

)

leakDetector

LeakDetector Catch::leakDetector

Definition at line 26 of file catch_impl.hpp.