/*

* Catch v1.4.0

* Generated: 2016-03-15 07:23:12.623111

* ----------------------------------------------------------

* This file has been merged from multiple headers. Please don't edit it directly

* Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.

*

* Distributed under the Boost Software License, Version 1.0. (See accompanying

* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

*/

#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED

#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED

#define TWOBLUECUBES_CATCH_HPP_INCLUDED

#ifdef __clang__

# pragma clang system_header

#elif defined __GNUC__

# pragma GCC system_header

#endif

// #included from: internal/catch_suppress_warnings.h

#ifdef __clang__

# ifdef __ICC // icpc defines the __clang__ macro

# pragma warning(push)

# pragma warning(disable: 161 1682)

# else // __ICC

# pragma clang diagnostic ignored "-Wglobal-constructors"

# pragma clang diagnostic ignored "-Wvariadic-macros"

# pragma clang diagnostic ignored "-Wc99-extensions"

# pragma clang diagnostic ignored "-Wunused-variable"

# pragma clang diagnostic push

# pragma clang diagnostic ignored "-Wpadded"

# pragma clang diagnostic ignored "-Wc++98-compat"

# pragma clang diagnostic ignored "-Wc++98-compat-pedantic"

# pragma clang diagnostic ignored "-Wswitch-enum"

# pragma clang diagnostic ignored "-Wcovered-switch-default"

# endif

#elif defined __GNUC__

# pragma GCC diagnostic ignored "-Wvariadic-macros"

# pragma GCC diagnostic ignored "-Wunused-variable"

# pragma GCC diagnostic push

# pragma GCC diagnostic ignored "-Wpadded"

#endif

#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)

# define CATCH_IMPL

#endif

#ifdef CATCH_IMPL

# ifndef CLARA_CONFIG_MAIN

# define CLARA_CONFIG_MAIN_NOT_DEFINED

# define CLARA_CONFIG_MAIN

# endif

#endif

// #included from: internal/catch_notimplemented_exception.h

#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED

// #included from: catch_common.h

#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED

#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line

#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )

#ifdef CATCH_CONFIG_COUNTER

# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )

#else

# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )

#endif

#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr

#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )

#include <sstream>

#include <stdexcept>

#include <algorithm>

// #included from: catch_compiler_capabilities.h

#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED

// Detect a number of compiler features - mostly C++11/14 conformance - by compiler

// The following features are defined:

//

// CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported?

// CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported?

// CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods

// CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported?

// CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported

// CATCH_CONFIG_CPP11_LONG_LONG : is long long supported?

// CATCH_CONFIG_CPP11_OVERRIDE : is override supported?

// CATCH_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)

// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported?

// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported?

// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?

// ****************

// Note to maintainers: if new toggles are added please document them

// in configuration.md, too

// ****************

// In general each macro has a _NO_<feature name> form

// (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature.

// Many features, at point of detection, define an _INTERNAL_ macro, so they

// can be combined, en-mass, with the _NO_ forms later.

// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11

#if defined(__cplusplus) && __cplusplus >= 201103L

# define CATCH_CPP11_OR_GREATER

#endif

#ifdef __clang__

# if __has_feature(cxx_nullptr)

# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR

# endif

# if __has_feature(cxx_noexcept)

# define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT

# endif

# if defined(CATCH_CPP11_OR_GREATER)

# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )

# endif

#endif // __clang__

////////////////////////////////////////////////////////////////////////////////

// Borland

#ifdef __BORLANDC__

#endif // __BORLANDC__

////////////////////////////////////////////////////////////////////////////////

// EDG

#ifdef __EDG_VERSION__

#endif // __EDG_VERSION__

////////////////////////////////////////////////////////////////////////////////

// Digital Mars

#ifdef __DMC__

#endif // __DMC__

////////////////////////////////////////////////////////////////////////////////

// GCC

#ifdef __GNUC__

# if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)

# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR

# endif

# if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS) && defined(CATCH_CPP11_OR_GREATER)

# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )

# endif

// - otherwise more recent versions define __cplusplus >= 201103L

// and will get picked up below

#endif // __GNUC__

////////////////////////////////////////////////////////////////////////////////

// Visual C++

#ifdef _MSC_VER

#if (_MSC_VER >= 1600)

# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR

# define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR

#endif

#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015))

#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT

#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS

#endif

#endif // _MSC_VER

////////////////////////////////////////////////////////////////////////////////

// Use variadic macros if the compiler supports them

#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \

( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \

( defined __GNUC__ && __GNUC__ >= 3 ) || \

( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )

#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS

#endif

// Use __COUNTER__ if the compiler supports it

#if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \

( defined __GNUC__ && __GNUC__ >= 4 && __GNUC_MINOR__ >= 3 ) || \

( defined __clang__ && __clang_major__ >= 3 )

#define CATCH_INTERNAL_CONFIG_COUNTER

#endif

////////////////////////////////////////////////////////////////////////////////

// C++ language feature support

// catch all support for C++11

#if defined(CATCH_CPP11_OR_GREATER)

# if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR)

# define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR

# endif

# ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT

# define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT

# endif

# ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS

# define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS

# endif

# ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM

# define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM

# endif

# ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE

# define CATCH_INTERNAL_CONFIG_CPP11_TUPLE

# endif

# ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS

# define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS

# endif

# if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG)

# define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG

# endif

# if !defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE)

# define CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE

# endif

# if !defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)

# define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR

# endif

#endif // __cplusplus >= 201103L

// Now set the actual defines based on the above + anything the user has configured

#if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11)

# define CATCH_CONFIG_CPP11_NULLPTR

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11)

# define CATCH_CONFIG_CPP11_NOEXCEPT

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11)

# define CATCH_CONFIG_CPP11_GENERATED_METHODS

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11)

# define CATCH_CONFIG_CPP11_IS_ENUM

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11)

# define CATCH_CONFIG_CPP11_TUPLE

#endif

#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS)

# define CATCH_CONFIG_VARIADIC_MACROS

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11)

# define CATCH_CONFIG_CPP11_LONG_LONG

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11)

# define CATCH_CONFIG_CPP11_OVERRIDE

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11)

# define CATCH_CONFIG_CPP11_UNIQUE_PTR

#endif

#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)

# define CATCH_CONFIG_COUNTER

#endif

#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)

# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS

#endif

// noexcept support:

#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)

# define CATCH_NOEXCEPT noexcept

# define CATCH_NOEXCEPT_IS(x) noexcept(x)

#else

# define CATCH_NOEXCEPT throw()

# define CATCH_NOEXCEPT_IS(x)

#endif

// nullptr support

#ifdef CATCH_CONFIG_CPP11_NULLPTR

# define CATCH_NULL nullptr

#else

# define CATCH_NULL NULL

#endif

// override support

#ifdef CATCH_CONFIG_CPP11_OVERRIDE

# define CATCH_OVERRIDE override

#else

# define CATCH_OVERRIDE

#endif

// unique_ptr support

#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR

# define CATCH_AUTO_PTR( T ) std::unique_ptr<T>

#else

# define CATCH_AUTO_PTR( T ) std::auto_ptr<T>

#endif

namespace Catch {

struct IConfig;

struct CaseSensitive { enum Choice {

Yes,

No

}; };

class NonCopyable {

#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS

NonCopyable( NonCopyable const& ) = delete;

NonCopyable( NonCopyable && ) = delete;

NonCopyable& operator = ( NonCopyable const& ) = delete;

NonCopyable& operator = ( NonCopyable && ) = delete;

#else

NonCopyable( NonCopyable const& info );

NonCopyable& operator = ( NonCopyable const& );

#endif

protected:

NonCopyable() {}

virtual ~NonCopyable();

};

class SafeBool {

public:

typedef void (SafeBool::*type)() const;

static type makeSafe( bool value ) {

return value ? &SafeBool::trueValue : 0;

}

private:

void trueValue() const {}

};

template<typename ContainerT>

inline void deleteAll( ContainerT& container ) {

typename ContainerT::const_iterator it = container.begin();

typename ContainerT::const_iterator itEnd = container.end();

for(; it != itEnd; ++it )

delete *it;

}

template<typename AssociativeContainerT>

inline void deleteAllValues( AssociativeContainerT& container ) {

typename AssociativeContainerT::const_iterator it = container.begin();

typename AssociativeContainerT::const_iterator itEnd = container.end();

for(; it != itEnd; ++it )

delete it->second;

}

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

bool endsWith( std::string const& s, std::string const& 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 );

struct pluralise {

pluralise( std::size_t count, std::string const& label );

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

std::size_t m_count;

std::string m_label;

};

struct SourceLineInfo {

SourceLineInfo();

SourceLineInfo( char const* _file, std::size_t _line );

SourceLineInfo( SourceLineInfo const& other );

# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS

SourceLineInfo( SourceLineInfo && ) = default;

SourceLineInfo& operator = ( SourceLineInfo const& ) = default;

SourceLineInfo& operator = ( SourceLineInfo && ) = default;

# endif

bool empty() const;

bool operator == ( SourceLineInfo const& other ) const;

bool operator < ( SourceLineInfo const& other ) const;

std::string file;

std::size_t line;

};

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

// This is just here to avoid compiler warnings with macro constants and boolean literals

inline bool isTrue( bool value ){ return value; }

inline bool alwaysTrue() { return true; }

inline bool alwaysFalse() { return false; }

void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo );

void seedRng( IConfig const& config );

unsigned int rngSeed();

// Use this in variadic streaming macros to allow

// >> +StreamEndStop

// as well as

// >> stuff +StreamEndStop

struct StreamEndStop {

std::string operator+() {

return std::string();

}

};

template<typename T>

T const& operator + ( T const& value, StreamEndStop ) {

return value;

}

}

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

#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO );

#include <ostream>

namespace Catch {

class NotImplementedException : public std::exception

{

public:

NotImplementedException( SourceLineInfo const& lineInfo );

NotImplementedException( NotImplementedException const& ) {}

virtual ~NotImplementedException() CATCH_NOEXCEPT {}

virtual const char* what() const CATCH_NOEXCEPT;

private:

std::string m_what;

SourceLineInfo m_lineInfo;

};

} // end namespace Catch

///////////////////////////////////////////////////////////////////////////////

#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )

// #included from: internal/catch_context.h

#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED

// #included from: catch_interfaces_generators.h

#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED

#include <string>

namespace Catch {

struct IGeneratorInfo {

virtual ~IGeneratorInfo();

virtual bool moveNext() = 0;

virtual std::size_t getCurrentIndex() const = 0;

};

struct IGeneratorsForTest {

virtual ~IGeneratorsForTest();

virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;

virtual bool moveNext() = 0;

};

IGeneratorsForTest* createGeneratorsForTest();

} // end namespace Catch

// #included from: catch_ptr.hpp

#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wpadded"

#endif

namespace Catch {

// An intrusive reference counting smart pointer.

// T must implement addRef() and release() methods

// typically implementing the IShared interface

template<typename T>

class Ptr {

public:

Ptr() : m_p( CATCH_NULL ){}

Ptr( T* p ) : m_p( p ){

if( m_p )

m_p->addRef();

}

Ptr( Ptr const& other ) : m_p( other.m_p ){

if( m_p )

m_p->addRef();

}

~Ptr(){

if( m_p )

m_p->release();

}

void reset() {

if( m_p )

m_p->release();

m_p = CATCH_NULL;

}

Ptr& operator = ( T* p ){

Ptr temp( p );

swap( temp );

return *this;

}

Ptr& operator = ( Ptr const& other ){

Ptr temp( other );

swap( temp );

return *this;

}

void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }

T* get() const{ return m_p; }

T& operator*() const { return *m_p; }

T* operator->() const { return m_p; }

bool operator !() const { return m_p == CATCH_NULL; }

operator SafeBool::type() const { return SafeBool::makeSafe( m_p != CATCH_NULL ); }

private:

T* m_p;

};

struct IShared : NonCopyable {

virtual ~IShared();

virtual void addRef() const = 0;

virtual void release() const = 0;

};

template<typename T = IShared>

struct SharedImpl : T {

SharedImpl() : m_rc( 0 ){}

virtual void addRef() const {

++m_rc;

}

virtual void release() const {

if( --m_rc == 0 )

delete this;

}

mutable unsigned int m_rc;

};

} // end namespace Catch

#ifdef __clang__

#pragma clang diagnostic pop

#endif

#include <memory>

#include <vector>

#include <stdlib.h>

namespace Catch {

class TestCase;

class Stream;

struct IResultCapture;

struct IRunner;

struct IGeneratorsForTest;

struct IConfig;

struct IContext

{

virtual ~IContext();

virtual IResultCapture* getResultCapture() = 0;

virtual IRunner* getRunner() = 0;

virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;

virtual bool advanceGeneratorsForCurrentTest() = 0;

virtual Ptr<IConfig const> getConfig() const = 0;

};

struct IMutableContext : IContext

{

virtual ~IMutableContext();

virtual void setResultCapture( IResultCapture* resultCapture ) = 0;

virtual void setRunner( IRunner* runner ) = 0;

virtual void setConfig( Ptr<IConfig const> const& config ) = 0;

};

IContext& getCurrentContext();

IMutableContext& getCurrentMutableContext();

void cleanUpContext();

Stream createStream( std::string const& streamName );

}

// #included from: internal/catch_test_registry.hpp

#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED

// #included from: catch_interfaces_testcase.h

#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED

#include <vector>

namespace Catch {

class TestSpec;

struct ITestCase : IShared {

virtual void invoke () const = 0;

protected:

virtual ~ITestCase();

};

class TestCase;

struct IConfig;

struct ITestCaseRegistry {

virtual ~ITestCaseRegistry();

virtual std::vector<TestCase> const& getAllTests() const = 0;

virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;

};

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

}

namespace Catch {

template<typename C>

class MethodTestCase : public SharedImpl<ITestCase> {

public:

MethodTestCase( void (C::*method)() ) : m_method( method ) {}

virtual void invoke() const {

C obj;

(obj.*m_method)();

}

private:

virtual ~MethodTestCase() {}

void (C::*m_method)();

};

typedef void(*TestFunction)();

struct NameAndDesc {

NameAndDesc( const char* _name = "", const char* _description= "" )

: name( _name ), description( _description )

{}

const char* name;

const char* description;

};

void registerTestCase

( ITestCase* testCase,

char const* className,

NameAndDesc const& nameAndDesc,

SourceLineInfo const& lineInfo );

struct AutoReg {

AutoReg

( TestFunction function,

SourceLineInfo const& lineInfo,

NameAndDesc const& nameAndDesc );

template<typename C>

AutoReg

( void (C::*method)(),

char const* className,

NameAndDesc const& nameAndDesc,

SourceLineInfo const& lineInfo ) {

registerTestCase

( new MethodTestCase<C>( method ),

className,

nameAndDesc,

lineInfo );

}

~AutoReg();

private:

AutoReg( AutoReg const& );

void operator= ( AutoReg const& );

};

void registerTestCaseFunction

( TestFunction function,

SourceLineInfo const& lineInfo,

NameAndDesc const& nameAndDesc );

} // end namespace Catch

#ifdef CATCH_CONFIG_VARIADIC_MACROS

///////////////////////////////////////////////////////////////////////////////

#define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \

static void TestName(); \

namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); }\

static void TestName()

#define INTERNAL_CATCH_TESTCASE( ... ) \

INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )

///////////////////////////////////////////////////////////////////////////////

#define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \

namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); }

///////////////////////////////////////////////////////////////////////////////

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

namespace{ \

struct TestName : ClassName{ \

void test(); \

}; \

Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); \

} \

void TestName::test()

#define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \

INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )

///////////////////////////////////////////////////////////////////////////////

#define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \

Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) );

#else

///////////////////////////////////////////////////////////////////////////////

#define INTERNAL_CATCH_TESTCASE2( TestName, Name, Desc ) \

static void TestName(); \

namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); }\

static void TestName()

#define INTERNAL_CATCH_TESTCASE( Name, Desc ) \

INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), Name, Desc )

///////////////////////////////////////////////////////////////////////////////

#define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \

namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); }

///////////////////////////////////////////////////////////////////////////////

#define INTERNAL_CATCH_TEST_CASE_METHOD2( TestCaseName, ClassName, TestName, Desc )\

namespace{ \

struct TestCaseName : ClassName{ \

void test(); \

}; \

Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); \

} \

void TestCaseName::test()

#define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\

INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, TestName, Desc )

///////////////////////////////////////////////////////////////////////////////

#define INTERNAL_CATCH_REGISTER_TESTCASE( Function, Name, Desc ) \

Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) );

#endif

// #included from: internal/catch_capture.hpp

#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED

// #included from: catch_result_builder.h

#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED

// #included from: catch_result_type.h

#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED

namespace Catch {

// ResultWas::OfType enum

struct ResultWas { enum OfType {

Unknown = -1,

Ok = 0,

Info = 1,

Warning = 2,

FailureBit = 0x10,

ExpressionFailed = FailureBit | 1,

ExplicitFailure = FailureBit | 2,

Exception = 0x100 | FailureBit,

ThrewException = Exception | 1,

DidntThrowException = Exception | 2,

FatalErrorCondition = 0x200 | FailureBit

}; };

inline bool isOk( ResultWas::OfType resultType ) {

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

}

inline bool isJustInfo( int flags ) {

return flags == ResultWas::Info;

}

// ResultDisposition::Flags enum

struct ResultDisposition { enum Flags {

Normal = 0x01,

ContinueOnFailure = 0x02, // Failures fail test, but execution continues

FalseTest = 0x04, // Prefix expression with !

SuppressFail = 0x08 // Failures are reported but do not fail the test

}; };

inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {

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

}

inline bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }

inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }

inline bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; }

} // end namespace Catch

// #included from: catch_assertionresult.h

#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED

#include <string>

namespace Catch {

struct AssertionInfo

{

AssertionInfo() {}

AssertionInfo( std::string const& _macroName,

SourceLineInfo const& _lineInfo,

std::string const& _capturedExpression,

ResultDisposition::Flags _resultDisposition );

std::string macroName;

SourceLineInfo lineInfo;

std::string capturedExpression;

ResultDisposition::Flags resultDisposition;

};

struct AssertionResultData

{

AssertionResultData() : resultType( ResultWas::Unknown ) {}

std::string reconstructedExpression;

std::string message;

ResultWas::OfType resultType;

};

class AssertionResult {

public:

AssertionResult();

AssertionResult( AssertionInfo const& info, AssertionResultData const& data );

~AssertionResult();

# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS

AssertionResult( AssertionResult const& ) = default;

AssertionResult( AssertionResult && ) = default;

AssertionResult& operator = ( AssertionResult const& ) = default;

AssertionResult& operator = ( AssertionResult && ) = default;

# endif

bool isOk() const;

bool succeeded() const;

ResultWas::OfType getResultType() const;

bool hasExpression() const;

bool hasMessage() const;

std::string getExpression() const;

std::string getExpressionInMacro() const;

bool hasExpandedExpression() const;

std::string getExpandedExpression() const;

std::string getMessage() const;

SourceLineInfo getSourceInfo() const;

std::string getTestMacroName() const;

protected:

AssertionInfo m_info;

AssertionResultData m_resultData;

};

} // end namespace Catch

// #included from: catch_matchers.hpp

#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED

namespace Catch {

namespace Matchers {

namespace Impl {

namespace Generic {

template<typename ExpressionT> class AllOf;

template<typename ExpressionT> class AnyOf;

template<typename ExpressionT> class Not;

}

template<typename ExpressionT>

struct Matcher : SharedImpl<IShared>

{

typedef ExpressionT ExpressionType;

virtual ~Matcher() {}

virtual Ptr<Matcher> clone() const = 0;

virtual bool match( ExpressionT const& expr ) const = 0;

virtual std::string toString() const = 0;

Generic::AllOf<ExpressionT> operator && ( Matcher<ExpressionT> const& other ) const;

Generic::AnyOf<ExpressionT> operator || ( Matcher<ExpressionT> const& other ) const;

Generic::Not<ExpressionT> operator ! () const;

};

template<typename DerivedT, typename ExpressionT>

struct MatcherImpl : Matcher<ExpressionT> {

virtual Ptr<Matcher<ExpressionT> > clone() const {

return Ptr<Matcher<ExpressionT> >( new DerivedT( static_cast<DerivedT const&>( *this ) ) );

}

};

namespace Generic {

template<typename ExpressionT>

class Not : public MatcherImpl<Not<ExpressionT>, ExpressionT> {

public:

explicit Not( Matcher<ExpressionT> const& matcher ) : m_matcher(matcher.clone()) {}

Not( Not const& other ) : m_matcher( other.m_matcher ) {}

virtual bool match( ExpressionT const& expr ) const CATCH_OVERRIDE {

return !m_matcher->match( expr );

}

virtual std::string toString() const CATCH_OVERRIDE {

return "not " + m_matcher->toString();

}

private:

Ptr< Matcher<ExpressionT> > m_matcher;

};

template<typename ExpressionT>

class AllOf : public MatcherImpl<AllOf<ExpressionT>, ExpressionT> {

public:

AllOf() {}

AllOf( AllOf const& other ) : m_matchers( other.m_matchers ) {}

AllOf& add( Matcher<ExpressionT> const& matcher ) {

m_matchers.push_back( matcher.clone() );

return *this;

}

virtual bool match( ExpressionT const& expr ) const

{

for( std::size_t i = 0; i < m_matchers.size(); ++i )

if( !m_matchers[i]->match( expr ) )

return false;

return true;

}

virtual std::string toString() const {

std::ostringstream oss;

oss << "( ";

for( std::size_t i = 0; i < m_matchers.size(); ++i ) {

if( i != 0 )

oss << " and ";

oss << m_matchers[i]->toString();

}

oss << " )";

return oss.str();

}

AllOf operator && ( Matcher<ExpressionT> const& other ) const {

AllOf allOfExpr( *this );

allOfExpr.add( other );

return allOfExpr;

}

private:

std::vector<Ptr<Matcher<ExpressionT> > > m_matchers;

};

template<typename ExpressionT>

class AnyOf : public MatcherImpl<AnyOf<ExpressionT>, ExpressionT> {

public:

AnyOf() {}

AnyOf( AnyOf const& other ) : m_matchers( other.m_matchers ) {}

AnyOf& add( Matcher<ExpressionT> const& matcher ) {

m_matchers.push_back( matcher.clone() );

return *this;

}

virtual bool match( ExpressionT const& expr ) const

{

for( std::size_t i = 0; i < m_matchers.size(); ++i )

if( m_matchers[i]->match( expr ) )

return true;

return false;

}

virtual std::string toString() const {

std::ostringstream oss;

oss << "( ";

for( std::size_t i = 0; i < m_matchers.size(); ++i ) {

if( i != 0 )

oss << " or ";

oss << m_matchers[i]->toString();