/*

* Catch v2.6.1

* Generated: 2019-02-12 19:52:52.262497

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

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

* Copyright (c) 2019 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

// start catch.hpp

#define CATCH_VERSION_MAJOR 2

#define CATCH_VERSION_MINOR 6

#define CATCH_VERSION_PATCH 1

#ifdef __clang__

# pragma clang system_header

#elif defined __GNUC__

# pragma GCC system_header

#endif

// start 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 push

# pragma clang diagnostic ignored "-Wpadded"

# pragma clang diagnostic ignored "-Wswitch-enum"

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

# endif

#elif defined __GNUC__

// Because REQUIREs trigger GCC's -Wparentheses, and because still

// supported version of g++ have only buggy support for _Pragmas,

// Wparentheses have to be suppressed globally.

# pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details

# pragma GCC diagnostic push

# pragma GCC diagnostic ignored "-Wunused-variable"

# pragma GCC diagnostic ignored "-Wpadded"

#endif

// end catch_suppress_warnings.h

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

# define CATCH_IMPL

# define CATCH_CONFIG_ALL_PARTS

#endif

// In the impl file, we want to have access to all parts of the headers

// Can also be used to sanely support PCHs

#if defined(CATCH_CONFIG_ALL_PARTS)

# define CATCH_CONFIG_EXTERNAL_INTERFACES

# if defined(CATCH_CONFIG_DISABLE_MATCHERS)

# undef CATCH_CONFIG_DISABLE_MATCHERS

# endif

# if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)

# define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER

# endif

#endif

#if !defined(CATCH_CONFIG_IMPL_ONLY)

// start catch_platform.h

#ifdef __APPLE__

# include <TargetConditionals.h>

# if TARGET_OS_OSX == 1

# define CATCH_PLATFORM_MAC

# elif TARGET_OS_IPHONE == 1

# define CATCH_PLATFORM_IPHONE

# endif

#elif defined(linux) || defined(__linux) || defined(__linux__)

# define CATCH_PLATFORM_LINUX

#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)

# define CATCH_PLATFORM_WINDOWS

#endif

// end catch_platform.h

#ifdef CATCH_IMPL

# ifndef CLARA_CONFIG_MAIN

# define CLARA_CONFIG_MAIN_NOT_DEFINED

# define CLARA_CONFIG_MAIN

# endif

#endif

// start catch_user_interfaces.h

namespace Catch {

unsigned int rngSeed();

}

// end catch_user_interfaces.h

// start catch_tag_alias_autoregistrar.h

// start catch_common.h

// start catch_compiler_capabilities.h

// Detect a number of compiler features - by compiler

// The following features are defined:

//

// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?

// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?

// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?

// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?

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

// 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_NO_POSIX_SIGNALS) 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.

#ifdef __cplusplus

# if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)

# define CATCH_CPP14_OR_GREATER

# endif

# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)

# define CATCH_CPP17_OR_GREATER

# endif

#endif

#if defined(CATCH_CPP17_OR_GREATER)

# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS

#endif

#ifdef __clang__

# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \

_Pragma( "clang diagnostic push" ) \

_Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \

_Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")

# define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \

_Pragma( "clang diagnostic pop" )

# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \

_Pragma( "clang diagnostic push" ) \

_Pragma( "clang diagnostic ignored \"-Wparentheses\"" )

# define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \

_Pragma( "clang diagnostic pop" )

# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \

_Pragma( "clang diagnostic push" ) \

_Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )

# define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS \

_Pragma( "clang diagnostic pop" )

#endif // __clang__

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

// Assume that non-Windows platforms support posix signals by default

#if !defined(CATCH_PLATFORM_WINDOWS)

#define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS

#endif

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

// We know some environments not to support full POSIX signals

#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)

#define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS

#endif

#ifdef __OS400__

# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS

# define CATCH_CONFIG_COLOUR_NONE

#endif

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

// Android somehow still does not support std::to_string

#if defined(__ANDROID__)

# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING

#endif

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

// Not all Windows environments support SEH properly

#if defined(__MINGW32__)

# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH

#endif

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

// PS4

#if defined(__ORBIS__)

# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE

#endif

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

// Cygwin

#ifdef __CYGWIN__

// Required for some versions of Cygwin to declare gettimeofday

// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin

# define _BSD_SOURCE

// some versions of cygwin (most) do not support std::to_string. Use the libstd check.

// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813

# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \

&& !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))

# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING

# endif

#endif // __CYGWIN__

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

// Visual C++

#ifdef _MSC_VER

# if _MSC_VER >= 1900 // Visual Studio 2015 or newer

# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS

# endif

// Universal Windows platform does not support SEH

// Or console colours (or console at all...)

# if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)

# define CATCH_CONFIG_COLOUR_NONE

# else

# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH

# endif

// MSVC traditional preprocessor needs some workaround for __VA_ARGS__

// _MSVC_TRADITIONAL == 0 means new conformant preprocessor

// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor

# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)

# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR

# endif

#endif // _MSC_VER

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

// Check if we are compiled with -fno-exceptions or equivalent

#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)

# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED

#endif

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

// DJGPP

#ifdef __DJGPP__

# define CATCH_INTERNAL_CONFIG_NO_WCHAR

#endif // __DJGPP__

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

// Embarcadero C++Build

#if defined(__BORLANDC__)

#define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN

#endif

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

// Use of __COUNTER__ is suppressed during code analysis in

// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly

// handled by it.

// Otherwise all supported compilers support COUNTER macro,

// but user still might want to turn it off

#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )

#define CATCH_INTERNAL_CONFIG_COUNTER

#endif

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

// Check if string_view is available and usable

// The check is split apart to work around v140 (VS2015) preprocessor issue...

#if defined(__has_include)

#if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)

# define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW

#endif

#endif

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

// Check if optional is available and usable

#if defined(__has_include)

# if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)

# define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL

# endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)

#endif // __has_include

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

// Check if variant is available and usable

#if defined(__has_include)

# if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)

# if defined(__clang__) && (__clang_major__ < 8)

// work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852

// fix should be in clang 8, workaround in libstdc++ 8.2

# include <ciso646>

# if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)

# define CATCH_CONFIG_NO_CPP17_VARIANT

# else

# define CATCH_INTERNAL_CONFIG_CPP17_VARIANT

# endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)

# else

# define CATCH_INTERNAL_CONFIG_CPP17_VARIANT

# endif // defined(__clang__) && (__clang_major__ < 8)

# endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)

#endif // __has_include

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

# define CATCH_CONFIG_COUNTER

#endif

#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)

# define CATCH_CONFIG_WINDOWS_SEH

#endif

// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.

#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)

# define CATCH_CONFIG_POSIX_SIGNALS

#endif

// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.

#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)

# define CATCH_CONFIG_WCHAR

#endif

#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)

# define CATCH_CONFIG_CPP11_TO_STRING

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)

# define CATCH_CONFIG_CPP17_OPTIONAL

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)

# define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)

# define CATCH_CONFIG_CPP17_STRING_VIEW

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)

# define CATCH_CONFIG_CPP17_VARIANT

#endif

#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)

# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE

#endif

#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)

# define CATCH_CONFIG_NEW_CAPTURE

#endif

#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)

# define CATCH_CONFIG_DISABLE_EXCEPTIONS

#endif

#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)

# define CATCH_CONFIG_POLYFILL_ISNAN

#endif

#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)

# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS

# define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS

#endif

#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)

# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS

# define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS

#endif

#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)

# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS

# define CATCH_INTERNAL_UNSUPPRESS_UNUSED_WARNINGS

#endif

#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)

#define CATCH_TRY if ((true))

#define CATCH_CATCH_ALL if ((false))

#define CATCH_CATCH_ANON(type) if ((false))

#else

#define CATCH_TRY try

#define CATCH_CATCH_ALL catch (...)

#define CATCH_CATCH_ANON(type) catch (type)

#endif

#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)

#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR

#endif

// end catch_compiler_capabilities.h

#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

#include <iosfwd>

#include <string>

#include <cstdint>

// We need a dummy global operator<< so we can bring it into Catch namespace later

struct Catch_global_namespace_dummy {};

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

namespace Catch {

struct CaseSensitive { enum Choice {

Yes,

No

}; };

class NonCopyable {

NonCopyable( NonCopyable const& ) = delete;

NonCopyable( NonCopyable && ) = delete;

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

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

protected:

NonCopyable();

virtual ~NonCopyable();

};

struct SourceLineInfo {

SourceLineInfo() = delete;

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

: file( _file ),

line( _line )

{}

SourceLineInfo( SourceLineInfo const& other ) = default;

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

SourceLineInfo( SourceLineInfo&& ) noexcept = default;

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

bool empty() const noexcept;

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

bool operator < ( SourceLineInfo const& other ) const noexcept;

char const* file;

std::size_t line;

};

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

// Bring in operator<< from global namespace into Catch namespace

// This is necessary because the overload of operator<< above makes

// lookup stop at namespace Catch

using ::operator<<;

// Use this in variadic streaming macros to allow

// >> +StreamEndStop

// as well as

// >> stuff +StreamEndStop

struct StreamEndStop {

std::string operator+() const;

};

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

// end catch_common.h

namespace Catch {

struct RegistrarForTagAliases {

RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );

};

} // end namespace Catch

#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \

CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \

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

CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS

// end catch_tag_alias_autoregistrar.h

// start catch_test_registry.h

// start catch_interfaces_testcase.h

#include <vector>

namespace Catch {

class TestSpec;

struct ITestInvoker {

virtual void invoke () const = 0;

virtual ~ITestInvoker();

};

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

}

// end catch_interfaces_testcase.h

// start catch_stringref.h

#include <cstddef>

#include <string>

#include <iosfwd>

namespace Catch {

/// A non-owning string class (similar to the forthcoming std::string_view)

/// Note that, because a StringRef may be a substring of another string,

/// it may not be null terminated. c_str() must return a null terminated

/// string, however, and so the StringRef will internally take ownership

/// (taking a copy), if necessary. In theory this ownership is not externally

/// visible - but it does mean (substring) StringRefs should not be shared between

/// threads.

class StringRef {

public:

using size_type = std::size_t;

private:

friend struct StringRefTestAccess;

char const* m_start;

size_type m_size;

char* m_data = nullptr;

void takeOwnership();

static constexpr char const* const s_empty = "";

public: // construction/ assignment

StringRef() noexcept

: StringRef( s_empty, 0 )

{}

StringRef( StringRef const& other ) noexcept

: m_start( other.m_start ),

m_size( other.m_size )

{}

StringRef( StringRef&& other ) noexcept

: m_start( other.m_start ),

m_size( other.m_size ),

m_data( other.m_data )

{

other.m_data = nullptr;

}

StringRef( char const* rawChars ) noexcept;

StringRef( char const* rawChars, size_type size ) noexcept

: m_start( rawChars ),

m_size( size )

{}

StringRef( std::string const& stdString ) noexcept

: m_start( stdString.c_str() ),

m_size( stdString.size() )

{}

~StringRef() noexcept {

delete[] m_data;

}

auto operator = ( StringRef const &other ) noexcept -> StringRef& {

delete[] m_data;

m_data = nullptr;

m_start = other.m_start;

m_size = other.m_size;

return *this;

}

operator std::string() const;

void swap( StringRef& other ) noexcept;

public: // operators

auto operator == ( StringRef const& other ) const noexcept -> bool;

auto operator != ( StringRef const& other ) const noexcept -> bool;

auto operator[] ( size_type index ) const noexcept -> char;

public: // named queries

auto empty() const noexcept -> bool {

return m_size == 0;

}

auto size() const noexcept -> size_type {

return m_size;

}

auto numberOfCharacters() const noexcept -> size_type;

auto c_str() const -> char const*;

public: // substrings and searches

auto substr( size_type start, size_type size ) const noexcept -> StringRef;

// Returns the current start pointer.

// Note that the pointer can change when if the StringRef is a substring

auto currentData() const noexcept -> char const*;

private: // ownership queries - may not be consistent between calls

auto isOwned() const noexcept -> bool;

auto isSubstring() const noexcept -> bool;

};

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

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

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

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

auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;

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

return StringRef( rawChars, size );

}

} // namespace Catch

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

return Catch::StringRef( rawChars, size );

}

// end catch_stringref.h

// start catch_type_traits.hpp

#include <type_traits>

namespace Catch{

#ifdef CATCH_CPP17_OR_GREATER

template <typename...>

inline constexpr auto is_unique = std::true_type{};

template <typename T, typename... Rest>

inline constexpr auto is_unique<T, Rest...> = std::bool_constant<

(!std::is_same_v<T, Rest> && ...) && is_unique<Rest...>

>{};

#else

template <typename...>

struct is_unique : std::true_type{};

template <typename T0, typename T1, typename... Rest>

struct is_unique<T0, T1, Rest...> : std::integral_constant

<bool,

!std::is_same<T0, T1>::value

&& is_unique<T0, Rest...>::value

&& is_unique<T1, Rest...>::value

>{};

#endif

}

// end catch_type_traits.hpp

// start catch_preprocessor.hpp

#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__

#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))

#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))

#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))

#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))

#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))

#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR

#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__

// MSVC needs more evaluations

#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))

#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))

#else

#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__)

#endif

#define CATCH_REC_END(...)

#define CATCH_REC_OUT

#define CATCH_EMPTY()

#define CATCH_DEFER(id) id CATCH_EMPTY()

#define CATCH_REC_GET_END2() 0, CATCH_REC_END

#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2

#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1

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

#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)

#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)

#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )

#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )

#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )

#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )

#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )

#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )

// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,

// and passes userdata as the first parameter to each invocation,

// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)

#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))

#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))

#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)

#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__

#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__

#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF

#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)

#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME2(Name, ...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME3(Name, __VA_ARGS__)

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR

#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME3(Name,...) Name " - " #__VA_ARGS__

#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME(Name,...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME2(Name, INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))

#else

// MSVC is adding extra space and needs more calls to properly remove ()

#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME3(Name,...) Name " -" #__VA_ARGS__

#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME1(Name, ...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME2(Name, __VA_ARGS__)

#define INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME(Name, ...) INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME1(Name, INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))

#endif

#define INTERNAL_CATCH_MAKE_TYPE_LIST(types) TypeList<INTERNAL_CATCH_REMOVE_PARENS(types)>

#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(types)\

CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,INTERNAL_CATCH_REMOVE_PARENS(types))

// end catch_preprocessor.hpp

// start catch_meta.hpp

#include <type_traits>

template< typename... >

struct TypeList{};

template< typename... >

struct append;

template< template<typename...> class L1

, typename...E1

, template<typename...> class L2

, typename...E2

>

struct append< L1<E1...>, L2<E2...> >

{

using type = L1<E1..., E2...>;

};

template< template<typename...> class L1

, typename...E1

, template<typename...> class L2

, typename...E2

, typename...Rest

>

struct append< L1<E1...>, L2<E2...>, Rest...>

{

using type = typename append< L1<E1..., E2...>, Rest... >::type;

};

template< template<typename...> class

, typename...

>

struct rewrap;

template< template<typename...> class Container

, template<typename...> class List

, typename...elems

>

struct rewrap<Container, List<elems...>>

{

using type = TypeList< Container< elems... > >;

};

template< template<typename...> class Container

, template<typename...> class List

, class...Elems

, typename...Elements>

struct rewrap<Container, List<Elems...>, Elements...>

{

using type = typename append<TypeList<Container<Elems...>>, typename rewrap<Container, Elements...>::type>::type;

};

template< template<typename...> class...Containers >

struct combine

{

template< typename...Types >

struct with_types

{

template< template <typename...> class Final >

struct into

{

using type = typename append<Final<>, typename rewrap<Containers, Types...>::type...>::type;

};

};

};

template<typename T>

struct always_false : std::false_type {};

// end catch_meta.hpp

namespace Catch {

template<typename C>

class TestInvokerAsMethod : public ITestInvoker {

void (C::*m_testAsMethod)();

public:

TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}

void invoke() const override {

C obj;

(obj.*m_testAsMethod)();

}

};

auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;

template<typename C>

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

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

}

struct NameAndTags {

NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;

StringRef name;

StringRef tags;

};

struct AutoReg : NonCopyable {

AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;

~AutoReg();

};

} // end namespace Catch

#if defined(CATCH_CONFIG_DISABLE)

#define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \

static void TestName()

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

namespace{ \

struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \

void test(); \

}; \

} \

void TestName::test()

#define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION( TestName, ... ) \

template<typename TestType> \

static void TestName()

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

namespace{ \

template<typename TestType> \

struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \

void test(); \

}; \

} \

template<typename TestType> \

void TestName::test()

#endif

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

#define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \

static void TestName(); \

CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \

namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \

CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \

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, ... ) \

CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \

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

CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS

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

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

CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \

namespace{ \

struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \

void test(); \

}; \

Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \

} \

CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \

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_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \

Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \

CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS

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

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

CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \

template<typename TestType> \

static void TestFunc();\

namespace {\

template<typename...Types> \

struct TestName{\

template<typename...Ts> \

TestName(Ts...names){\

CATCH_INTERNAL_CHECK_UNIQUE_TYPES(CATCH_REC_LIST(INTERNAL_CATCH_REMOVE_PARENS, __VA_ARGS__)) \

using expander = int[];\

(void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ names, Tags } ), 0)... };/* NOLINT */ \

}\

};\

INTERNAL_CATCH_TEMPLATE_REGISTRY_INITIATE(TestName, Name, __VA_ARGS__) \

}\

CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \

template<typename TestType> \

static void TestFunc()

#if defined(CATCH_CPP17_OR_GREATER)

#define CATCH_INTERNAL_CHECK_UNIQUE_TYPES(...) static_assert(Catch::is_unique<__VA_ARGS__>,"Duplicate type detected in declaration of template test case");

#else

#define CATCH_INTERNAL_CHECK_UNIQUE_TYPES(...) static_assert(Catch::is_unique<__VA_ARGS__>::value,"Duplicate type detected in declaration of template test case");

#endif

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR

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

INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, __VA_ARGS__ )

#else

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

INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, __VA_ARGS__ ) )

#endif

#define INTERNAL_CATCH_TEMPLATE_REGISTRY_INITIATE(TestName, Name, ...)\

static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\

TestName<CATCH_REC_LIST(INTERNAL_CATCH_REMOVE_PARENS, __VA_ARGS__)>(CATCH_REC_LIST_UD(INTERNAL_CATCH_TEMPLATE_UNIQUE_NAME,Name, __VA_ARGS__));\

return 0;\

}();

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

CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \

template<typename TestType> static void TestFuncName(); \

namespace { \

template<typename... Types> \

struct TestName { \

TestName() { \

CATCH_INTERNAL_CHECK_UNIQUE_TYPES(Types...) \

int index = 0; \

using expander = int[]; \

(void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + Catch::StringMaker<int>::convert(index++), Tags } ), 0)... };/* NOLINT */ \

} \

}; \

static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \

using TestInit = combine<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)> \

::with_types<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(TypesList)>::into<TestName>::type; \

TestInit(); \

return 0; \

}(); \

} \

CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \

template<typename TestType> \

static void TestFuncName()

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR

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

INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ),Name,Tags,__VA_ARGS__)

#else

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

INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, __VA_ARGS__ ) )

#endif

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

CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \

namespace{ \

template<typename TestType> \

struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \

void test();\

};\

template<typename...Types> \

struct TestNameClass{\

template<typename...Ts> \

TestNameClass(Ts...names){\

CATCH_INTERNAL_CHECK_UNIQUE_TYPES(CATCH_REC_LIST(INTERNAL_CATCH_REMOVE_PARENS, __VA_ARGS__)) \

using expander = int[];\

(void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ names, Tags } ), 0)... };/* NOLINT */ \

}\

};\

INTERNAL_CATCH_TEMPLATE_REGISTRY_INITIATE(TestNameClass, Name, __VA_ARGS__)\

}\

CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS\

template<typename TestType> \

void TestName<TestType>::test()

#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR

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

INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, __VA_ARGS__ )

#else

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