From 37a19f1ebbb6fc5866660b626207775fa40a8f82 Mon Sep 17 00:00:00 2001 From: Gerald Schmidt Date: Mon, 24 Sep 2018 20:30:11 +0200 Subject: [PATCH] added tests --- .gitignore | 2 + tests/Makefile | 10 + tests/catch.hpp | 11605 ++++++++++++++++++++++++++++++++++++ tests/tests | Bin 0 -> 1433380 bytes tests/tests-main.cpp | 2 + tests/tests-main.o | Bin 0 -> 1507392 bytes tests/tests-readfile.cpp | 15 + tests/tests-replace.cpp | 19 + tests/tests-stringset.cpp | 19 + tests/tests-stringset.o | Bin 0 -> 50792 bytes 10 files changed, 11672 insertions(+) create mode 100644 tests/Makefile create mode 100644 tests/catch.hpp create mode 100755 tests/tests create mode 100644 tests/tests-main.cpp create mode 100644 tests/tests-main.o create mode 100644 tests/tests-readfile.cpp create mode 100644 tests/tests-replace.cpp create mode 100644 tests/tests-stringset.cpp create mode 100644 tests/tests-stringset.o diff --git a/.gitignore b/.gitignore index 436088e..d14aa32 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,5 @@ *.bz2 xmlcopyeditor xmlcopyeditor.exe +*.o +tests-main diff --git a/tests/Makefile b/tests/Makefile new file mode 100644 index 0000000..2abf762 --- /dev/null +++ b/tests/Makefile @@ -0,0 +1,10 @@ +build: + g++ -o tests-main \ + *.cpp \ + ../src/replace.cpp \ + ../src/readfile.cpp +run: + ./tests-main +all: build run +clean: + rm *.o tests-main diff --git a/tests/catch.hpp b/tests/catch.hpp new file mode 100644 index 0000000..849c53c --- /dev/null +++ b/tests/catch.hpp @@ -0,0 +1,11605 @@ +/* + * Catch v1.11.0 + * Generated: 2017-10-31 13:42:42.914833 + * ---------------------------------------------------------- + * 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 ignored "-Wparentheses" + +# 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 + +// #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_SHUFFLE : is std::shuffle supported? +// CATCH_CONFIG_CPP11_TYPE_TRAITS : are type_traits and enable_if supported? + +// 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? +// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported? +// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported? +// **************** +// Note to maintainers: if new toggles are added please document them +// in configuration.md, too +// **************** + +// In general each macro has a _NO_ 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 + +#ifdef __cplusplus + +# if __cplusplus >= 201103L +# define CATCH_CPP11_OR_GREATER +# endif + +# if __cplusplus >= 201402L +# define CATCH_CPP14_OR_GREATER +# endif + +#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_ETD_WARNINGS \ + _Pragma( "clang diagnostic push" ) \ + _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) +# define CATCH_INTERNAL_UNSUPPRESS_ETD_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" ) +# endif + +#endif // __clang__ + +//////////////////////////////////////////////////////////////////////////////// +// We know some environments not to support full POSIX signals +#if defined(__CYGWIN__) || defined(__QNX__) + +# if !defined(CATCH_CONFIG_POSIX_SIGNALS) +# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS +# endif + +#endif + +#ifdef __OS400__ +# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS +# define CATCH_CONFIG_COLOUR_NONE +#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 + +#endif // __CYGWIN__ + +//////////////////////////////////////////////////////////////////////////////// +// 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 + +// - otherwise more recent versions define __cplusplus >= 201103L +// and will get picked up below + +#endif // __GNUC__ + +//////////////////////////////////////////////////////////////////////////////// +// Visual C++ +#ifdef _MSC_VER + +#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH + +#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 +#define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE +#define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS +#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__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \ + ( defined __clang__ && __clang_major__ >= 3 ) + +// Use of __COUNTER__ is suppressed during code analysis in CLion/AppCode 2017.2.x and former, +// because __COUNTER__ is not properly handled by it. +// This does not affect compilation +#if ( !defined __JETBRAINS_IDE__ || __JETBRAINS_IDE__ >= 20170300L ) + #define CATCH_INTERNAL_CONFIG_COUNTER +#endif + +#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 +# if !defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) +# define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE +# endif +# if !defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) +# define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS +# 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_CPP11_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_CPP11_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_CPP11_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_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_NO_CPP11) +# define CATCH_CONFIG_CPP11_SHUFFLE +#endif +# if defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_NO_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_NO_CPP11) +# define CATCH_CONFIG_CPP11_TYPE_TRAITS +# endif +#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_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_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS) +# define CATCH_CONFIG_POSIX_SIGNALS +#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_ETD_WARNINGS) +# define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS +# define CATCH_INTERNAL_UNSUPPRESS_ETD_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 +#else +# define CATCH_AUTO_PTR( T ) std::auto_ptr +#endif + +#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 +#include + +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 + 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 + 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 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 ); + + 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 ); +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + SourceLineInfo(SourceLineInfo const& other) = default; + 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; + + char const* 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 + T const& operator + ( T const& value, StreamEndStop ) { + return value; + } +} + +#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) ) +#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO ); + +namespace Catch { + + class NotImplementedException : public std::exception + { + public: + NotImplementedException( SourceLineInfo const& lineInfo ); + + 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 + +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 + 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 + 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 + +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 getConfig() const = 0; + }; + + struct IMutableContext : IContext + { + virtual ~IMutableContext(); + virtual void setResultCapture( IResultCapture* resultCapture ) = 0; + virtual void setRunner( IRunner* runner ) = 0; + virtual void setConfig( Ptr 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 + +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 const& getAllTests() const = 0; + virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0; + }; + + bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ); + std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ); + std::vector const& getAllTestCasesSorted( IConfig const& config ); + +} + +namespace Catch { + +template +class MethodTestCase : public SharedImpl { + +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 + AutoReg + ( void (C::*method)(), + char const* className, + NameAndDesc const& nameAndDesc, + SourceLineInfo const& lineInfo ) { + + registerTestCase + ( new MethodTestCase( 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(); \ + CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); } /* NOLINT */ \ + CATCH_INTERNAL_UNSUPPRESS_ETD_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_ETD_WARNINGS \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \ + CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\ + CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \ + namespace{ \ + struct TestName : ClassName{ \ + void test(); \ + }; \ + Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \ + } \ + CATCH_INTERNAL_UNSUPPRESS_ETD_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_ETD_WARNINGS \ + Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); /* NOLINT */ \ + CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS + +#else + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TESTCASE2( TestName, Name, Desc ) \ + static void TestName(); \ + CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); } /* NOLINT */ \ + CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \ + 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 ) \ + CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \ + namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \ + CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS + + /////////////////////////////////////////////////////////////////////////////// + #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestCaseName, ClassName, TestName, Desc )\ + CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \ + namespace{ \ + struct TestCaseName : ClassName{ \ + void test(); \ + }; \ + Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \ + } \ + CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \ + 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_INTERNAL_SUPPRESS_ETD_WARNINGS \ + Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); /* NOLINT */ \ + CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS + +#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( static_cast( lhs ) | static_cast( 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 + +namespace Catch { + + struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison; + + struct DecomposedExpression + { + virtual ~DecomposedExpression() {} + virtual bool isBinaryExpression() const { + return false; + } + virtual void reconstructExpression( std::string& dest ) const = 0; + + // Only simple binary comparisons can be decomposed. + // If more complex check is required then wrap sub-expressions in parentheses. + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( T const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( T const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( T const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( T const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator % ( T const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( T const& ); + template STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( T const& ); + + private: + DecomposedExpression& operator = (DecomposedExpression const&); + }; + + struct AssertionInfo + { + AssertionInfo(); + AssertionInfo( char const * _macroName, + SourceLineInfo const& _lineInfo, + char const * _capturedExpression, + ResultDisposition::Flags _resultDisposition, + char const * _secondArg = ""); + + char const * macroName; + SourceLineInfo lineInfo; + char const * capturedExpression; + ResultDisposition::Flags resultDisposition; + char const * secondArg; + }; + + struct AssertionResultData + { + AssertionResultData() : decomposedExpression( CATCH_NULL ) + , resultType( ResultWas::Unknown ) + , negated( false ) + , parenthesized( false ) {} + + void negate( bool parenthesize ) { + negated = !negated; + parenthesized = parenthesize; + if( resultType == ResultWas::Ok ) + resultType = ResultWas::ExpressionFailed; + else if( resultType == ResultWas::ExpressionFailed ) + resultType = ResultWas::Ok; + } + + std::string const& reconstructExpression() const { + if( decomposedExpression != CATCH_NULL ) { + decomposedExpression->reconstructExpression( reconstructedExpression ); + if( parenthesized ) { + reconstructedExpression.insert( 0, 1, '(' ); + reconstructedExpression.append( 1, ')' ); + } + if( negated ) { + reconstructedExpression.insert( 0, 1, '!' ); + } + decomposedExpression = CATCH_NULL; + } + return reconstructedExpression; + } + + mutable DecomposedExpression const* decomposedExpression; + mutable std::string reconstructedExpression; + std::string message; + ResultWas::OfType resultType; + bool negated; + bool parenthesized; + }; + + 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; + void discardDecomposedExpression() const; + void expandDecomposedExpression() 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 { + + template struct MatchAllOf; + template struct MatchAnyOf; + template struct MatchNotOf; + + class MatcherUntypedBase { + public: + std::string toString() const { + if( m_cachedToString.empty() ) + m_cachedToString = describe(); + return m_cachedToString; + } + + protected: + virtual ~MatcherUntypedBase(); + virtual std::string describe() const = 0; + mutable std::string m_cachedToString; + private: + MatcherUntypedBase& operator = ( MatcherUntypedBase const& ); + }; + + template + struct MatcherMethod { + virtual bool match( ObjectT const& arg ) const = 0; + }; + template + struct MatcherMethod { + virtual bool match( PtrT* arg ) const = 0; + }; + + template + struct MatcherBase : MatcherUntypedBase, MatcherMethod { + + MatchAllOf operator && ( MatcherBase const& other ) const; + MatchAnyOf operator || ( MatcherBase const& other ) const; + MatchNotOf operator ! () const; + }; + + template + struct MatchAllOf : MatcherBase { + virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE { + for( std::size_t i = 0; i < m_matchers.size(); ++i ) { + if (!m_matchers[i]->match(arg)) + return false; + } + return true; + } + virtual std::string describe() const CATCH_OVERRIDE { + std::string description; + description.reserve( 4 + m_matchers.size()*32 ); + description += "( "; + for( std::size_t i = 0; i < m_matchers.size(); ++i ) { + if( i != 0 ) + description += " and "; + description += m_matchers[i]->toString(); + } + description += " )"; + return description; + } + + MatchAllOf& operator && ( MatcherBase const& other ) { + m_matchers.push_back( &other ); + return *this; + } + + std::vector const*> m_matchers; + }; + template + struct MatchAnyOf : MatcherBase { + + virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE { + for( std::size_t i = 0; i < m_matchers.size(); ++i ) { + if (m_matchers[i]->match(arg)) + return true; + } + return false; + } + virtual std::string describe() const CATCH_OVERRIDE { + std::string description; + description.reserve( 4 + m_matchers.size()*32 ); + description += "( "; + for( std::size_t i = 0; i < m_matchers.size(); ++i ) { + if( i != 0 ) + description += " or "; + description += m_matchers[i]->toString(); + } + description += " )"; + return description; + } + + MatchAnyOf& operator || ( MatcherBase const& other ) { + m_matchers.push_back( &other ); + return *this; + } + + std::vector const*> m_matchers; + }; + + template + struct MatchNotOf : MatcherBase { + + MatchNotOf( MatcherBase const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {} + + virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE { + return !m_underlyingMatcher.match( arg ); + } + + virtual std::string describe() const CATCH_OVERRIDE { + return "not " + m_underlyingMatcher.toString(); + } + MatcherBase const& m_underlyingMatcher; + }; + + template + MatchAllOf MatcherBase::operator && ( MatcherBase const& other ) const { + return MatchAllOf() && *this && other; + } + template + MatchAnyOf MatcherBase::operator || ( MatcherBase const& other ) const { + return MatchAnyOf() || *this || other; + } + template + MatchNotOf MatcherBase::operator ! () const { + return MatchNotOf( *this ); + } + + } // namespace Impl + + // The following functions create the actual matcher objects. + // This allows the types to be inferred + // - deprecated: prefer ||, && and ! + template + Impl::MatchNotOf Not( Impl::MatcherBase const& underlyingMatcher ) { + return Impl::MatchNotOf( underlyingMatcher ); + } + template + Impl::MatchAllOf AllOf( Impl::MatcherBase const& m1, Impl::MatcherBase const& m2 ) { + return Impl::MatchAllOf() && m1 && m2; + } + template + Impl::MatchAllOf AllOf( Impl::MatcherBase const& m1, Impl::MatcherBase const& m2, Impl::MatcherBase const& m3 ) { + return Impl::MatchAllOf() && m1 && m2 && m3; + } + template + Impl::MatchAnyOf AnyOf( Impl::MatcherBase const& m1, Impl::MatcherBase const& m2 ) { + return Impl::MatchAnyOf() || m1 || m2; + } + template + Impl::MatchAnyOf AnyOf( Impl::MatcherBase const& m1, Impl::MatcherBase const& m2, Impl::MatcherBase const& m3 ) { + return Impl::MatchAnyOf() || m1 || m2 || m3; + } + +} // namespace Matchers + +using namespace Matchers; +using Matchers::Impl::MatcherBase; + +} // namespace Catch + +namespace Catch { + + struct TestFailureException{}; + + template class ExpressionLhs; + + struct CopyableStream { + CopyableStream() {} + CopyableStream( CopyableStream const& other ) { + oss << other.oss.str(); + } + CopyableStream& operator=( CopyableStream const& other ) { + oss.str(std::string()); + oss << other.oss.str(); + return *this; + } + std::ostringstream oss; + }; + + class ResultBuilder : public DecomposedExpression { + public: + ResultBuilder( char const* macroName, + SourceLineInfo const& lineInfo, + char const* capturedExpression, + ResultDisposition::Flags resultDisposition, + char const* secondArg = "" ); + ~ResultBuilder(); + + template + ExpressionLhs operator <= ( T const& operand ); + ExpressionLhs operator <= ( bool value ); + + template + ResultBuilder& operator << ( T const& value ) { + stream().oss << value; + return *this; + } + + ResultBuilder& setResultType( ResultWas::OfType result ); + ResultBuilder& setResultType( bool result ); + + void endExpression( DecomposedExpression const& expr ); + + virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE; + + AssertionResult build() const; + AssertionResult build( DecomposedExpression const& expr ) const; + + void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal ); + void captureResult( ResultWas::OfType resultType ); + void captureExpression(); + void captureExpectedException( std::string const& expectedMessage ); + void captureExpectedException( Matchers::Impl::MatcherBase const& matcher ); + void handleResult( AssertionResult const& result ); + void react(); + bool shouldDebugBreak() const; + bool allowThrows() const; + + template + void captureMatch( ArgT const& arg, MatcherT const& matcher, char const* matcherString ); + + void setExceptionGuard(); + void unsetExceptionGuard(); + + private: + AssertionInfo m_assertionInfo; + AssertionResultData m_data; + + CopyableStream &stream() + { + if(!m_usedStream) + { + m_usedStream = true; + m_stream().oss.str(""); + } + return m_stream(); + } + + static CopyableStream &m_stream() + { + static CopyableStream s; + return s; + } + + bool m_shouldDebugBreak; + bool m_shouldThrow; + bool m_guardException; + bool m_usedStream; + }; + +} // namespace Catch + +// Include after due to circular dependency: +// #included from: catch_expression_lhs.hpp +#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED + +// #included from: catch_evaluate.hpp +#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable:4389) // '==' : signed/unsigned mismatch +#pragma warning(disable:4018) // more "signed/unsigned mismatch" +#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform) +#endif + +#include + +namespace Catch { +namespace Internal { + + enum Operator { + IsEqualTo, + IsNotEqualTo, + IsLessThan, + IsGreaterThan, + IsLessThanOrEqualTo, + IsGreaterThanOrEqualTo + }; + + template struct OperatorTraits { static const char* getName(){ return "*error*"; } }; + template<> struct OperatorTraits { static const char* getName(){ return "=="; } }; + template<> struct OperatorTraits { static const char* getName(){ return "!="; } }; + template<> struct OperatorTraits { static const char* getName(){ return "<"; } }; + template<> struct OperatorTraits { static const char* getName(){ return ">"; } }; + template<> struct OperatorTraits { static const char* getName(){ return "<="; } }; + template<> struct OperatorTraits{ static const char* getName(){ return ">="; } }; + + template + T& removeConst(T const &t) { return const_cast(t); } +#ifdef CATCH_CONFIG_CPP11_NULLPTR + inline std::nullptr_t removeConst(std::nullptr_t) { return nullptr; } +#endif + + // So the compare overloads can be operator agnostic we convey the operator as a template + // enum, which is used to specialise an Evaluator for doing the comparison. + template + struct Evaluator{}; + + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs) { + return bool(removeConst(lhs) == removeConst(rhs) ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return bool(removeConst(lhs) != removeConst(rhs) ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return bool(removeConst(lhs) < removeConst(rhs) ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return bool(removeConst(lhs) > removeConst(rhs) ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return bool(removeConst(lhs) >= removeConst(rhs) ); + } + }; + template + struct Evaluator { + static bool evaluate( T1 const& lhs, T2 const& rhs ) { + return bool(removeConst(lhs) <= removeConst(rhs) ); + } + }; + + // Special case for comparing a pointer to an int (deduced for p==0) + template + struct Evaluator { + static bool evaluate( int lhs, T* rhs) { + return reinterpret_cast( lhs ) == rhs; + } + }; + template + struct Evaluator { + static bool evaluate( T* lhs, int rhs) { + return lhs == reinterpret_cast( rhs ); + } + }; + template + struct Evaluator { + static bool evaluate( int lhs, T* rhs) { + return reinterpret_cast( lhs ) != rhs; + } + }; + template + struct Evaluator { + static bool evaluate( T* lhs, int rhs) { + return lhs != reinterpret_cast( rhs ); + } + }; + + template + struct Evaluator { + static bool evaluate( long lhs, T* rhs) { + return reinterpret_cast( lhs ) == rhs; + } + }; + template + struct Evaluator { + static bool evaluate( T* lhs, long rhs) { + return lhs == reinterpret_cast( rhs ); + } + }; + template + struct Evaluator { + static bool evaluate( long lhs, T* rhs) { + return reinterpret_cast( lhs ) != rhs; + } + }; + template + struct Evaluator { + static bool evaluate( T* lhs, long rhs) { + return lhs != reinterpret_cast( rhs ); + } + }; + +} // end of namespace Internal +} // end of namespace Catch + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +// #included from: catch_tostring.h +#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED + +#include +#include +#include +#include +#include + +#ifdef __OBJC__ +// #included from: catch_objc_arc.hpp +#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED + +#import + +#ifdef __has_feature +#define CATCH_ARC_ENABLED __has_feature(objc_arc) +#else +#define CATCH_ARC_ENABLED 0 +#endif + +void arcSafeRelease( NSObject* obj ); +id performOptionalSelector( id obj, SEL sel ); + +#if !CATCH_ARC_ENABLED +inline void arcSafeRelease( NSObject* obj ) { + [obj release]; +} +inline id performOptionalSelector( id obj, SEL sel ) { + if( [obj respondsToSelector: sel] ) + return [obj performSelector: sel]; + return nil; +} +#define CATCH_UNSAFE_UNRETAINED +#define CATCH_ARC_STRONG +#else +inline void arcSafeRelease( NSObject* ){} +inline id performOptionalSelector( id obj, SEL sel ) { +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Warc-performSelector-leaks" +#endif + if( [obj respondsToSelector: sel] ) + return [obj performSelector: sel]; +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + return nil; +} +#define CATCH_UNSAFE_UNRETAINED __unsafe_unretained +#define CATCH_ARC_STRONG __strong +#endif + +#endif + +#ifdef CATCH_CONFIG_CPP11_TUPLE +#include +#endif + +#ifdef CATCH_CONFIG_CPP11_IS_ENUM +#include +#endif + +namespace Catch { + +// Why we're here. +template +std::string toString( T const& value ); + +// Built in overloads + +std::string toString( std::string const& value ); +std::string toString( std::wstring const& value ); +std::string toString( const char* const value ); +std::string toString( char* const value ); +std::string toString( const wchar_t* const value ); +std::string toString( wchar_t* const value ); +std::string toString( int value ); +std::string toString( unsigned long value ); +std::string toString( unsigned int value ); +std::string toString( const double value ); +std::string toString( const float value ); +std::string toString( bool value ); +std::string toString( char value ); +std::string toString( signed char value ); +std::string toString( unsigned char value ); + +#ifdef CATCH_CONFIG_CPP11_LONG_LONG +std::string toString( long long value ); +std::string toString( unsigned long long value ); +#endif + +#ifdef CATCH_CONFIG_CPP11_NULLPTR +std::string toString( std::nullptr_t ); +#endif + +#ifdef __OBJC__ + std::string toString( NSString const * const& nsstring ); + std::string toString( NSString * CATCH_ARC_STRONG & nsstring ); + std::string toString( NSObject* const& nsObject ); +#endif + +namespace Detail { + + extern const std::string unprintableString; + + #if !defined(CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK) + struct BorgType { + template BorgType( T const& ); + }; + + struct TrueType { char sizer[1]; }; + struct FalseType { char sizer[2]; }; + + TrueType& testStreamable( std::ostream& ); + FalseType testStreamable( FalseType ); + + FalseType operator<<( std::ostream const&, BorgType const& ); + + template + struct IsStreamInsertable { + static std::ostream &s; + static T const&t; + enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) }; + }; +#else + template + class IsStreamInsertable { + template + static auto test(int) + -> decltype( std::declval() << std::declval(), std::true_type() ); + + template + static auto test(...) -> std::false_type; + + public: + static const bool value = decltype(test(0))::value; + }; +#endif + +#if defined(CATCH_CONFIG_CPP11_IS_ENUM) + template::value + > + struct EnumStringMaker + { + static std::string convert( T const& ) { return unprintableString; } + }; + + template + struct EnumStringMaker + { + static std::string convert( T const& v ) + { + return ::Catch::toString( + static_cast::type>(v) + ); + } + }; +#endif + template + struct StringMakerBase { +#if defined(CATCH_CONFIG_CPP11_IS_ENUM) + template + static std::string convert( T const& v ) + { + return EnumStringMaker::convert( v ); + } +#else + template + static std::string convert( T const& ) { return unprintableString; } +#endif + }; + + template<> + struct StringMakerBase { + template + static std::string convert( T const& _value ) { + std::ostringstream oss; + oss << _value; + return oss.str(); + } + }; + + std::string rawMemoryToString( const void *object, std::size_t size ); + + template + std::string rawMemoryToString( const T& object ) { + return rawMemoryToString( &object, sizeof(object) ); + } + +} // end namespace Detail + +template +struct StringMaker : + Detail::StringMakerBase::value> {}; + +template +struct StringMaker { + template + static std::string convert( U* p ) { + if( !p ) + return "NULL"; + else + return Detail::rawMemoryToString( p ); + } +}; + +template +struct StringMaker { + static std::string convert( R C::* p ) { + if( !p ) + return "NULL"; + else + return Detail::rawMemoryToString( p ); + } +}; + +namespace Detail { + template + std::string rangeToString( InputIterator first, InputIterator last ); +} + +//template +//struct StringMaker > { +// static std::string convert( std::vector const& v ) { +// return Detail::rangeToString( v.begin(), v.end() ); +// } +//}; + +template +std::string toString( std::vector const& v ) { + return Detail::rangeToString( v.begin(), v.end() ); +} + +#ifdef CATCH_CONFIG_CPP11_TUPLE + +// toString for tuples +namespace TupleDetail { + template< + typename Tuple, + std::size_t N = 0, + bool = (N < std::tuple_size::value) + > + struct ElementPrinter { + static void print( const Tuple& tuple, std::ostream& os ) + { + os << ( N ? ", " : " " ) + << Catch::toString(std::get(tuple)); + ElementPrinter::print(tuple,os); + } + }; + + template< + typename Tuple, + std::size_t N + > + struct ElementPrinter { + static void print( const Tuple&, std::ostream& ) {} + }; + +} + +template +struct StringMaker> { + + static std::string convert( const std::tuple& tuple ) + { + std::ostringstream os; + os << '{'; + TupleDetail::ElementPrinter>::print( tuple, os ); + os << " }"; + return os.str(); + } +}; +#endif // CATCH_CONFIG_CPP11_TUPLE + +namespace Detail { + template + std::string makeString( T const& value ) { + return StringMaker::convert( value ); + } +} // end namespace Detail + +/// \brief converts any type to a string +/// +/// The default template forwards on to ostringstream - except when an +/// ostringstream overload does not exist - in which case it attempts to detect +/// that and writes {?}. +/// Overload (not specialise) this template for custom typs that you don't want +/// to provide an ostream overload for. +template +std::string toString( T const& value ) { + return StringMaker::convert( value ); +} + + namespace Detail { + template + std::string rangeToString( InputIterator first, InputIterator last ) { + std::ostringstream oss; + oss << "{ "; + if( first != last ) { + oss << Catch::toString( *first ); + for( ++first ; first != last ; ++first ) + oss << ", " << Catch::toString( *first ); + } + oss << " }"; + return oss.str(); + } +} + +} // end namespace Catch + +namespace Catch { + +template +class BinaryExpression; + +template +class MatchExpression; + +// Wraps the LHS of an expression and overloads comparison operators +// for also capturing those and RHS (if any) +template +class ExpressionLhs : public DecomposedExpression { +public: + ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ), m_truthy(false) {} + + ExpressionLhs& operator = ( const ExpressionLhs& ); + + template + BinaryExpression + operator == ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + BinaryExpression + operator != ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + BinaryExpression + operator < ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + BinaryExpression + operator > ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + BinaryExpression + operator <= ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + template + BinaryExpression + operator >= ( RhsT const& rhs ) { + return captureExpression( rhs ); + } + + BinaryExpression operator == ( bool rhs ) { + return captureExpression( rhs ); + } + + BinaryExpression operator != ( bool rhs ) { + return captureExpression( rhs ); + } + + void endExpression() { + m_truthy = m_lhs ? true : false; + m_rb + .setResultType( m_truthy ) + .endExpression( *this ); + } + + virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE { + dest = Catch::toString( m_lhs ); + } + +private: + template + BinaryExpression captureExpression( RhsT& rhs ) const { + return BinaryExpression( m_rb, m_lhs, rhs ); + } + + template + BinaryExpression captureExpression( bool rhs ) const { + return BinaryExpression( m_rb, m_lhs, rhs ); + } + +private: + ResultBuilder& m_rb; + T m_lhs; + bool m_truthy; +}; + +template +class BinaryExpression : public DecomposedExpression { +public: + BinaryExpression( ResultBuilder& rb, LhsT lhs, RhsT rhs ) + : m_rb( rb ), m_lhs( lhs ), m_rhs( rhs ) {} + + BinaryExpression& operator = ( BinaryExpression& ); + + void endExpression() const { + m_rb + .setResultType( Internal::Evaluator::evaluate( m_lhs, m_rhs ) ) + .endExpression( *this ); + } + + virtual bool isBinaryExpression() const CATCH_OVERRIDE { + return true; + } + + virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE { + std::string lhs = Catch::toString( m_lhs ); + std::string rhs = Catch::toString( m_rhs ); + char delim = lhs.size() + rhs.size() < 40 && + lhs.find('\n') == std::string::npos && + rhs.find('\n') == std::string::npos ? ' ' : '\n'; + dest.reserve( 7 + lhs.size() + rhs.size() ); + // 2 for spaces around operator + // 2 for operator + // 2 for parentheses (conditionally added later) + // 1 for negation (conditionally added later) + dest = lhs; + dest += delim; + dest += Internal::OperatorTraits::getName(); + dest += delim; + dest += rhs; + } + +private: + ResultBuilder& m_rb; + LhsT m_lhs; + RhsT m_rhs; +}; + +template +class MatchExpression : public DecomposedExpression { +public: + MatchExpression( ArgT arg, MatcherT matcher, char const* matcherString ) + : m_arg( arg ), m_matcher( matcher ), m_matcherString( matcherString ) {} + + virtual bool isBinaryExpression() const CATCH_OVERRIDE { + return true; + } + + virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE { + std::string matcherAsString = m_matcher.toString(); + dest = Catch::toString( m_arg ); + dest += ' '; + if( matcherAsString == Detail::unprintableString ) + dest += m_matcherString; + else + dest += matcherAsString; + } + +private: + ArgT m_arg; + MatcherT m_matcher; + char const* m_matcherString; +}; + +} // end namespace Catch + + +namespace Catch { + + template + ExpressionLhs ResultBuilder::operator <= ( T const& operand ) { + return ExpressionLhs( *this, operand ); + } + + inline ExpressionLhs ResultBuilder::operator <= ( bool value ) { + return ExpressionLhs( *this, value ); + } + + template + void ResultBuilder::captureMatch( ArgT const& arg, MatcherT const& matcher, + char const* matcherString ) { + MatchExpression expr( arg, matcher, matcherString ); + setResultType( matcher.match( arg ) ); + endExpression( expr ); + } + +} // namespace Catch + +// #included from: catch_message.h +#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED + +#include + +namespace Catch { + + struct MessageInfo { + MessageInfo( std::string const& _macroName, + SourceLineInfo const& _lineInfo, + ResultWas::OfType _type ); + + std::string macroName; + SourceLineInfo lineInfo; + ResultWas::OfType type; + std::string message; + unsigned int sequence; + + bool operator == ( MessageInfo const& other ) const { + return sequence == other.sequence; + } + bool operator < ( MessageInfo const& other ) const { + return sequence < other.sequence; + } + private: + static unsigned int globalCount; + }; + + struct MessageBuilder { + MessageBuilder( std::string const& macroName, + SourceLineInfo const& lineInfo, + ResultWas::OfType type ) + : m_info( macroName, lineInfo, type ) + {} + + template + MessageBuilder& operator << ( T const& value ) { + m_stream << value; + return *this; + } + + MessageInfo m_info; + std::ostringstream m_stream; + }; + + class ScopedMessage { + public: + ScopedMessage( MessageBuilder const& builder ); + ScopedMessage( ScopedMessage const& other ); + ~ScopedMessage(); + + MessageInfo m_info; + }; + +} // end namespace Catch + +// #included from: catch_interfaces_capture.h +#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED + +#include + +namespace Catch { + + class TestCase; + class AssertionResult; + struct AssertionInfo; + struct SectionInfo; + struct SectionEndInfo; + struct MessageInfo; + class ScopedMessageBuilder; + struct Counts; + + struct IResultCapture { + + virtual ~IResultCapture(); + + virtual void assertionEnded( AssertionResult const& result ) = 0; + virtual bool sectionStarted( SectionInfo const& sectionInfo, + Counts& assertions ) = 0; + virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0; + virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0; + virtual void pushScopedMessage( MessageInfo const& message ) = 0; + virtual void popScopedMessage( MessageInfo const& message ) = 0; + + virtual std::string getCurrentTestName() const = 0; + virtual const AssertionResult* getLastResult() const = 0; + + virtual void exceptionEarlyReported() = 0; + + virtual void handleFatalErrorCondition( std::string const& message ) = 0; + + virtual bool lastAssertionPassed() = 0; + virtual void assertionPassed() = 0; + virtual void assertionRun() = 0; + }; + + IResultCapture& getResultCapture(); +} + +// #included from: catch_debugger.h +#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED + +// #included from: catch_platform.h +#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED + +#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) +# define CATCH_PLATFORM_MAC +#elif defined(__IPHONE_OS_VERSION_MIN_REQUIRED) +# define CATCH_PLATFORM_IPHONE +#elif defined(linux) || defined(__linux) || defined(__linux__) +# define CATCH_PLATFORM_LINUX +#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) +# define CATCH_PLATFORM_WINDOWS +# if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX) +# define CATCH_DEFINES_NOMINMAX +# endif +# if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN) +# define CATCH_DEFINES_WIN32_LEAN_AND_MEAN +# endif +#endif + +#include + +namespace Catch{ + + bool isDebuggerActive(); + void writeToDebugConsole( std::string const& text ); +} + +#ifdef CATCH_PLATFORM_MAC + + // The following code snippet based on: + // http://cocoawithlove.com/2008/03/break-into-debugger.html + #if defined(__ppc64__) || defined(__ppc__) + #define CATCH_TRAP() \ + __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \ + : : : "memory","r0","r3","r4" ) /* NOLINT */ + #else + #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ ) + #endif + +#elif defined(CATCH_PLATFORM_LINUX) + // If we can use inline assembler, do it because this allows us to break + // directly at the location of the failing check instead of breaking inside + // raise() called from it, i.e. one stack frame below. + #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64)) + #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */ + #else // Fall back to the generic way. + #include + + #define CATCH_TRAP() raise(SIGTRAP) + #endif +#elif defined(_MSC_VER) + #define CATCH_TRAP() __debugbreak() +#elif defined(__MINGW32__) + extern "C" __declspec(dllimport) void __stdcall DebugBreak(); + #define CATCH_TRAP() DebugBreak() +#endif + +#ifdef CATCH_TRAP + #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } +#else + #define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue(); +#endif + +// #included from: catch_interfaces_runner.h +#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED + +namespace Catch { + class TestCase; + + struct IRunner { + virtual ~IRunner(); + virtual bool aborting() const = 0; + }; +} + +#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION) +# define CATCH_INTERNAL_STRINGIFY(expr) #expr +#else +# define CATCH_INTERNAL_STRINGIFY(expr) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION" +#endif + +#if defined(CATCH_CONFIG_FAST_COMPILE) +/////////////////////////////////////////////////////////////////////////////// +// We can speedup compilation significantly by breaking into debugger lower in +// the callstack, because then we don't have to expand CATCH_BREAK_INTO_DEBUGGER +// macro in each assertion +#define INTERNAL_CATCH_REACT( resultBuilder ) \ + resultBuilder.react(); + +/////////////////////////////////////////////////////////////////////////////// +// Another way to speed-up compilation is to omit local try-catch for REQUIRE* +// macros. +// This can potentially cause false negative, if the test code catches +// the exception before it propagates back up to the runner. +#define INTERNAL_CATCH_TEST_NO_TRY( macroName, resultDisposition, expr ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \ + __catchResult.setExceptionGuard(); \ + CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ + ( __catchResult <= expr ).endExpression(); \ + CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \ + __catchResult.unsetExceptionGuard(); \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::isTrue( false && static_cast( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look +// The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&. + +#define INTERNAL_CHECK_THAT_NO_TRY( macroName, matcher, resultDisposition, arg ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \ + __catchResult.setExceptionGuard(); \ + __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \ + __catchResult.unsetExceptionGuard(); \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) + +#else +/////////////////////////////////////////////////////////////////////////////// +// In the event of a failure works out if the debugger needs to be invoked +// and/or an exception thrown and takes appropriate action. +// This needs to be done as a macro so the debugger will stop in the user +// source code rather than in Catch library code +#define INTERNAL_CATCH_REACT( resultBuilder ) \ + if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \ + resultBuilder.react(); +#endif + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \ + try { \ + CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \ + ( __catchResult <= expr ).endExpression(); \ + CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \ + } \ + catch( ... ) { \ + __catchResult.useActiveException( resultDisposition ); \ + } \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::isTrue( false && static_cast( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look + // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&. + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_IF( macroName, resultDisposition, expr ) \ + INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \ + if( Catch::getResultCapture().lastAssertionPassed() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, expr ) \ + INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \ + if( !Catch::getResultCapture().lastAssertionPassed() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, expr ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \ + try { \ + static_cast(expr); \ + __catchResult.captureResult( Catch::ResultWas::Ok ); \ + } \ + catch( ... ) { \ + __catchResult.useActiveException( resultDisposition ); \ + } \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, matcher, expr ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition, CATCH_INTERNAL_STRINGIFY(matcher) ); \ + if( __catchResult.allowThrows() ) \ + try { \ + static_cast(expr); \ + __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \ + } \ + catch( ... ) { \ + __catchResult.captureExpectedException( matcher ); \ + } \ + else \ + __catchResult.captureResult( Catch::ResultWas::Ok ); \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \ + if( __catchResult.allowThrows() ) \ + try { \ + static_cast(expr); \ + __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \ + } \ + catch( exceptionType ) { \ + __catchResult.captureResult( Catch::ResultWas::Ok ); \ + } \ + catch( ... ) { \ + __catchResult.useActiveException( resultDisposition ); \ + } \ + else \ + __catchResult.captureResult( Catch::ResultWas::Ok ); \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) + +/////////////////////////////////////////////////////////////////////////////// +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \ + __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \ + __catchResult.captureResult( messageType ); \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) +#else + #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, log ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \ + __catchResult << log + ::Catch::StreamEndStop(); \ + __catchResult.captureResult( messageType ); \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) +#endif + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_INFO( macroName, log ) \ + Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log; + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \ + do { \ + Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \ + try { \ + __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \ + } catch( ... ) { \ + __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \ + } \ + INTERNAL_CATCH_REACT( __catchResult ) \ + } while( Catch::alwaysFalse() ) + +// #included from: internal/catch_section.h +#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED + +// #included from: catch_section_info.h +#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED + +// #included from: catch_totals.hpp +#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED + +#include + +namespace Catch { + + struct Counts { + Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {} + + Counts operator - ( Counts const& other ) const { + Counts diff; + diff.passed = passed - other.passed; + diff.failed = failed - other.failed; + diff.failedButOk = failedButOk - other.failedButOk; + return diff; + } + Counts& operator += ( Counts const& other ) { + passed += other.passed; + failed += other.failed; + failedButOk += other.failedButOk; + return *this; + } + + std::size_t total() const { + return passed + failed + failedButOk; + } + bool allPassed() const { + return failed == 0 && failedButOk == 0; + } + bool allOk() const { + return failed == 0; + } + + std::size_t passed; + std::size_t failed; + std::size_t failedButOk; + }; + + struct Totals { + + Totals operator - ( Totals const& other ) const { + Totals diff; + diff.assertions = assertions - other.assertions; + diff.testCases = testCases - other.testCases; + return diff; + } + + Totals delta( Totals const& prevTotals ) const { + Totals diff = *this - prevTotals; + if( diff.assertions.failed > 0 ) + ++diff.testCases.failed; + else if( diff.assertions.failedButOk > 0 ) + ++diff.testCases.failedButOk; + else + ++diff.testCases.passed; + return diff; + } + + Totals& operator += ( Totals const& other ) { + assertions += other.assertions; + testCases += other.testCases; + return *this; + } + + Counts assertions; + Counts testCases; + }; +} + +#include + +namespace Catch { + + struct SectionInfo { + SectionInfo + ( SourceLineInfo const& _lineInfo, + std::string const& _name, + std::string const& _description = std::string() ); + + std::string name; + std::string description; + SourceLineInfo lineInfo; + }; + + struct SectionEndInfo { + SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds ) + : sectionInfo( _sectionInfo ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds ) + {} + + SectionInfo sectionInfo; + Counts prevAssertions; + double durationInSeconds; + }; + +} // end namespace Catch + +// #included from: catch_timer.h +#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED + +#ifdef _MSC_VER + +namespace Catch { + typedef unsigned long long UInt64; +} +#else +#include +namespace Catch { + typedef uint64_t UInt64; +} +#endif + +namespace Catch { + class Timer { + public: + Timer() : m_ticks( 0 ) {} + void start(); + unsigned int getElapsedMicroseconds() const; + unsigned int getElapsedMilliseconds() const; + double getElapsedSeconds() const; + + private: + UInt64 m_ticks; + }; + +} // namespace Catch + +#include + +namespace Catch { + + class Section : NonCopyable { + public: + Section( SectionInfo const& info ); + ~Section(); + + // This indicates whether the section should be executed or not + operator bool() const; + + private: + SectionInfo m_info; + + std::string m_name; + Counts m_assertions; + bool m_sectionIncluded; + Timer m_timer; + }; + +} // end namespace Catch + +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define INTERNAL_CATCH_SECTION( ... ) \ + if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) +#else + #define INTERNAL_CATCH_SECTION( name, desc ) \ + if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) ) +#endif + +// #included from: internal/catch_generators.hpp +#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED + +#include +#include +#include + +namespace Catch { + +template +struct IGenerator { + virtual ~IGenerator() {} + virtual T getValue( std::size_t index ) const = 0; + virtual std::size_t size () const = 0; +}; + +template +class BetweenGenerator : public IGenerator { +public: + BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){} + + virtual T getValue( std::size_t index ) const { + return m_from+static_cast( index ); + } + + virtual std::size_t size() const { + return static_cast( 1+m_to-m_from ); + } + +private: + + T m_from; + T m_to; +}; + +template +class ValuesGenerator : public IGenerator { +public: + ValuesGenerator(){} + + void add( T value ) { + m_values.push_back( value ); + } + + virtual T getValue( std::size_t index ) const { + return m_values[index]; + } + + virtual std::size_t size() const { + return m_values.size(); + } + +private: + std::vector m_values; +}; + +template +class CompositeGenerator { +public: + CompositeGenerator() : m_totalSize( 0 ) {} + + // *** Move semantics, similar to auto_ptr *** + CompositeGenerator( CompositeGenerator& other ) + : m_fileInfo( other.m_fileInfo ), + m_totalSize( 0 ) + { + move( other ); + } + + CompositeGenerator& setFileInfo( const char* fileInfo ) { + m_fileInfo = fileInfo; + return *this; + } + + ~CompositeGenerator() { + deleteAll( m_composed ); + } + + operator T () const { + size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize ); + + typename std::vector*>::const_iterator it = m_composed.begin(); + typename std::vector*>::const_iterator itEnd = m_composed.end(); + for( size_t index = 0; it != itEnd; ++it ) + { + const IGenerator* generator = *it; + if( overallIndex >= index && overallIndex < index + generator->size() ) + { + return generator->getValue( overallIndex-index ); + } + index += generator->size(); + } + CATCH_INTERNAL_ERROR( "Indexed past end of generated range" ); + return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so + } + + void add( const IGenerator* generator ) { + m_totalSize += generator->size(); + m_composed.push_back( generator ); + } + + CompositeGenerator& then( CompositeGenerator& other ) { + move( other ); + return *this; + } + + CompositeGenerator& then( T value ) { + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( value ); + add( valuesGen ); + return *this; + } + +private: + + void move( CompositeGenerator& other ) { + m_composed.insert( m_composed.end(), other.m_composed.begin(), other.m_composed.end() ); + m_totalSize += other.m_totalSize; + other.m_composed.clear(); + } + + std::vector*> m_composed; + std::string m_fileInfo; + size_t m_totalSize; +}; + +namespace Generators +{ + template + CompositeGenerator between( T from, T to ) { + CompositeGenerator generators; + generators.add( new BetweenGenerator( from, to ) ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2 ) { + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + generators.add( valuesGen ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2, T val3 ){ + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + valuesGen->add( val3 ); + generators.add( valuesGen ); + return generators; + } + + template + CompositeGenerator values( T val1, T val2, T val3, T val4 ) { + CompositeGenerator generators; + ValuesGenerator* valuesGen = new ValuesGenerator(); + valuesGen->add( val1 ); + valuesGen->add( val2 ); + valuesGen->add( val3 ); + valuesGen->add( val4 ); + generators.add( valuesGen ); + return generators; + } + +} // end namespace Generators + +using namespace Generators; + +} // end namespace Catch + +#define INTERNAL_CATCH_LINESTR2( line ) #line +#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line ) + +#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" ) + +// #included from: internal/catch_interfaces_exception.h +#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED + +#include +#include + +// #included from: catch_interfaces_registry_hub.h +#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED + +#include + +namespace Catch { + + class TestCase; + struct ITestCaseRegistry; + struct IExceptionTranslatorRegistry; + struct IExceptionTranslator; + struct IReporterRegistry; + struct IReporterFactory; + struct ITagAliasRegistry; + + struct IRegistryHub { + virtual ~IRegistryHub(); + + virtual IReporterRegistry const& getReporterRegistry() const = 0; + virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0; + virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0; + + virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0; + }; + + struct IMutableRegistryHub { + virtual ~IMutableRegistryHub(); + virtual void registerReporter( std::string const& name, Ptr const& factory ) = 0; + virtual void registerListener( Ptr const& factory ) = 0; + virtual void registerTest( TestCase const& testInfo ) = 0; + virtual void registerTranslator( const IExceptionTranslator* translator ) = 0; + virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0; + }; + + IRegistryHub& getRegistryHub(); + IMutableRegistryHub& getMutableRegistryHub(); + void cleanUp(); + std::string translateActiveException(); + +} + +namespace Catch { + + typedef std::string(*exceptionTranslateFunction)(); + + struct IExceptionTranslator; + typedef std::vector ExceptionTranslators; + + struct IExceptionTranslator { + virtual ~IExceptionTranslator(); + virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0; + }; + + struct IExceptionTranslatorRegistry { + virtual ~IExceptionTranslatorRegistry(); + + virtual std::string translateActiveException() const = 0; + }; + + class ExceptionTranslatorRegistrar { + template + class ExceptionTranslator : public IExceptionTranslator { + public: + + ExceptionTranslator( std::string(*translateFunction)( T& ) ) + : m_translateFunction( translateFunction ) + {} + + virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const CATCH_OVERRIDE { + try { + if( it == itEnd ) + throw; + else + return (*it)->translate( it+1, itEnd ); + } + catch( T& ex ) { + return m_translateFunction( ex ); + } + } + + protected: + std::string(*m_translateFunction)( T& ); + }; + + public: + template + ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) { + getMutableRegistryHub().registerTranslator + ( new ExceptionTranslator( translateFunction ) ); + } + }; +} + +/////////////////////////////////////////////////////////////////////////////// +#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \ + static std::string translatorName( signature ); \ + namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); }\ + static std::string translatorName( signature ) + +#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature ) + +// #included from: internal/catch_approx.hpp +#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED + +#include +#include + +#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) +#include +#endif + +namespace Catch { +namespace Detail { + + class Approx { + public: + explicit Approx ( double value ) + : m_epsilon( std::numeric_limits::epsilon()*100 ), + m_margin( 0.0 ), + m_scale( 1.0 ), + m_value( value ) + {} + + static Approx custom() { + return Approx( 0 ); + } + +#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) + + template ::value>::type> + Approx operator()( T value ) { + Approx approx( static_cast(value) ); + approx.epsilon( m_epsilon ); + approx.margin( m_margin ); + approx.scale( m_scale ); + return approx; + } + + template ::value>::type> + explicit Approx( T value ): Approx(static_cast(value)) + {} + + template ::value>::type> + friend bool operator == ( const T& lhs, Approx const& rhs ) { + // Thanks to Richard Harris for his help refining this formula + auto lhs_v = double(lhs); + bool relativeOK = std::fabs(lhs_v - rhs.m_value) < rhs.m_epsilon * (rhs.m_scale + (std::max)(std::fabs(lhs_v), std::fabs(rhs.m_value))); + if (relativeOK) { + return true; + } + + return std::fabs(lhs_v - rhs.m_value) <= rhs.m_margin; + } + + template ::value>::type> + friend bool operator == ( Approx const& lhs, const T& rhs ) { + return operator==( rhs, lhs ); + } + + template ::value>::type> + friend bool operator != ( T lhs, Approx const& rhs ) { + return !operator==( lhs, rhs ); + } + + template ::value>::type> + friend bool operator != ( Approx const& lhs, T rhs ) { + return !operator==( rhs, lhs ); + } + + template ::value>::type> + friend bool operator <= ( T lhs, Approx const& rhs ) { + return double(lhs) < rhs.m_value || lhs == rhs; + } + + template ::value>::type> + friend bool operator <= ( Approx const& lhs, T rhs ) { + return lhs.m_value < double(rhs) || lhs == rhs; + } + + template ::value>::type> + friend bool operator >= ( T lhs, Approx const& rhs ) { + return double(lhs) > rhs.m_value || lhs == rhs; + } + + template ::value>::type> + friend bool operator >= ( Approx const& lhs, T rhs ) { + return lhs.m_value > double(rhs) || lhs == rhs; + } + + template ::value>::type> + Approx& epsilon( T newEpsilon ) { + m_epsilon = double(newEpsilon); + return *this; + } + + template ::value>::type> + Approx& margin( T newMargin ) { + m_margin = double(newMargin); + return *this; + } + + template ::value>::type> + Approx& scale( T newScale ) { + m_scale = double(newScale); + return *this; + } + +#else + + Approx operator()( double value ) { + Approx approx( value ); + approx.epsilon( m_epsilon ); + approx.margin( m_margin ); + approx.scale( m_scale ); + return approx; + } + + friend bool operator == ( double lhs, Approx const& rhs ) { + // Thanks to Richard Harris for his help refining this formula + bool relativeOK = std::fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( std::fabs(lhs), std::fabs(rhs.m_value) ) ); + if (relativeOK) { + return true; + } + return std::fabs(lhs - rhs.m_value) <= rhs.m_margin; + } + + friend bool operator == ( Approx const& lhs, double rhs ) { + return operator==( rhs, lhs ); + } + + friend bool operator != ( double lhs, Approx const& rhs ) { + return !operator==( lhs, rhs ); + } + + friend bool operator != ( Approx const& lhs, double rhs ) { + return !operator==( rhs, lhs ); + } + + friend bool operator <= ( double lhs, Approx const& rhs ) { + return lhs < rhs.m_value || lhs == rhs; + } + + friend bool operator <= ( Approx const& lhs, double rhs ) { + return lhs.m_value < rhs || lhs == rhs; + } + + friend bool operator >= ( double lhs, Approx const& rhs ) { + return lhs > rhs.m_value || lhs == rhs; + } + + friend bool operator >= ( Approx const& lhs, double rhs ) { + return lhs.m_value > rhs || lhs == rhs; + } + + Approx& epsilon( double newEpsilon ) { + m_epsilon = newEpsilon; + return *this; + } + + Approx& margin( double newMargin ) { + m_margin = newMargin; + return *this; + } + + Approx& scale( double newScale ) { + m_scale = newScale; + return *this; + } +#endif + + std::string toString() const { + std::ostringstream oss; + oss << "Approx( " << Catch::toString( m_value ) << " )"; + return oss.str(); + } + + private: + double m_epsilon; + double m_margin; + double m_scale; + double m_value; + }; +} + +template<> +inline std::string toString( Detail::Approx const& value ) { + return value.toString(); +} + +} // end namespace Catch + +// #included from: internal/catch_matchers_string.h +#define TWOBLUECUBES_CATCH_MATCHERS_STRING_H_INCLUDED + +namespace Catch { +namespace Matchers { + + namespace StdString { + + struct CasedString + { + CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity ); + std::string adjustString( std::string const& str ) const; + std::string caseSensitivitySuffix() const; + + CaseSensitive::Choice m_caseSensitivity; + std::string m_str; + }; + + struct StringMatcherBase : MatcherBase { + StringMatcherBase( std::string const& operation, CasedString const& comparator ); + virtual std::string describe() const CATCH_OVERRIDE; + + CasedString m_comparator; + std::string m_operation; + }; + + struct EqualsMatcher : StringMatcherBase { + EqualsMatcher( CasedString const& comparator ); + virtual bool match( std::string const& source ) const CATCH_OVERRIDE; + }; + struct ContainsMatcher : StringMatcherBase { + ContainsMatcher( CasedString const& comparator ); + virtual bool match( std::string const& source ) const CATCH_OVERRIDE; + }; + struct StartsWithMatcher : StringMatcherBase { + StartsWithMatcher( CasedString const& comparator ); + virtual bool match( std::string const& source ) const CATCH_OVERRIDE; + }; + struct EndsWithMatcher : StringMatcherBase { + EndsWithMatcher( CasedString const& comparator ); + virtual bool match( std::string const& source ) const CATCH_OVERRIDE; + }; + + } // namespace StdString + + // The following functions create the actual matcher objects. + // This allows the types to be inferred + + StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ); + StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ); + StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ); + StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes ); + +} // namespace Matchers +} // namespace Catch + +// #included from: internal/catch_matchers_vector.h +#define TWOBLUECUBES_CATCH_MATCHERS_VECTOR_H_INCLUDED + +namespace Catch { +namespace Matchers { + + namespace Vector { + + template + struct ContainsElementMatcher : MatcherBase, T> { + + ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {} + + bool match(std::vector const &v) const CATCH_OVERRIDE { + return std::find(v.begin(), v.end(), m_comparator) != v.end(); + } + + virtual std::string describe() const CATCH_OVERRIDE { + return "Contains: " + Catch::toString( m_comparator ); + } + + T const& m_comparator; + }; + + template + struct ContainsMatcher : MatcherBase, std::vector > { + + ContainsMatcher(std::vector const &comparator) : m_comparator( comparator ) {} + + bool match(std::vector const &v) const CATCH_OVERRIDE { + // !TBD: see note in EqualsMatcher + if (m_comparator.size() > v.size()) + return false; + for (size_t i = 0; i < m_comparator.size(); ++i) + if (std::find(v.begin(), v.end(), m_comparator[i]) == v.end()) + return false; + return true; + } + virtual std::string describe() const CATCH_OVERRIDE { + return "Contains: " + Catch::toString( m_comparator ); + } + + std::vector const& m_comparator; + }; + + template + struct EqualsMatcher : MatcherBase, std::vector > { + + EqualsMatcher(std::vector const &comparator) : m_comparator( comparator ) {} + + bool match(std::vector const &v) const CATCH_OVERRIDE { + // !TBD: This currently works if all elements can be compared using != + // - a more general approach would be via a compare template that defaults + // to using !=. but could be specialised for, e.g. std::vector etc + // - then just call that directly + if (m_comparator.size() != v.size()) + return false; + for (size_t i = 0; i < v.size(); ++i) + if (m_comparator[i] != v[i]) + return false; + return true; + } + virtual std::string describe() const CATCH_OVERRIDE { + return "Equals: " + Catch::toString( m_comparator ); + } + std::vector const& m_comparator; + }; + + } // namespace Vector + + // The following functions create the actual matcher objects. + // This allows the types to be inferred + + template + Vector::ContainsMatcher Contains( std::vector const& comparator ) { + return Vector::ContainsMatcher( comparator ); + } + + template + Vector::ContainsElementMatcher VectorContains( T const& comparator ) { + return Vector::ContainsElementMatcher( comparator ); + } + + template + Vector::EqualsMatcher Equals( std::vector const& comparator ) { + return Vector::EqualsMatcher( comparator ); + } + +} // namespace Matchers +} // namespace Catch + +// #included from: internal/catch_interfaces_tag_alias_registry.h +#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED + +// #included from: catch_tag_alias.h +#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED + +#include + +namespace Catch { + + struct TagAlias { + TagAlias( std::string const& _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {} + + std::string tag; + SourceLineInfo lineInfo; + }; + + struct RegistrarForTagAliases { + RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ); + }; + +} // end namespace Catch + +#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } +// #included from: catch_option.hpp +#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED + +namespace Catch { + + // An optional type + template + class Option { + public: + Option() : nullableValue( CATCH_NULL ) {} + Option( T const& _value ) + : nullableValue( new( storage ) T( _value ) ) + {} + Option( Option const& _other ) + : nullableValue( _other ? new( storage ) T( *_other ) : CATCH_NULL ) + {} + + ~Option() { + reset(); + } + + Option& operator= ( Option const& _other ) { + if( &_other != this ) { + reset(); + if( _other ) + nullableValue = new( storage ) T( *_other ); + } + return *this; + } + Option& operator = ( T const& _value ) { + reset(); + nullableValue = new( storage ) T( _value ); + return *this; + } + + void reset() { + if( nullableValue ) + nullableValue->~T(); + nullableValue = CATCH_NULL; + } + + T& operator*() { return *nullableValue; } + T const& operator*() const { return *nullableValue; } + T* operator->() { return nullableValue; } + const T* operator->() const { return nullableValue; } + + T valueOr( T const& defaultValue ) const { + return nullableValue ? *nullableValue : defaultValue; + } + + bool some() const { return nullableValue != CATCH_NULL; } + bool none() const { return nullableValue == CATCH_NULL; } + + bool operator !() const { return nullableValue == CATCH_NULL; } + operator SafeBool::type() const { + return SafeBool::makeSafe( some() ); + } + + private: + T *nullableValue; + union { + char storage[sizeof(T)]; + + // These are here to force alignment for the storage + long double dummy1; + void (*dummy2)(); + long double dummy3; +#ifdef CATCH_CONFIG_CPP11_LONG_LONG + long long dummy4; +#endif + }; + }; + +} // end namespace Catch + +namespace Catch { + + struct ITagAliasRegistry { + virtual ~ITagAliasRegistry(); + virtual Option find( std::string const& alias ) const = 0; + virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0; + + static ITagAliasRegistry const& get(); + }; + +} // end namespace Catch + +// These files are included here so the single_include script doesn't put them +// in the conditionally compiled sections +// #included from: internal/catch_test_case_info.h +#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED + +#include +#include + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +namespace Catch { + + struct ITestCase; + + struct TestCaseInfo { + enum SpecialProperties{ + None = 0, + IsHidden = 1 << 1, + ShouldFail = 1 << 2, + MayFail = 1 << 3, + Throws = 1 << 4, + NonPortable = 1 << 5 + }; + + TestCaseInfo( std::string const& _name, + std::string const& _className, + std::string const& _description, + std::set const& _tags, + SourceLineInfo const& _lineInfo ); + + TestCaseInfo( TestCaseInfo const& other ); + + friend void setTags( TestCaseInfo& testCaseInfo, std::set const& tags ); + + bool isHidden() const; + bool throws() const; + bool okToFail() const; + bool expectedToFail() const; + + std::string name; + std::string className; + std::string description; + std::set tags; + std::set lcaseTags; + std::string tagsAsString; + SourceLineInfo lineInfo; + SpecialProperties properties; + }; + + class TestCase : public TestCaseInfo { + public: + + TestCase( ITestCase* testCase, TestCaseInfo const& info ); + TestCase( TestCase const& other ); + + TestCase withName( std::string const& _newName ) const; + + void invoke() const; + + TestCaseInfo const& getTestCaseInfo() const; + + void swap( TestCase& other ); + bool operator == ( TestCase const& other ) const; + bool operator < ( TestCase const& other ) const; + TestCase& operator = ( TestCase const& other ); + + private: + Ptr test; + }; + + TestCase makeTestCase( ITestCase* testCase, + std::string const& className, + std::string const& name, + std::string const& description, + SourceLineInfo const& lineInfo ); +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + + +#ifdef __OBJC__ +// #included from: internal/catch_objc.hpp +#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED + +#import + +#include + +// NB. Any general catch headers included here must be included +// in catch.hpp first to make sure they are included by the single +// header for non obj-usage + +/////////////////////////////////////////////////////////////////////////////// +// This protocol is really only here for (self) documenting purposes, since +// all its methods are optional. +@protocol OcFixture + +@optional + +-(void) setUp; +-(void) tearDown; + +@end + +namespace Catch { + + class OcMethod : public SharedImpl { + + public: + OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {} + + virtual void invoke() const { + id obj = [[m_cls alloc] init]; + + performOptionalSelector( obj, @selector(setUp) ); + performOptionalSelector( obj, m_sel ); + performOptionalSelector( obj, @selector(tearDown) ); + + arcSafeRelease( obj ); + } + private: + virtual ~OcMethod() {} + + Class m_cls; + SEL m_sel; + }; + + namespace Detail{ + + inline std::string getAnnotation( Class cls, + std::string const& annotationName, + std::string const& testCaseName ) { + NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()]; + SEL sel = NSSelectorFromString( selStr ); + arcSafeRelease( selStr ); + id value = performOptionalSelector( cls, sel ); + if( value ) + return [(NSString*)value UTF8String]; + return ""; + } + } + + inline size_t registerTestMethods() { + size_t noTestMethods = 0; + int noClasses = objc_getClassList( CATCH_NULL, 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, name.c_str(), desc.c_str(), SourceLineInfo() ) ); + noTestMethods++; + } + } + free(methods); + } + } + return noTestMethods; + } + + namespace Matchers { + namespace Impl { + namespace NSStringMatchers { + + struct StringHolder : MatcherBase{ + StringHolder( NSString* substr ) : m_substr( [substr copy] ){} + StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){} + StringHolder() { + arcSafeRelease( m_substr ); + } + + virtual bool match( NSString* arg ) const CATCH_OVERRIDE { + return false; + } + + NSString* m_substr; + }; + + struct Equals : StringHolder { + Equals( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( NSString* str ) const CATCH_OVERRIDE { + return (str != nil || m_substr == nil ) && + [str isEqualToString:m_substr]; + } + + virtual std::string describe() const CATCH_OVERRIDE { + return "equals string: " + Catch::toString( m_substr ); + } + }; + + struct Contains : StringHolder { + Contains( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( NSString* str ) const { + return (str != nil || m_substr == nil ) && + [str rangeOfString:m_substr].location != NSNotFound; + } + + virtual std::string describe() const CATCH_OVERRIDE { + return "contains string: " + Catch::toString( m_substr ); + } + }; + + struct StartsWith : StringHolder { + StartsWith( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( NSString* str ) const { + return (str != nil || m_substr == nil ) && + [str rangeOfString:m_substr].location == 0; + } + + virtual std::string describe() const CATCH_OVERRIDE { + return "starts with: " + Catch::toString( m_substr ); + } + }; + struct EndsWith : StringHolder { + EndsWith( NSString* substr ) : StringHolder( substr ){} + + virtual bool match( NSString* str ) const { + return (str != nil || m_substr == nil ) && + [str rangeOfString:m_substr].location == [str length] - [m_substr length]; + } + + virtual std::string describe() const CATCH_OVERRIDE { + return "ends with: " + Catch::toString( m_substr ); + } + }; + + } // namespace NSStringMatchers + } // namespace Impl + + inline Impl::NSStringMatchers::Equals + Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); } + + inline Impl::NSStringMatchers::Contains + Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); } + + inline Impl::NSStringMatchers::StartsWith + StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); } + + inline Impl::NSStringMatchers::EndsWith + EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); } + + } // namespace Matchers + + using namespace Matchers; + +} // namespace Catch + +/////////////////////////////////////////////////////////////////////////////// +#define OC_TEST_CASE( name, desc )\ ++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \ +{\ +return @ name; \ +}\ ++(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \ +{ \ +return @ desc; \ +} \ +-(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test ) + +#endif + +#ifdef CATCH_IMPL + +// !TBD: Move the leak detector code into a separate header +#ifdef CATCH_CONFIG_WINDOWS_CRTDBG +#include +class LeakDetector { +public: + LeakDetector() { + int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); + flag |= _CRTDBG_LEAK_CHECK_DF; + flag |= _CRTDBG_ALLOC_MEM_DF; + _CrtSetDbgFlag(flag); + _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG); + _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR); + // Change this to leaking allocation's number to break there + _CrtSetBreakAlloc(-1); + } +}; +#else +class LeakDetector {}; +#endif + +LeakDetector leakDetector; + +// #included from: internal/catch_impl.hpp +#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED + +// Collect all the implementation files together here +// These are the equivalent of what would usually be cpp files + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wweak-vtables" +#endif + +// #included from: ../catch_session.hpp +#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED + +// #included from: internal/catch_commandline.hpp +#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED + +// #included from: catch_config.hpp +#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED + +// #included from: catch_test_spec_parser.hpp +#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +// #included from: catch_test_spec.hpp +#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wpadded" +#endif + +// #included from: catch_wildcard_pattern.hpp +#define TWOBLUECUBES_CATCH_WILDCARD_PATTERN_HPP_INCLUDED + +#include + +namespace Catch +{ + class WildcardPattern { + enum WildcardPosition { + NoWildcard = 0, + WildcardAtStart = 1, + WildcardAtEnd = 2, + WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd + }; + + public: + + WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity ) + : m_caseSensitivity( caseSensitivity ), + m_wildcard( NoWildcard ), + m_pattern( adjustCase( pattern ) ) + { + if( startsWith( m_pattern, '*' ) ) { + m_pattern = m_pattern.substr( 1 ); + m_wildcard = WildcardAtStart; + } + if( endsWith( m_pattern, '*' ) ) { + m_pattern = m_pattern.substr( 0, m_pattern.size()-1 ); + m_wildcard = static_cast( m_wildcard | WildcardAtEnd ); + } + } + virtual ~WildcardPattern(); + virtual bool matches( std::string const& str ) const { + switch( m_wildcard ) { + case NoWildcard: + return m_pattern == adjustCase( str ); + case WildcardAtStart: + return endsWith( adjustCase( str ), m_pattern ); + case WildcardAtEnd: + return startsWith( adjustCase( str ), m_pattern ); + case WildcardAtBothEnds: + return contains( adjustCase( str ), m_pattern ); + } + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wunreachable-code" +#endif + throw std::logic_error( "Unknown enum" ); +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + } + private: + std::string adjustCase( std::string const& str ) const { + return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str; + } + CaseSensitive::Choice m_caseSensitivity; + WildcardPosition m_wildcard; + std::string m_pattern; + }; +} + +#include +#include + +namespace Catch { + + class TestSpec { + struct Pattern : SharedImpl<> { + virtual ~Pattern(); + virtual bool matches( TestCaseInfo const& testCase ) const = 0; + }; + class NamePattern : public Pattern { + public: + NamePattern( std::string const& name ) + : m_wildcardPattern( toLower( name ), CaseSensitive::No ) + {} + virtual ~NamePattern(); + virtual bool matches( TestCaseInfo const& testCase ) const { + return m_wildcardPattern.matches( toLower( testCase.name ) ); + } + private: + WildcardPattern m_wildcardPattern; + }; + + class TagPattern : public Pattern { + public: + TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {} + virtual ~TagPattern(); + virtual bool matches( TestCaseInfo const& testCase ) const { + return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end(); + } + private: + std::string m_tag; + }; + + class ExcludedPattern : public Pattern { + public: + ExcludedPattern( Ptr const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {} + virtual ~ExcludedPattern(); + virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); } + private: + Ptr m_underlyingPattern; + }; + + struct Filter { + std::vector > m_patterns; + + bool matches( TestCaseInfo const& testCase ) const { + // All patterns in a filter must match for the filter to be a match + for( std::vector >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) { + if( !(*it)->matches( testCase ) ) + return false; + } + return true; + } + }; + + public: + bool hasFilters() const { + return !m_filters.empty(); + } + bool matches( TestCaseInfo const& testCase ) const { + // A TestSpec matches if any filter matches + for( std::vector::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it ) + if( it->matches( testCase ) ) + return true; + return false; + } + + private: + std::vector m_filters; + + friend class TestSpecParser; + }; +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +namespace Catch { + + class TestSpecParser { + enum Mode{ None, Name, QuotedName, Tag, EscapedName }; + Mode m_mode; + bool m_exclusion; + std::size_t m_start, m_pos; + std::string m_arg; + std::vector m_escapeChars; + TestSpec::Filter m_currentFilter; + TestSpec m_testSpec; + ITagAliasRegistry const* m_tagAliases; + + public: + TestSpecParser( ITagAliasRegistry const& tagAliases ) :m_mode(None), m_exclusion(false), m_start(0), m_pos(0), m_tagAliases( &tagAliases ) {} + + TestSpecParser& parse( std::string const& arg ) { + m_mode = None; + m_exclusion = false; + m_start = std::string::npos; + m_arg = m_tagAliases->expandAliases( arg ); + m_escapeChars.clear(); + for( m_pos = 0; m_pos < m_arg.size(); ++m_pos ) + visitChar( m_arg[m_pos] ); + if( m_mode == Name ) + addPattern(); + return *this; + } + TestSpec testSpec() { + addFilter(); + return m_testSpec; + } + private: + void visitChar( char c ) { + if( m_mode == None ) { + switch( c ) { + case ' ': return; + case '~': m_exclusion = true; return; + case '[': return startNewMode( Tag, ++m_pos ); + case '"': return startNewMode( QuotedName, ++m_pos ); + case '\\': return escape(); + default: startNewMode( Name, m_pos ); break; + } + } + if( m_mode == Name ) { + if( c == ',' ) { + addPattern(); + addFilter(); + } + else if( c == '[' ) { + if( subString() == "exclude:" ) + m_exclusion = true; + else + addPattern(); + startNewMode( Tag, ++m_pos ); + } + else if( c == '\\' ) + escape(); + } + else if( m_mode == EscapedName ) + m_mode = Name; + else if( m_mode == QuotedName && c == '"' ) + addPattern(); + else if( m_mode == Tag && c == ']' ) + addPattern(); + } + void startNewMode( Mode mode, std::size_t start ) { + m_mode = mode; + m_start = start; + } + void escape() { + if( m_mode == None ) + m_start = m_pos; + m_mode = EscapedName; + m_escapeChars.push_back( m_pos ); + } + std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); } + template + void addPattern() { + std::string token = subString(); + for( size_t i = 0; i < m_escapeChars.size(); ++i ) + token = token.substr( 0, m_escapeChars[i]-m_start-i ) + token.substr( m_escapeChars[i]-m_start-i+1 ); + m_escapeChars.clear(); + if( startsWith( token, "exclude:" ) ) { + m_exclusion = true; + token = token.substr( 8 ); + } + if( !token.empty() ) { + Ptr pattern = new T( token ); + if( m_exclusion ) + pattern = new TestSpec::ExcludedPattern( pattern ); + m_currentFilter.m_patterns.push_back( pattern ); + } + m_exclusion = false; + m_mode = None; + } + void addFilter() { + if( !m_currentFilter.m_patterns.empty() ) { + m_testSpec.m_filters.push_back( m_currentFilter ); + m_currentFilter = TestSpec::Filter(); + } + } + }; + inline TestSpec parseTestSpec( std::string const& arg ) { + return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec(); + } + +} // namespace Catch + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +// #included from: catch_interfaces_config.h +#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED + +#include +#include +#include + +namespace Catch { + + struct Verbosity { enum Level { + NoOutput = 0, + Quiet, + Normal + }; }; + + struct WarnAbout { enum What { + Nothing = 0x00, + NoAssertions = 0x01 + }; }; + + struct ShowDurations { enum OrNot { + DefaultForReporter, + Always, + Never + }; }; + struct RunTests { enum InWhatOrder { + InDeclarationOrder, + InLexicographicalOrder, + InRandomOrder + }; }; + struct UseColour { enum YesOrNo { + Auto, + Yes, + No + }; }; + struct WaitForKeypress { enum When { + Never, + BeforeStart = 1, + BeforeExit = 2, + BeforeStartAndExit = BeforeStart | BeforeExit + }; }; + + class TestSpec; + + struct IConfig : IShared { + + virtual ~IConfig(); + + virtual bool allowThrows() const = 0; + virtual std::ostream& stream() const = 0; + virtual std::string name() const = 0; + virtual bool includeSuccessfulResults() const = 0; + virtual bool shouldDebugBreak() const = 0; + virtual bool warnAboutMissingAssertions() const = 0; + virtual int abortAfter() const = 0; + virtual bool showInvisibles() const = 0; + virtual ShowDurations::OrNot showDurations() const = 0; + virtual TestSpec const& testSpec() const = 0; + virtual RunTests::InWhatOrder runOrder() const = 0; + virtual unsigned int rngSeed() const = 0; + virtual UseColour::YesOrNo useColour() const = 0; + virtual std::vector const& getSectionsToRun() const = 0; + + }; +} + +// #included from: catch_stream.h +#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED + +// #included from: catch_streambuf.h +#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED + +#include + +namespace Catch { + + class StreamBufBase : public std::streambuf { + public: + virtual ~StreamBufBase() CATCH_NOEXCEPT; + }; +} + +#include +#include +#include +#include + +namespace Catch { + + std::ostream& cout(); + std::ostream& cerr(); + std::ostream& clog(); + + struct IStream { + virtual ~IStream() CATCH_NOEXCEPT; + virtual std::ostream& stream() const = 0; + }; + + class FileStream : public IStream { + mutable std::ofstream m_ofs; + public: + FileStream( std::string const& filename ); + virtual ~FileStream() CATCH_NOEXCEPT; + public: // IStream + virtual std::ostream& stream() const CATCH_OVERRIDE; + }; + + class CoutStream : public IStream { + mutable std::ostream m_os; + public: + CoutStream(); + virtual ~CoutStream() CATCH_NOEXCEPT; + + public: // IStream + virtual std::ostream& stream() const CATCH_OVERRIDE; + }; + + class DebugOutStream : public IStream { + CATCH_AUTO_PTR( StreamBufBase ) m_streamBuf; + mutable std::ostream m_os; + public: + DebugOutStream(); + virtual ~DebugOutStream() CATCH_NOEXCEPT; + + public: // IStream + virtual std::ostream& stream() const CATCH_OVERRIDE; + }; +} + +#include +#include +#include +#include + +#ifndef CATCH_CONFIG_CONSOLE_WIDTH +#define CATCH_CONFIG_CONSOLE_WIDTH 80 +#endif + +namespace Catch { + + struct ConfigData { + + ConfigData() + : listTests( false ), + listTags( false ), + listReporters( false ), + listTestNamesOnly( false ), + listExtraInfo( false ), + showSuccessfulTests( false ), + shouldDebugBreak( false ), + noThrow( false ), + showHelp( false ), + showInvisibles( false ), + filenamesAsTags( false ), + libIdentify( false ), + abortAfter( -1 ), + rngSeed( 0 ), + verbosity( Verbosity::Normal ), + warnings( WarnAbout::Nothing ), + showDurations( ShowDurations::DefaultForReporter ), + runOrder( RunTests::InDeclarationOrder ), + useColour( UseColour::Auto ), + waitForKeypress( WaitForKeypress::Never ) + {} + + bool listTests; + bool listTags; + bool listReporters; + bool listTestNamesOnly; + bool listExtraInfo; + + bool showSuccessfulTests; + bool shouldDebugBreak; + bool noThrow; + bool showHelp; + bool showInvisibles; + bool filenamesAsTags; + bool libIdentify; + + int abortAfter; + unsigned int rngSeed; + + Verbosity::Level verbosity; + WarnAbout::What warnings; + ShowDurations::OrNot showDurations; + RunTests::InWhatOrder runOrder; + UseColour::YesOrNo useColour; + WaitForKeypress::When waitForKeypress; + + std::string outputFilename; + std::string name; + std::string processName; + + std::vector reporterNames; + std::vector testsOrTags; + std::vector sectionsToRun; + }; + + class Config : public SharedImpl { + private: + Config( Config const& other ); + Config& operator = ( Config const& other ); + virtual void dummy(); + public: + + Config() + {} + + Config( ConfigData const& data ) + : m_data( data ), + m_stream( openStream() ) + { + if( !data.testsOrTags.empty() ) { + TestSpecParser parser( ITagAliasRegistry::get() ); + for( std::size_t i = 0; i < data.testsOrTags.size(); ++i ) + parser.parse( data.testsOrTags[i] ); + m_testSpec = parser.testSpec(); + } + } + + virtual ~Config() {} + + std::string const& getFilename() const { + return m_data.outputFilename ; + } + + bool listTests() const { return m_data.listTests; } + bool listTestNamesOnly() const { return m_data.listTestNamesOnly; } + bool listTags() const { return m_data.listTags; } + bool listReporters() const { return m_data.listReporters; } + bool listExtraInfo() const { return m_data.listExtraInfo; } + + std::string getProcessName() const { return m_data.processName; } + + std::vector const& getReporterNames() const { return m_data.reporterNames; } + std::vector const& getSectionsToRun() const CATCH_OVERRIDE { return m_data.sectionsToRun; } + + virtual TestSpec const& testSpec() const CATCH_OVERRIDE { return m_testSpec; } + + bool showHelp() const { return m_data.showHelp; } + + // IConfig interface + virtual bool allowThrows() const CATCH_OVERRIDE { return !m_data.noThrow; } + virtual std::ostream& stream() const CATCH_OVERRIDE { return m_stream->stream(); } + virtual std::string name() const CATCH_OVERRIDE { return m_data.name.empty() ? m_data.processName : m_data.name; } + virtual bool includeSuccessfulResults() const CATCH_OVERRIDE { return m_data.showSuccessfulTests; } + virtual bool warnAboutMissingAssertions() const CATCH_OVERRIDE { return m_data.warnings & WarnAbout::NoAssertions; } + virtual ShowDurations::OrNot showDurations() const CATCH_OVERRIDE { return m_data.showDurations; } + virtual RunTests::InWhatOrder runOrder() const CATCH_OVERRIDE { return m_data.runOrder; } + virtual unsigned int rngSeed() const CATCH_OVERRIDE { return m_data.rngSeed; } + virtual UseColour::YesOrNo useColour() const CATCH_OVERRIDE { return m_data.useColour; } + virtual bool shouldDebugBreak() const CATCH_OVERRIDE { return m_data.shouldDebugBreak; } + virtual int abortAfter() const CATCH_OVERRIDE { return m_data.abortAfter; } + virtual bool showInvisibles() const CATCH_OVERRIDE { return m_data.showInvisibles; } + + private: + + IStream const* openStream() { + if( m_data.outputFilename.empty() ) + return new CoutStream(); + else if( m_data.outputFilename[0] == '%' ) { + if( m_data.outputFilename == "%debug" ) + return new DebugOutStream(); + else + throw std::domain_error( "Unrecognised stream: " + m_data.outputFilename ); + } + else + return new FileStream( m_data.outputFilename ); + } + ConfigData m_data; + + CATCH_AUTO_PTR( IStream const ) m_stream; + TestSpec m_testSpec; + }; + +} // end namespace Catch + +// #included from: catch_clara.h +#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED + +// Use Catch's value for console width (store Clara's off to the side, if present) +#ifdef CLARA_CONFIG_CONSOLE_WIDTH +#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH +#undef CLARA_CONFIG_CONSOLE_WIDTH +#endif +#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH + +// Declare Clara inside the Catch namespace +#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch { +// #included from: ../external/clara.h + +// Version 0.0.2.4 + +// Only use header guard if we are not using an outer namespace +#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE) + +#ifndef STITCH_CLARA_OPEN_NAMESPACE +#define TWOBLUECUBES_CLARA_H_INCLUDED +#define STITCH_CLARA_OPEN_NAMESPACE +#define STITCH_CLARA_CLOSE_NAMESPACE +#else +#define STITCH_CLARA_CLOSE_NAMESPACE } +#endif + +#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE + +// ----------- #included from tbc_text_format.h ----------- + +// Only use header guard if we are not using an outer namespace +#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE) +#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE +#define TBC_TEXT_FORMAT_H_INCLUDED +#endif + +#include +#include +#include +#include +#include + +// Use optional outer namespace +#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE +namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE { +#endif + +namespace Tbc { + +#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH + const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; +#else + const unsigned int consoleWidth = 80; +#endif + + struct TextAttributes { + TextAttributes() + : initialIndent( std::string::npos ), + indent( 0 ), + width( consoleWidth-1 ), + tabChar( '\t' ) + {} + + TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } + TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } + TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } + TextAttributes& setTabChar( char _value ) { tabChar = _value; return *this; } + + std::size_t initialIndent; // indent of first line, or npos + std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos + std::size_t width; // maximum width of text, including indent. Longer text will wrap + char tabChar; // If this char is seen the indent is changed to current pos + }; + + class Text { + public: + Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) + : attr( _attr ) + { + std::string wrappableChars = " [({.,/|\\-"; + std::size_t indent = _attr.initialIndent != std::string::npos + ? _attr.initialIndent + : _attr.indent; + std::string remainder = _str; + + while( !remainder.empty() ) { + if( lines.size() >= 1000 ) { + lines.push_back( "... message truncated due to excessive size" ); + return; + } + std::size_t tabPos = std::string::npos; + std::size_t width = (std::min)( remainder.size(), _attr.width - indent ); + std::size_t pos = remainder.find_first_of( '\n' ); + if( pos <= width ) { + width = pos; + } + pos = remainder.find_last_of( _attr.tabChar, width ); + if( pos != std::string::npos ) { + tabPos = pos; + if( remainder[width] == '\n' ) + width--; + remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 ); + } + + if( width == remainder.size() ) { + spliceLine( indent, remainder, width ); + } + else if( remainder[width] == '\n' ) { + spliceLine( indent, remainder, width ); + if( width <= 1 || remainder.size() != 1 ) + remainder = remainder.substr( 1 ); + indent = _attr.indent; + } + else { + pos = remainder.find_last_of( wrappableChars, width ); + if( pos != std::string::npos && pos > 0 ) { + spliceLine( indent, remainder, pos ); + if( remainder[0] == ' ' ) + remainder = remainder.substr( 1 ); + } + else { + spliceLine( indent, remainder, width-1 ); + lines.back() += "-"; + } + if( lines.size() == 1 ) + indent = _attr.indent; + if( tabPos != std::string::npos ) + indent += tabPos; + } + } + } + + void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) { + lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) ); + _remainder = _remainder.substr( _pos ); + } + + typedef std::vector::const_iterator const_iterator; + + const_iterator begin() const { return lines.begin(); } + const_iterator end() const { return lines.end(); } + std::string const& last() const { return lines.back(); } + std::size_t size() const { return lines.size(); } + std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } + std::string toString() const { + std::ostringstream oss; + oss << *this; + return oss.str(); + } + + friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { + for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); + it != itEnd; ++it ) { + if( it != _text.begin() ) + _stream << "\n"; + _stream << *it; + } + return _stream; + } + + private: + std::string str; + TextAttributes attr; + std::vector lines; + }; + +} // end namespace Tbc + +#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE +} // end outer namespace +#endif + +#endif // TBC_TEXT_FORMAT_H_INCLUDED + +// ----------- end of #include from tbc_text_format.h ----------- +// ........... back in clara.h + +#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE + +// ----------- #included from clara_compilers.h ----------- + +#ifndef TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED +#define TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED + +// Detect a number of compiler features - mostly C++11/14 conformance - by compiler +// The following features are defined: +// +// CLARA_CONFIG_CPP11_NULLPTR : is nullptr supported? +// CLARA_CONFIG_CPP11_NOEXCEPT : is noexcept supported? +// CLARA_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods +// CLARA_CONFIG_CPP11_OVERRIDE : is override supported? +// CLARA_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr) + +// CLARA_CONFIG_CPP11_OR_GREATER : Is C++11 supported? + +// CLARA_CONFIG_VARIADIC_MACROS : are variadic macros supported? + +// In general each macro has a _NO_ form +// (e.g. CLARA_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 CLARA_CONFIG_NO_CPP11 + +#ifdef __clang__ + +#if __has_feature(cxx_nullptr) +#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR +#endif + +#if __has_feature(cxx_noexcept) +#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT +#endif + +#endif // __clang__ + +//////////////////////////////////////////////////////////////////////////////// +// GCC +#ifdef __GNUC__ + +#if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__) +#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR +#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 CLARA_INTERNAL_CONFIG_CPP11_NULLPTR +#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR +#endif + +#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015)) +#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT +#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +#endif + +#endif // _MSC_VER + +//////////////////////////////////////////////////////////////////////////////// +// C++ language feature support + +// catch all support for C++11 +#if defined(__cplusplus) && __cplusplus >= 201103L + +#define CLARA_CPP11_OR_GREATER + +#if !defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR) +#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR +#endif + +#ifndef CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT +#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT +#endif + +#ifndef CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS +#endif + +#if !defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE) +#define CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE +#endif +#if !defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) +#define CLARA_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(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NO_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_NO_CPP11) +#define CLARA_CONFIG_CPP11_NULLPTR +#endif +#if defined(CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_NO_CPP11) +#define CLARA_CONFIG_CPP11_NOEXCEPT +#endif +#if defined(CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_NO_CPP11) +#define CLARA_CONFIG_CPP11_GENERATED_METHODS +#endif +#if defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_OVERRIDE) && !defined(CLARA_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_CPP11) +#define CLARA_CONFIG_CPP11_OVERRIDE +#endif +#if defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_UNIQUE_PTR) && !defined(CLARA_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_CPP11) +#define CLARA_CONFIG_CPP11_UNIQUE_PTR +#endif + +// noexcept support: +#if defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_NOEXCEPT) +#define CLARA_NOEXCEPT noexcept +# define CLARA_NOEXCEPT_IS(x) noexcept(x) +#else +#define CLARA_NOEXCEPT throw() +# define CLARA_NOEXCEPT_IS(x) +#endif + +// nullptr support +#ifdef CLARA_CONFIG_CPP11_NULLPTR +#define CLARA_NULL nullptr +#else +#define CLARA_NULL NULL +#endif + +// override support +#ifdef CLARA_CONFIG_CPP11_OVERRIDE +#define CLARA_OVERRIDE override +#else +#define CLARA_OVERRIDE +#endif + +// unique_ptr support +#ifdef CLARA_CONFIG_CPP11_UNIQUE_PTR +# define CLARA_AUTO_PTR( T ) std::unique_ptr +#else +# define CLARA_AUTO_PTR( T ) std::auto_ptr +#endif + +#endif // TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED + +// ----------- end of #include from clara_compilers.h ----------- +// ........... back in clara.h + +#include +#include +#include + +#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) +#define CLARA_PLATFORM_WINDOWS +#endif + +// Use optional outer namespace +#ifdef STITCH_CLARA_OPEN_NAMESPACE +STITCH_CLARA_OPEN_NAMESPACE +#endif + +namespace Clara { + + struct UnpositionalTag {}; + + extern UnpositionalTag _; + +#ifdef CLARA_CONFIG_MAIN + UnpositionalTag _; +#endif + + namespace Detail { + +#ifdef CLARA_CONSOLE_WIDTH + const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH; +#else + const unsigned int consoleWidth = 80; +#endif + + using namespace Tbc; + + inline bool startsWith( std::string const& str, std::string const& prefix ) { + return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix; + } + + template struct RemoveConstRef{ typedef T type; }; + template struct RemoveConstRef{ typedef T type; }; + template struct RemoveConstRef{ typedef T type; }; + template struct RemoveConstRef{ typedef T type; }; + + template struct IsBool { static const bool value = false; }; + template<> struct IsBool { static const bool value = true; }; + + template + void convertInto( std::string const& _source, T& _dest ) { + std::stringstream ss; + ss << _source; + ss >> _dest; + if( ss.fail() ) + throw std::runtime_error( "Unable to convert " + _source + " to destination type" ); + } + inline void convertInto( std::string const& _source, std::string& _dest ) { + _dest = _source; + } + char toLowerCh(char c) { + return static_cast( std::tolower( c ) ); + } + inline void convertInto( std::string const& _source, bool& _dest ) { + std::string sourceLC = _source; + std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), toLowerCh ); + if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" ) + _dest = true; + else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" ) + _dest = false; + else + throw std::runtime_error( "Expected a boolean value but did not recognise:\n '" + _source + "'" ); + } + + template + struct IArgFunction { + virtual ~IArgFunction() {} +#ifdef CLARA_CONFIG_CPP11_GENERATED_METHODS + IArgFunction() = default; + IArgFunction( IArgFunction const& ) = default; +#endif + virtual void set( ConfigT& config, std::string const& value ) const = 0; + virtual bool takesArg() const = 0; + virtual IArgFunction* clone() const = 0; + }; + + template + class BoundArgFunction { + public: + BoundArgFunction() : functionObj( CLARA_NULL ) {} + BoundArgFunction( IArgFunction* _functionObj ) : functionObj( _functionObj ) {} + BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : CLARA_NULL ) {} + BoundArgFunction& operator = ( BoundArgFunction const& other ) { + IArgFunction* newFunctionObj = other.functionObj ? other.functionObj->clone() : CLARA_NULL; + delete functionObj; + functionObj = newFunctionObj; + return *this; + } + ~BoundArgFunction() { delete functionObj; } + + void set( ConfigT& config, std::string const& value ) const { + functionObj->set( config, value ); + } + bool takesArg() const { return functionObj->takesArg(); } + + bool isSet() const { + return functionObj != CLARA_NULL; + } + private: + IArgFunction* functionObj; + }; + + template + struct NullBinder : IArgFunction{ + virtual void set( C&, std::string const& ) const {} + virtual bool takesArg() const { return true; } + virtual IArgFunction* clone() const { return new NullBinder( *this ); } + }; + + template + struct BoundDataMember : IArgFunction{ + BoundDataMember( M C::* _member ) : member( _member ) {} + virtual void set( C& p, std::string const& stringValue ) const { + convertInto( stringValue, p.*member ); + } + virtual bool takesArg() const { return !IsBool::value; } + virtual IArgFunction* clone() const { return new BoundDataMember( *this ); } + M C::* member; + }; + template + struct BoundUnaryMethod : IArgFunction{ + BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {} + virtual void set( C& p, std::string const& stringValue ) const { + typename RemoveConstRef::type value; + convertInto( stringValue, value ); + (p.*member)( value ); + } + virtual bool takesArg() const { return !IsBool::value; } + virtual IArgFunction* clone() const { return new BoundUnaryMethod( *this ); } + void (C::*member)( M ); + }; + template + struct BoundNullaryMethod : IArgFunction{ + BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {} + virtual void set( C& p, std::string const& stringValue ) const { + bool value; + convertInto( stringValue, value ); + if( value ) + (p.*member)(); + } + virtual bool takesArg() const { return false; } + virtual IArgFunction* clone() const { return new BoundNullaryMethod( *this ); } + void (C::*member)(); + }; + + template + struct BoundUnaryFunction : IArgFunction{ + BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {} + virtual void set( C& obj, std::string const& stringValue ) const { + bool value; + convertInto( stringValue, value ); + if( value ) + function( obj ); + } + virtual bool takesArg() const { return false; } + virtual IArgFunction* clone() const { return new BoundUnaryFunction( *this ); } + void (*function)( C& ); + }; + + template + struct BoundBinaryFunction : IArgFunction{ + BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {} + virtual void set( C& obj, std::string const& stringValue ) const { + typename RemoveConstRef::type value; + convertInto( stringValue, value ); + function( obj, value ); + } + virtual bool takesArg() const { return !IsBool::value; } + virtual IArgFunction* clone() const { return new BoundBinaryFunction( *this ); } + void (*function)( C&, T ); + }; + + } // namespace Detail + + inline std::vector argsToVector( int argc, char const* const* const argv ) { + std::vector args( static_cast( argc ) ); + for( std::size_t i = 0; i < static_cast( argc ); ++i ) + args[i] = argv[i]; + + return args; + } + + class Parser { + enum Mode { None, MaybeShortOpt, SlashOpt, ShortOpt, LongOpt, Positional }; + Mode mode; + std::size_t from; + bool inQuotes; + public: + + struct Token { + enum Type { Positional, ShortOpt, LongOpt }; + Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {} + Type type; + std::string data; + }; + + Parser() : mode( None ), from( 0 ), inQuotes( false ){} + + void parseIntoTokens( std::vector const& args, std::vector& tokens ) { + const std::string doubleDash = "--"; + for( std::size_t i = 1; i < args.size() && args[i] != doubleDash; ++i ) + parseIntoTokens( args[i], tokens); + } + + void parseIntoTokens( std::string const& arg, std::vector& tokens ) { + for( std::size_t i = 0; i < arg.size(); ++i ) { + char c = arg[i]; + if( c == '"' ) + inQuotes = !inQuotes; + mode = handleMode( i, c, arg, tokens ); + } + mode = handleMode( arg.size(), '\0', arg, tokens ); + } + Mode handleMode( std::size_t i, char c, std::string const& arg, std::vector& tokens ) { + switch( mode ) { + case None: return handleNone( i, c ); + case MaybeShortOpt: return handleMaybeShortOpt( i, c ); + case ShortOpt: + case LongOpt: + case SlashOpt: return handleOpt( i, c, arg, tokens ); + case Positional: return handlePositional( i, c, arg, tokens ); + default: throw std::logic_error( "Unknown mode" ); + } + } + + Mode handleNone( std::size_t i, char c ) { + if( inQuotes ) { + from = i; + return Positional; + } + switch( c ) { + case '-': return MaybeShortOpt; +#ifdef CLARA_PLATFORM_WINDOWS + case '/': from = i+1; return SlashOpt; +#endif + default: from = i; return Positional; + } + } + Mode handleMaybeShortOpt( std::size_t i, char c ) { + switch( c ) { + case '-': from = i+1; return LongOpt; + default: from = i; return ShortOpt; + } + } + + Mode handleOpt( std::size_t i, char c, std::string const& arg, std::vector& tokens ) { + if( std::string( ":=\0", 3 ).find( c ) == std::string::npos ) + return mode; + + std::string optName = arg.substr( from, i-from ); + if( mode == ShortOpt ) + for( std::size_t j = 0; j < optName.size(); ++j ) + tokens.push_back( Token( Token::ShortOpt, optName.substr( j, 1 ) ) ); + else if( mode == SlashOpt && optName.size() == 1 ) + tokens.push_back( Token( Token::ShortOpt, optName ) ); + else + tokens.push_back( Token( Token::LongOpt, optName ) ); + return None; + } + Mode handlePositional( std::size_t i, char c, std::string const& arg, std::vector& tokens ) { + if( inQuotes || std::string( "\0", 1 ).find( c ) == std::string::npos ) + return mode; + + std::string data = arg.substr( from, i-from ); + tokens.push_back( Token( Token::Positional, data ) ); + return None; + } + }; + + template + struct CommonArgProperties { + CommonArgProperties() {} + CommonArgProperties( Detail::BoundArgFunction const& _boundField ) : boundField( _boundField ) {} + + Detail::BoundArgFunction boundField; + std::string description; + std::string detail; + std::string placeholder; // Only value if boundField takes an arg + + bool takesArg() const { + return !placeholder.empty(); + } + void validate() const { + if( !boundField.isSet() ) + throw std::logic_error( "option not bound" ); + } + }; + struct OptionArgProperties { + std::vector shortNames; + std::string longName; + + bool hasShortName( std::string const& shortName ) const { + return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end(); + } + bool hasLongName( std::string const& _longName ) const { + return _longName == longName; + } + }; + struct PositionalArgProperties { + PositionalArgProperties() : position( -1 ) {} + int position; // -1 means non-positional (floating) + + bool isFixedPositional() const { + return position != -1; + } + }; + + template + class CommandLine { + + struct Arg : CommonArgProperties, OptionArgProperties, PositionalArgProperties { + Arg() {} + Arg( Detail::BoundArgFunction const& _boundField ) : CommonArgProperties( _boundField ) {} + + using CommonArgProperties::placeholder; // !TBD + + std::string dbgName() const { + if( !longName.empty() ) + return "--" + longName; + if( !shortNames.empty() ) + return "-" + shortNames[0]; + return "positional args"; + } + std::string commands() const { + std::ostringstream oss; + bool first = true; + std::vector::const_iterator it = shortNames.begin(), itEnd = shortNames.end(); + for(; it != itEnd; ++it ) { + if( first ) + first = false; + else + oss << ", "; + oss << "-" << *it; + } + if( !longName.empty() ) { + if( !first ) + oss << ", "; + oss << "--" << longName; + } + if( !placeholder.empty() ) + oss << " <" << placeholder << ">"; + return oss.str(); + } + }; + + typedef CLARA_AUTO_PTR( Arg ) ArgAutoPtr; + + friend void addOptName( Arg& arg, std::string const& optName ) + { + if( optName.empty() ) + return; + if( Detail::startsWith( optName, "--" ) ) { + if( !arg.longName.empty() ) + throw std::logic_error( "Only one long opt may be specified. '" + + arg.longName + + "' already specified, now attempting to add '" + + optName + "'" ); + arg.longName = optName.substr( 2 ); + } + else if( Detail::startsWith( optName, "-" ) ) + arg.shortNames.push_back( optName.substr( 1 ) ); + else + throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" ); + } + friend void setPositionalArg( Arg& arg, int position ) + { + arg.position = position; + } + + class ArgBuilder { + public: + ArgBuilder( Arg* arg ) : m_arg( arg ) {} + + // Bind a non-boolean data member (requires placeholder string) + template + void bind( M C::* field, std::string const& placeholder ) { + m_arg->boundField = new Detail::BoundDataMember( field ); + m_arg->placeholder = placeholder; + } + // Bind a boolean data member (no placeholder required) + template + void bind( bool C::* field ) { + m_arg->boundField = new Detail::BoundDataMember( field ); + } + + // Bind a method taking a single, non-boolean argument (requires a placeholder string) + template + void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) { + m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod ); + m_arg->placeholder = placeholder; + } + + // Bind a method taking a single, boolean argument (no placeholder string required) + template + void bind( void (C::* unaryMethod)( bool ) ) { + m_arg->boundField = new Detail::BoundUnaryMethod( unaryMethod ); + } + + // Bind a method that takes no arguments (will be called if opt is present) + template + void bind( void (C::* nullaryMethod)() ) { + m_arg->boundField = new Detail::BoundNullaryMethod( nullaryMethod ); + } + + // Bind a free function taking a single argument - the object to operate on (no placeholder string required) + template + void bind( void (* unaryFunction)( C& ) ) { + m_arg->boundField = new Detail::BoundUnaryFunction( unaryFunction ); + } + + // Bind a free function taking a single argument - the object to operate on (requires a placeholder string) + template + void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) { + m_arg->boundField = new Detail::BoundBinaryFunction( binaryFunction ); + m_arg->placeholder = placeholder; + } + + ArgBuilder& describe( std::string const& description ) { + m_arg->description = description; + return *this; + } + ArgBuilder& detail( std::string const& detail ) { + m_arg->detail = detail; + return *this; + } + + protected: + Arg* m_arg; + }; + + class OptBuilder : public ArgBuilder { + public: + OptBuilder( Arg* arg ) : ArgBuilder( arg ) {} + OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {} + + OptBuilder& operator[]( std::string const& optName ) { + addOptName( *ArgBuilder::m_arg, optName ); + return *this; + } + }; + + public: + + CommandLine() + : m_boundProcessName( new Detail::NullBinder() ), + m_highestSpecifiedArgPosition( 0 ), + m_throwOnUnrecognisedTokens( false ) + {} + CommandLine( CommandLine const& other ) + : m_boundProcessName( other.m_boundProcessName ), + m_options ( other.m_options ), + m_positionalArgs( other.m_positionalArgs ), + m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ), + m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens ) + { + if( other.m_floatingArg.get() ) + m_floatingArg.reset( new Arg( *other.m_floatingArg ) ); + } + + CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) { + m_throwOnUnrecognisedTokens = shouldThrow; + return *this; + } + + OptBuilder operator[]( std::string const& optName ) { + m_options.push_back( Arg() ); + addOptName( m_options.back(), optName ); + OptBuilder builder( &m_options.back() ); + return builder; + } + + ArgBuilder operator[]( int position ) { + m_positionalArgs.insert( std::make_pair( position, Arg() ) ); + if( position > m_highestSpecifiedArgPosition ) + m_highestSpecifiedArgPosition = position; + setPositionalArg( m_positionalArgs[position], position ); + ArgBuilder builder( &m_positionalArgs[position] ); + return builder; + } + + // Invoke this with the _ instance + ArgBuilder operator[]( UnpositionalTag ) { + if( m_floatingArg.get() ) + throw std::logic_error( "Only one unpositional argument can be added" ); + m_floatingArg.reset( new Arg() ); + ArgBuilder builder( m_floatingArg.get() ); + return builder; + } + + template + void bindProcessName( M C::* field ) { + m_boundProcessName = new Detail::BoundDataMember( field ); + } + template + void bindProcessName( void (C::*_unaryMethod)( M ) ) { + m_boundProcessName = new Detail::BoundUnaryMethod( _unaryMethod ); + } + + void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const { + typename std::vector::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it; + std::size_t maxWidth = 0; + for( it = itBegin; it != itEnd; ++it ) + maxWidth = (std::max)( maxWidth, it->commands().size() ); + + for( it = itBegin; it != itEnd; ++it ) { + Detail::Text usage( it->commands(), Detail::TextAttributes() + .setWidth( maxWidth+indent ) + .setIndent( indent ) ); + Detail::Text desc( it->description, Detail::TextAttributes() + .setWidth( width - maxWidth - 3 ) ); + + for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) { + std::string usageCol = i < usage.size() ? usage[i] : ""; + os << usageCol; + + if( i < desc.size() && !desc[i].empty() ) + os << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' ) + << desc[i]; + os << "\n"; + } + } + } + std::string optUsage() const { + std::ostringstream oss; + optUsage( oss ); + return oss.str(); + } + + void argSynopsis( std::ostream& os ) const { + for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) { + if( i > 1 ) + os << " "; + typename std::map::const_iterator it = m_positionalArgs.find( i ); + if( it != m_positionalArgs.end() ) + os << "<" << it->second.placeholder << ">"; + else if( m_floatingArg.get() ) + os << "<" << m_floatingArg->placeholder << ">"; + else + throw std::logic_error( "non consecutive positional arguments with no floating args" ); + } + // !TBD No indication of mandatory args + if( m_floatingArg.get() ) { + if( m_highestSpecifiedArgPosition > 1 ) + os << " "; + os << "[<" << m_floatingArg->placeholder << "> ...]"; + } + } + std::string argSynopsis() const { + std::ostringstream oss; + argSynopsis( oss ); + return oss.str(); + } + + void usage( std::ostream& os, std::string const& procName ) const { + validate(); + os << "usage:\n " << procName << " "; + argSynopsis( os ); + if( !m_options.empty() ) { + os << " [options]\n\nwhere options are: \n"; + optUsage( os, 2 ); + } + os << "\n"; + } + std::string usage( std::string const& procName ) const { + std::ostringstream oss; + usage( oss, procName ); + return oss.str(); + } + + ConfigT parse( std::vector const& args ) const { + ConfigT config; + parseInto( args, config ); + return config; + } + + std::vector parseInto( std::vector const& args, ConfigT& config ) const { + std::string processName = args.empty() ? std::string() : args[0]; + std::size_t lastSlash = processName.find_last_of( "/\\" ); + if( lastSlash != std::string::npos ) + processName = processName.substr( lastSlash+1 ); + m_boundProcessName.set( config, processName ); + std::vector tokens; + Parser parser; + parser.parseIntoTokens( args, tokens ); + return populate( tokens, config ); + } + + std::vector populate( std::vector const& tokens, ConfigT& config ) const { + validate(); + std::vector unusedTokens = populateOptions( tokens, config ); + unusedTokens = populateFixedArgs( unusedTokens, config ); + unusedTokens = populateFloatingArgs( unusedTokens, config ); + return unusedTokens; + } + + std::vector populateOptions( std::vector const& tokens, ConfigT& config ) const { + std::vector unusedTokens; + std::vector errors; + for( std::size_t i = 0; i < tokens.size(); ++i ) { + Parser::Token const& token = tokens[i]; + typename std::vector::const_iterator it = m_options.begin(), itEnd = m_options.end(); + for(; it != itEnd; ++it ) { + Arg const& arg = *it; + + try { + if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) || + ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) { + if( arg.takesArg() ) { + if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional ) + errors.push_back( "Expected argument to option: " + token.data ); + else + arg.boundField.set( config, tokens[++i].data ); + } + else { + arg.boundField.set( config, "true" ); + } + break; + } + } + catch( std::exception& ex ) { + errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" ); + } + } + if( it == itEnd ) { + if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens ) + unusedTokens.push_back( token ); + else if( errors.empty() && m_throwOnUnrecognisedTokens ) + errors.push_back( "unrecognised option: " + token.data ); + } + } + if( !errors.empty() ) { + std::ostringstream oss; + for( std::vector::const_iterator it = errors.begin(), itEnd = errors.end(); + it != itEnd; + ++it ) { + if( it != errors.begin() ) + oss << "\n"; + oss << *it; + } + throw std::runtime_error( oss.str() ); + } + return unusedTokens; + } + std::vector populateFixedArgs( std::vector const& tokens, ConfigT& config ) const { + std::vector unusedTokens; + int position = 1; + for( std::size_t i = 0; i < tokens.size(); ++i ) { + Parser::Token const& token = tokens[i]; + typename std::map::const_iterator it = m_positionalArgs.find( position ); + if( it != m_positionalArgs.end() ) + it->second.boundField.set( config, token.data ); + else + unusedTokens.push_back( token ); + if( token.type == Parser::Token::Positional ) + position++; + } + return unusedTokens; + } + std::vector populateFloatingArgs( std::vector const& tokens, ConfigT& config ) const { + if( !m_floatingArg.get() ) + return tokens; + std::vector unusedTokens; + for( std::size_t i = 0; i < tokens.size(); ++i ) { + Parser::Token const& token = tokens[i]; + if( token.type == Parser::Token::Positional ) + m_floatingArg->boundField.set( config, token.data ); + else + unusedTokens.push_back( token ); + } + return unusedTokens; + } + + void validate() const + { + if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() ) + throw std::logic_error( "No options or arguments specified" ); + + for( typename std::vector::const_iterator it = m_options.begin(), + itEnd = m_options.end(); + it != itEnd; ++it ) + it->validate(); + } + + private: + Detail::BoundArgFunction m_boundProcessName; + std::vector m_options; + std::map m_positionalArgs; + ArgAutoPtr m_floatingArg; + int m_highestSpecifiedArgPosition; + bool m_throwOnUnrecognisedTokens; + }; + +} // end namespace Clara + +STITCH_CLARA_CLOSE_NAMESPACE +#undef STITCH_CLARA_OPEN_NAMESPACE +#undef STITCH_CLARA_CLOSE_NAMESPACE + +#endif // TWOBLUECUBES_CLARA_H_INCLUDED +#undef STITCH_CLARA_OPEN_NAMESPACE + +// Restore Clara's value for console width, if present +#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH +#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH +#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH +#endif + +#include +#include + +namespace Catch { + + inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; } + inline void abortAfterX( ConfigData& config, int x ) { + if( x < 1 ) + throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" ); + config.abortAfter = x; + } + inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); } + inline void addSectionToRun( ConfigData& config, std::string const& sectionName ) { config.sectionsToRun.push_back( sectionName ); } + inline void addReporterName( ConfigData& config, std::string const& _reporterName ) { config.reporterNames.push_back( _reporterName ); } + + inline void addWarning( ConfigData& config, std::string const& _warning ) { + if( _warning == "NoAssertions" ) + config.warnings = static_cast( config.warnings | WarnAbout::NoAssertions ); + else + throw std::runtime_error( "Unrecognised warning: '" + _warning + '\'' ); + } + inline void setOrder( ConfigData& config, 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 + throw std::runtime_error( "Unrecognised ordering: '" + order + '\'' ); + } + inline void setRngSeed( ConfigData& config, std::string const& seed ) { + if( seed == "time" ) { + config.rngSeed = static_cast( std::time(0) ); + } + else { + std::stringstream ss; + ss << seed; + ss >> config.rngSeed; + if( ss.fail() ) + throw std::runtime_error( "Argument to --rng-seed should be the word 'time' or a number" ); + } + } + inline void setVerbosity( ConfigData& config, int level ) { + // !TBD: accept strings? + config.verbosity = static_cast( level ); + } + inline void setShowDurations( ConfigData& config, bool _showDurations ) { + config.showDurations = _showDurations + ? ShowDurations::Always + : ShowDurations::Never; + } + inline void setUseColour( ConfigData& config, std::string const& value ) { + std::string mode = toLower( value ); + + if( mode == "yes" ) + config.useColour = UseColour::Yes; + else if( mode == "no" ) + config.useColour = UseColour::No; + else if( mode == "auto" ) + config.useColour = UseColour::Auto; + else + throw std::runtime_error( "colour mode must be one of: auto, yes or no" ); + } + inline void setWaitForKeypress( ConfigData& config, std::string const& keypress ) { + std::string 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 + throw std::runtime_error( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" ); + }; + + inline void forceColour( ConfigData& config ) { + config.useColour = UseColour::Yes; + } + inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) { + std::ifstream f( _filename.c_str() ); + if( !f.is_open() ) + throw std::domain_error( "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 + '"'; + addTestOrTags( config, line + ',' ); + } + } + } + + inline Clara::CommandLine makeCommandLineParser() { + + using namespace Clara; + CommandLine cli; + + cli.bindProcessName( &ConfigData::processName ); + + cli["-?"]["-h"]["--help"] + .describe( "display usage information" ) + .bind( &ConfigData::showHelp ); + + cli["-l"]["--list-tests"] + .describe( "list all/matching test cases" ) + .bind( &ConfigData::listTests ); + + cli["-t"]["--list-tags"] + .describe( "list all/matching tags" ) + .bind( &ConfigData::listTags ); + + cli["-s"]["--success"] + .describe( "include successful tests in output" ) + .bind( &ConfigData::showSuccessfulTests ); + + cli["-b"]["--break"] + .describe( "break into debugger on failure" ) + .bind( &ConfigData::shouldDebugBreak ); + + cli["-e"]["--nothrow"] + .describe( "skip exception tests" ) + .bind( &ConfigData::noThrow ); + + cli["-i"]["--invisibles"] + .describe( "show invisibles (tabs, newlines)" ) + .bind( &ConfigData::showInvisibles ); + + cli["-o"]["--out"] + .describe( "output filename" ) + .bind( &ConfigData::outputFilename, "filename" ); + + cli["-r"]["--reporter"] +// .placeholder( "name[:filename]" ) + .describe( "reporter to use (defaults to console)" ) + .bind( &addReporterName, "name" ); + + cli["-n"]["--name"] + .describe( "suite name" ) + .bind( &ConfigData::name, "name" ); + + cli["-a"]["--abort"] + .describe( "abort at first failure" ) + .bind( &abortAfterFirst ); + + cli["-x"]["--abortx"] + .describe( "abort after x failures" ) + .bind( &abortAfterX, "no. failures" ); + + cli["-w"]["--warn"] + .describe( "enable warnings" ) + .bind( &addWarning, "warning name" ); + +// - needs updating if reinstated +// cli.into( &setVerbosity ) +// .describe( "level of verbosity (0=no output)" ) +// .shortOpt( "v") +// .longOpt( "verbosity" ) +// .placeholder( "level" ); + + cli[_] + .describe( "which test or tests to use" ) + .bind( &addTestOrTags, "test name, pattern or tags" ); + + cli["-d"]["--durations"] + .describe( "show test durations" ) + .bind( &setShowDurations, "yes|no" ); + + cli["-f"]["--input-file"] + .describe( "load test names to run from a file" ) + .bind( &loadTestNamesFromFile, "filename" ); + + cli["-#"]["--filenames-as-tags"] + .describe( "adds a tag for the filename" ) + .bind( &ConfigData::filenamesAsTags ); + + cli["-c"]["--section"] + .describe( "specify section to run" ) + .bind( &addSectionToRun, "section name" ); + + // Less common commands which don't have a short form + cli["--list-test-names-only"] + .describe( "list all/matching test cases names only" ) + .bind( &ConfigData::listTestNamesOnly ); + + cli["--list-extra-info"] + .describe( "list all/matching test cases with more info" ) + .bind( &ConfigData::listExtraInfo ); + + cli["--list-reporters"] + .describe( "list all reporters" ) + .bind( &ConfigData::listReporters ); + + cli["--order"] + .describe( "test case order (defaults to decl)" ) + .bind( &setOrder, "decl|lex|rand" ); + + cli["--rng-seed"] + .describe( "set a specific seed for random numbers" ) + .bind( &setRngSeed, "'time'|number" ); + + cli["--force-colour"] + .describe( "force colourised output (deprecated)" ) + .bind( &forceColour ); + + cli["--use-colour"] + .describe( "should output be colourised" ) + .bind( &setUseColour, "yes|no" ); + + cli["--libidentify"] + .describe( "report name and version according to libidentify standard" ) + .bind( &ConfigData::libIdentify ); + + cli["--wait-for-keypress"] + .describe( "waits for a keypress before exiting" ) + .bind( &setWaitForKeypress, "start|exit|both" ); + + return cli; + } + +} // end namespace Catch + +// #included from: internal/catch_list.hpp +#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED + +// #included from: catch_text.h +#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED + +#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH + +#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch +// #included from: ../external/tbc_text_format.h +// Only use header guard if we are not using an outer namespace +#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE +# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED +# ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +# define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +# endif +# else +# define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED +# endif +#endif +#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +#include +#include +#include + +// Use optional outer namespace +#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE +namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE { +#endif + +namespace Tbc { + +#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH + const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH; +#else + const unsigned int consoleWidth = 80; +#endif + + struct TextAttributes { + TextAttributes() + : initialIndent( std::string::npos ), + indent( 0 ), + width( consoleWidth-1 ) + {} + + TextAttributes& setInitialIndent( std::size_t _value ) { initialIndent = _value; return *this; } + TextAttributes& setIndent( std::size_t _value ) { indent = _value; return *this; } + TextAttributes& setWidth( std::size_t _value ) { width = _value; return *this; } + + std::size_t initialIndent; // indent of first line, or npos + std::size_t indent; // indent of subsequent lines, or all if initialIndent is npos + std::size_t width; // maximum width of text, including indent. Longer text will wrap + }; + + class Text { + public: + Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() ) + : attr( _attr ) + { + const std::string wrappableBeforeChars = "[({<\t"; + const std::string wrappableAfterChars = "])}>-,./|\\"; + const std::string wrappableInsteadOfChars = " \n\r"; + std::string indent = _attr.initialIndent != std::string::npos + ? std::string( _attr.initialIndent, ' ' ) + : std::string( _attr.indent, ' ' ); + + typedef std::string::const_iterator iterator; + iterator it = _str.begin(); + const iterator strEnd = _str.end(); + + while( it != strEnd ) { + + if( lines.size() >= 1000 ) { + lines.push_back( "... message truncated due to excessive size" ); + return; + } + + std::string suffix; + std::size_t width = (std::min)( static_cast( strEnd-it ), _attr.width-static_cast( indent.size() ) ); + iterator itEnd = it+width; + iterator itNext = _str.end(); + + iterator itNewLine = std::find( it, itEnd, '\n' ); + if( itNewLine != itEnd ) + itEnd = itNewLine; + + if( itEnd != strEnd ) { + bool foundWrapPoint = false; + iterator findIt = itEnd; + do { + if( wrappableAfterChars.find( *findIt ) != std::string::npos && findIt != itEnd ) { + itEnd = findIt+1; + itNext = findIt+1; + foundWrapPoint = true; + } + else if( findIt > it && wrappableBeforeChars.find( *findIt ) != std::string::npos ) { + itEnd = findIt; + itNext = findIt; + foundWrapPoint = true; + } + else if( wrappableInsteadOfChars.find( *findIt ) != std::string::npos ) { + itNext = findIt+1; + itEnd = findIt; + foundWrapPoint = true; + } + if( findIt == it ) + break; + else + --findIt; + } + while( !foundWrapPoint ); + + if( !foundWrapPoint ) { + // No good wrap char, so we'll break mid word and add a hyphen + --itEnd; + itNext = itEnd; + suffix = "-"; + } + else { + while( itEnd > it && wrappableInsteadOfChars.find( *(itEnd-1) ) != std::string::npos ) + --itEnd; + } + } + lines.push_back( indent + std::string( it, itEnd ) + suffix ); + + if( indent.size() != _attr.indent ) + indent = std::string( _attr.indent, ' ' ); + it = itNext; + } + } + + typedef std::vector::const_iterator const_iterator; + + const_iterator begin() const { return lines.begin(); } + const_iterator end() const { return lines.end(); } + std::string const& last() const { return lines.back(); } + std::size_t size() const { return lines.size(); } + std::string const& operator[]( std::size_t _index ) const { return lines[_index]; } + std::string toString() const { + std::ostringstream oss; + oss << *this; + return oss.str(); + } + + inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) { + for( Text::const_iterator it = _text.begin(), itEnd = _text.end(); + it != itEnd; ++it ) { + if( it != _text.begin() ) + _stream << "\n"; + _stream << *it; + } + return _stream; + } + + private: + std::string str; + TextAttributes attr; + std::vector lines; + }; + +} // end namespace Tbc + +#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE +} // end outer namespace +#endif + +#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED +#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE + +namespace Catch { + using Tbc::Text; + using Tbc::TextAttributes; +} + +// #included from: catch_console_colour.hpp +#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED + +namespace Catch { + + struct Colour { + enum Code { + None = 0, + + White, + Red, + Green, + Blue, + Cyan, + Yellow, + Grey, + + Bright = 0x10, + + BrightRed = Bright | Red, + BrightGreen = Bright | Green, + LightGrey = Bright | Grey, + BrightWhite = Bright | White, + + // By intention + FileName = LightGrey, + Warning = Yellow, + ResultError = BrightRed, + ResultSuccess = BrightGreen, + ResultExpectedFailure = Warning, + + Error = BrightRed, + Success = Green, + + OriginalExpression = Cyan, + ReconstructedExpression = Yellow, + + SecondaryText = LightGrey, + Headers = White + }; + + // Use constructed object for RAII guard + Colour( Code _colourCode ); + Colour( Colour const& other ); + ~Colour(); + + // Use static method for one-shot changes + static void use( Code _colourCode ); + + private: + bool m_moved; + }; + + inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; } + +} // end namespace Catch + +// #included from: catch_interfaces_reporter.h +#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED + +#include +#include +#include + +namespace Catch +{ + struct ReporterConfig { + explicit ReporterConfig( Ptr const& _fullConfig ) + : m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {} + + ReporterConfig( Ptr const& _fullConfig, std::ostream& _stream ) + : m_stream( &_stream ), m_fullConfig( _fullConfig ) {} + + std::ostream& stream() const { return *m_stream; } + Ptr fullConfig() const { return m_fullConfig; } + + private: + std::ostream* m_stream; + Ptr m_fullConfig; + }; + + struct ReporterPreferences { + ReporterPreferences() + : shouldRedirectStdOut( false ) + {} + + bool shouldRedirectStdOut; + }; + + template + struct LazyStat : Option { + LazyStat() : used( false ) {} + LazyStat& operator=( T const& _value ) { + Option::operator=( _value ); + used = false; + return *this; + } + void reset() { + Option::reset(); + used = false; + } + bool used; + }; + + struct TestRunInfo { + TestRunInfo( std::string const& _name ) : name( _name ) {} + std::string name; + }; + struct GroupInfo { + GroupInfo( std::string const& _name, + std::size_t _groupIndex, + std::size_t _groupsCount ) + : name( _name ), + groupIndex( _groupIndex ), + groupsCounts( _groupsCount ) + {} + + std::string name; + std::size_t groupIndex; + std::size_t groupsCounts; + }; + + struct AssertionStats { + AssertionStats( AssertionResult const& _assertionResult, + std::vector const& _infoMessages, + Totals const& _totals ) + : assertionResult( _assertionResult ), + infoMessages( _infoMessages ), + totals( _totals ) + { + if( assertionResult.hasMessage() ) { + // Copy message into messages list. + // !TBD This should have been done earlier, somewhere + MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() ); + builder << assertionResult.getMessage(); + builder.m_info.message = builder.m_stream.str(); + + infoMessages.push_back( builder.m_info ); + } + } + virtual ~AssertionStats(); + +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + AssertionStats( AssertionStats const& ) = default; + AssertionStats( AssertionStats && ) = default; + AssertionStats& operator = ( AssertionStats const& ) = default; + AssertionStats& operator = ( AssertionStats && ) = default; +# endif + + AssertionResult assertionResult; + std::vector infoMessages; + Totals totals; + }; + + struct SectionStats { + SectionStats( SectionInfo const& _sectionInfo, + Counts const& _assertions, + double _durationInSeconds, + bool _missingAssertions ) + : sectionInfo( _sectionInfo ), + assertions( _assertions ), + durationInSeconds( _durationInSeconds ), + missingAssertions( _missingAssertions ) + {} + virtual ~SectionStats(); +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + SectionStats( SectionStats const& ) = default; + SectionStats( SectionStats && ) = default; + SectionStats& operator = ( SectionStats const& ) = default; + SectionStats& operator = ( SectionStats && ) = default; +# endif + + SectionInfo sectionInfo; + Counts assertions; + double durationInSeconds; + bool missingAssertions; + }; + + struct TestCaseStats { + TestCaseStats( TestCaseInfo const& _testInfo, + Totals const& _totals, + std::string const& _stdOut, + std::string const& _stdErr, + bool _aborting ) + : testInfo( _testInfo ), + totals( _totals ), + stdOut( _stdOut ), + stdErr( _stdErr ), + aborting( _aborting ) + {} + virtual ~TestCaseStats(); + +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + TestCaseStats( TestCaseStats const& ) = default; + TestCaseStats( TestCaseStats && ) = default; + TestCaseStats& operator = ( TestCaseStats const& ) = default; + TestCaseStats& operator = ( TestCaseStats && ) = default; +# endif + + TestCaseInfo testInfo; + Totals totals; + std::string stdOut; + std::string stdErr; + bool aborting; + }; + + struct TestGroupStats { + TestGroupStats( GroupInfo const& _groupInfo, + Totals const& _totals, + bool _aborting ) + : groupInfo( _groupInfo ), + totals( _totals ), + aborting( _aborting ) + {} + TestGroupStats( GroupInfo const& _groupInfo ) + : groupInfo( _groupInfo ), + aborting( false ) + {} + virtual ~TestGroupStats(); + +# ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS + TestGroupStats( TestGroupStats const& ) = default; + TestGroupStats( TestGroupStats && ) = default; + TestGroupStats& operator = ( TestGroupStats const& ) = default; + TestGroupStats& operator = ( TestGroupStats && ) = default; +# endif + + GroupInfo groupInfo; + Totals totals; + bool aborting; + }; + + struct TestRunStats { + TestRunStats( TestRunInfo const& _runInfo, + Totals const& _totals, + bool _aborting ) + : runInfo( _runInfo ), + totals( _totals ), + aborting( _aborting ) + {} + virtual ~TestRunStats(); + +# ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS + TestRunStats( TestRunStats const& _other ) + : runInfo( _other.runInfo ), + totals( _other.totals ), + aborting( _other.aborting ) + {} +# else + TestRunStats( TestRunStats const& ) = default; + TestRunStats( TestRunStats && ) = default; + TestRunStats& operator = ( TestRunStats const& ) = default; + TestRunStats& operator = ( TestRunStats && ) = default; +# endif + + TestRunInfo runInfo; + Totals totals; + bool aborting; + }; + + class MultipleReporters; + + struct IStreamingReporter : IShared { + virtual ~IStreamingReporter(); + + // Implementing class must also provide the following static method: + // static std::string getDescription(); + + virtual ReporterPreferences getPreferences() const = 0; + + virtual void noMatchingTestCases( std::string const& spec ) = 0; + + virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0; + virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0; + + virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0; + virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0; + + virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0; + + // The return value indicates if the messages buffer should be cleared: + virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0; + + virtual void sectionEnded( SectionStats const& sectionStats ) = 0; + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0; + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0; + virtual void testRunEnded( TestRunStats const& testRunStats ) = 0; + + virtual void skipTest( TestCaseInfo const& testInfo ) = 0; + + virtual MultipleReporters* tryAsMulti() { return CATCH_NULL; } + }; + + struct IReporterFactory : IShared { + virtual ~IReporterFactory(); + virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0; + virtual std::string getDescription() const = 0; + }; + + struct IReporterRegistry { + typedef std::map > FactoryMap; + typedef std::vector > Listeners; + + virtual ~IReporterRegistry(); + virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const = 0; + virtual FactoryMap const& getFactories() const = 0; + virtual Listeners const& getListeners() const = 0; + }; + + Ptr addReporter( Ptr const& existingReporter, Ptr const& additionalReporter ); + +} + +#include +#include + +namespace Catch { + + inline std::size_t listTests( Config const& config ) { + + TestSpec testSpec = config.testSpec(); + if( config.testSpec().hasFilters() ) + Catch::cout() << "Matching test cases:\n"; + else { + Catch::cout() << "All available test cases:\n"; + testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); + } + + std::size_t matchedTests = 0; + TextAttributes nameAttr, descAttr, tagsAttr; + nameAttr.setInitialIndent( 2 ).setIndent( 4 ); + descAttr.setIndent( 4 ); + tagsAttr.setIndent( 6 ); + + std::vector matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config ); + for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); + it != itEnd; + ++it ) { + matchedTests++; + TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); + Colour::Code colour = testCaseInfo.isHidden() + ? Colour::SecondaryText + : Colour::None; + Colour colourGuard( colour ); + + Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl; + if( config.listExtraInfo() ) { + Catch::cout() << " " << testCaseInfo.lineInfo << std::endl; + std::string description = testCaseInfo.description; + if( description.empty() ) + description = "(NO DESCRIPTION)"; + Catch::cout() << Text( description, descAttr ) << std::endl; + } + if( !testCaseInfo.tags.empty() ) + Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl; + } + + if( !config.testSpec().hasFilters() ) + Catch::cout() << pluralise( matchedTests, "test case" ) << '\n' << std::endl; + else + Catch::cout() << pluralise( matchedTests, "matching test case" ) << '\n' << std::endl; + return matchedTests; + } + + inline std::size_t listTestsNamesOnly( Config const& config ) { + TestSpec testSpec = config.testSpec(); + if( !config.testSpec().hasFilters() ) + testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); + std::size_t matchedTests = 0; + std::vector matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config ); + for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); + it != itEnd; + ++it ) { + matchedTests++; + TestCaseInfo const& testCaseInfo = it->getTestCaseInfo(); + if( startsWith( testCaseInfo.name, '#' ) ) + Catch::cout() << '"' << testCaseInfo.name << '"'; + else + Catch::cout() << testCaseInfo.name; + if ( config.listExtraInfo() ) + Catch::cout() << "\t@" << testCaseInfo.lineInfo; + Catch::cout() << std::endl; + } + return matchedTests; + } + + struct TagInfo { + TagInfo() : count ( 0 ) {} + void add( std::string const& spelling ) { + ++count; + spellings.insert( spelling ); + } + std::string all() const { + std::string out; + for( std::set::const_iterator it = spellings.begin(), itEnd = spellings.end(); + it != itEnd; + ++it ) + out += "[" + *it + "]"; + return out; + } + std::set spellings; + std::size_t count; + }; + + inline std::size_t listTags( Config const& config ) { + TestSpec testSpec = config.testSpec(); + if( config.testSpec().hasFilters() ) + Catch::cout() << "Tags for matching test cases:\n"; + else { + Catch::cout() << "All available tags:\n"; + testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec(); + } + + std::map tagCounts; + + std::vector matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config ); + for( std::vector::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end(); + it != itEnd; + ++it ) { + for( std::set::const_iterator tagIt = it->getTestCaseInfo().tags.begin(), + tagItEnd = it->getTestCaseInfo().tags.end(); + tagIt != tagItEnd; + ++tagIt ) { + std::string tagName = *tagIt; + std::string lcaseTagName = toLower( tagName ); + std::map::iterator countIt = tagCounts.find( lcaseTagName ); + if( countIt == tagCounts.end() ) + countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first; + countIt->second.add( tagName ); + } + } + + for( std::map::const_iterator countIt = tagCounts.begin(), + countItEnd = tagCounts.end(); + countIt != countItEnd; + ++countIt ) { + std::ostringstream oss; + oss << " " << std::setw(2) << countIt->second.count << " "; + Text wrapper( countIt->second.all(), TextAttributes() + .setInitialIndent( 0 ) + .setIndent( oss.str().size() ) + .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) ); + Catch::cout() << oss.str() << wrapper << '\n'; + } + Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl; + return tagCounts.size(); + } + + inline std::size_t listReporters( Config const& /*config*/ ) { + Catch::cout() << "Available reporters:\n"; + IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories(); + IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it; + std::size_t maxNameLen = 0; + for(it = itBegin; it != itEnd; ++it ) + maxNameLen = (std::max)( maxNameLen, it->first.size() ); + + for(it = itBegin; it != itEnd; ++it ) { + Text wrapper( it->second->getDescription(), TextAttributes() + .setInitialIndent( 0 ) + .setIndent( 7+maxNameLen ) + .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) ); + Catch::cout() << " " + << it->first + << ':' + << std::string( maxNameLen - it->first.size() + 2, ' ' ) + << wrapper << '\n'; + } + Catch::cout() << std::endl; + return factories.size(); + } + + inline Option list( Config const& config ) { + Option listedCount; + if( config.listTests() || ( config.listExtraInfo() && !config.listTestNamesOnly() ) ) + 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( config ); + return listedCount; + } + +} // end namespace Catch + +// #included from: internal/catch_run_context.hpp +#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED + +// #included from: catch_test_case_tracker.hpp +#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED + +#include +#include +#include +#include +#include + +CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS + +namespace Catch { +namespace TestCaseTracking { + + struct NameAndLocation { + std::string name; + SourceLineInfo location; + + NameAndLocation( std::string const& _name, SourceLineInfo const& _location ) + : name( _name ), + location( _location ) + {} + }; + + struct ITracker : SharedImpl<> { + virtual ~ITracker(); + + // static queries + virtual NameAndLocation const& nameAndLocation() const = 0; + + // dynamic queries + virtual bool isComplete() const = 0; // Successfully completed or failed + virtual bool isSuccessfullyCompleted() const = 0; + virtual bool isOpen() const = 0; // Started but not complete + virtual bool hasChildren() const = 0; + + virtual ITracker& parent() = 0; + + // actions + virtual void close() = 0; // Successfully complete + virtual void fail() = 0; + virtual void markAsNeedingAnotherRun() = 0; + + virtual void addChild( Ptr const& child ) = 0; + virtual ITracker* findChild( NameAndLocation const& nameAndLocation ) = 0; + virtual void openChild() = 0; + + // Debug/ checking + virtual bool isSectionTracker() const = 0; + virtual bool isIndexTracker() const = 0; + }; + + class TrackerContext { + + enum RunState { + NotStarted, + Executing, + CompletedCycle + }; + + Ptr m_rootTracker; + ITracker* m_currentTracker; + RunState m_runState; + + public: + + static TrackerContext& instance() { + static TrackerContext s_instance; + return s_instance; + } + + TrackerContext() + : m_currentTracker( CATCH_NULL ), + m_runState( NotStarted ) + {} + + ITracker& startRun(); + + void endRun() { + m_rootTracker.reset(); + m_currentTracker = CATCH_NULL; + m_runState = NotStarted; + } + + void startCycle() { + m_currentTracker = m_rootTracker.get(); + m_runState = Executing; + } + void completeCycle() { + m_runState = CompletedCycle; + } + + bool completedCycle() const { + return m_runState == CompletedCycle; + } + ITracker& currentTracker() { + return *m_currentTracker; + } + void setCurrentTracker( ITracker* tracker ) { + m_currentTracker = tracker; + } + }; + + class TrackerBase : public ITracker { + protected: + enum CycleState { + NotStarted, + Executing, + ExecutingChildren, + NeedsAnotherRun, + CompletedSuccessfully, + Failed + }; + class TrackerHasName { + NameAndLocation m_nameAndLocation; + public: + TrackerHasName( NameAndLocation const& nameAndLocation ) : m_nameAndLocation( nameAndLocation ) {} + bool operator ()( Ptr const& tracker ) { + return + tracker->nameAndLocation().name == m_nameAndLocation.name && + tracker->nameAndLocation().location == m_nameAndLocation.location; + } + }; + typedef std::vector > Children; + NameAndLocation m_nameAndLocation; + TrackerContext& m_ctx; + ITracker* m_parent; + Children m_children; + CycleState m_runState; + public: + TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent ) + : m_nameAndLocation( nameAndLocation ), + m_ctx( ctx ), + m_parent( parent ), + m_runState( NotStarted ) + {} + virtual ~TrackerBase(); + + virtual NameAndLocation const& nameAndLocation() const CATCH_OVERRIDE { + return m_nameAndLocation; + } + virtual bool isComplete() const CATCH_OVERRIDE { + return m_runState == CompletedSuccessfully || m_runState == Failed; + } + virtual bool isSuccessfullyCompleted() const CATCH_OVERRIDE { + return m_runState == CompletedSuccessfully; + } + virtual bool isOpen() const CATCH_OVERRIDE { + return m_runState != NotStarted && !isComplete(); + } + virtual bool hasChildren() const CATCH_OVERRIDE { + return !m_children.empty(); + } + + virtual void addChild( Ptr const& child ) CATCH_OVERRIDE { + m_children.push_back( child ); + } + + virtual ITracker* findChild( NameAndLocation const& nameAndLocation ) CATCH_OVERRIDE { + Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( nameAndLocation ) ); + return( it != m_children.end() ) + ? it->get() + : CATCH_NULL; + } + virtual ITracker& parent() CATCH_OVERRIDE { + assert( m_parent ); // Should always be non-null except for root + return *m_parent; + } + + virtual void openChild() CATCH_OVERRIDE { + if( m_runState != ExecutingChildren ) { + m_runState = ExecutingChildren; + if( m_parent ) + m_parent->openChild(); + } + } + + virtual bool isSectionTracker() const CATCH_OVERRIDE { return false; } + virtual bool isIndexTracker() const CATCH_OVERRIDE { return false; } + + void open() { + m_runState = Executing; + moveToThis(); + if( m_parent ) + m_parent->openChild(); + } + + virtual void close() CATCH_OVERRIDE { + + // Close any still open children (e.g. generators) + while( &m_ctx.currentTracker() != this ) + m_ctx.currentTracker().close(); + + switch( m_runState ) { + case NotStarted: + case CompletedSuccessfully: + case Failed: + throw std::logic_error( "Illogical state" ); + + case NeedsAnotherRun: + break;; + + case Executing: + m_runState = CompletedSuccessfully; + break; + case ExecutingChildren: + if( m_children.empty() || m_children.back()->isComplete() ) + m_runState = CompletedSuccessfully; + break; + + default: + throw std::logic_error( "Unexpected state" ); + } + moveToParent(); + m_ctx.completeCycle(); + } + virtual void fail() CATCH_OVERRIDE { + m_runState = Failed; + if( m_parent ) + m_parent->markAsNeedingAnotherRun(); + moveToParent(); + m_ctx.completeCycle(); + } + virtual void markAsNeedingAnotherRun() CATCH_OVERRIDE { + m_runState = NeedsAnotherRun; + } + private: + void moveToParent() { + assert( m_parent ); + m_ctx.setCurrentTracker( m_parent ); + } + void moveToThis() { + m_ctx.setCurrentTracker( this ); + } + }; + + class SectionTracker : public TrackerBase { + std::vector m_filters; + public: + SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent ) + : TrackerBase( nameAndLocation, ctx, parent ) + { + if( parent ) { + while( !parent->isSectionTracker() ) + parent = &parent->parent(); + + SectionTracker& parentSection = static_cast( *parent ); + addNextFilters( parentSection.m_filters ); + } + } + virtual ~SectionTracker(); + + virtual bool isSectionTracker() const CATCH_OVERRIDE { return true; } + + static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) { + SectionTracker* section = CATCH_NULL; + + ITracker& currentTracker = ctx.currentTracker(); + if( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) { + assert( childTracker ); + assert( childTracker->isSectionTracker() ); + section = static_cast( childTracker ); + } + else { + section = new SectionTracker( nameAndLocation, ctx, ¤tTracker ); + currentTracker.addChild( section ); + } + if( !ctx.completedCycle() ) + section->tryOpen(); + return *section; + } + + void tryOpen() { + if( !isComplete() && (m_filters.empty() || m_filters[0].empty() || m_filters[0] == m_nameAndLocation.name ) ) + open(); + } + + void addInitialFilters( std::vector const& filters ) { + if( !filters.empty() ) { + m_filters.push_back(""); // Root - should never be consulted + m_filters.push_back(""); // Test Case - not a section filter + m_filters.insert( m_filters.end(), filters.begin(), filters.end() ); + } + } + void addNextFilters( std::vector const& filters ) { + if( filters.size() > 1 ) + m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() ); + } + }; + + class IndexTracker : public TrackerBase { + int m_size; + int m_index; + public: + IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size ) + : TrackerBase( nameAndLocation, ctx, parent ), + m_size( size ), + m_index( -1 ) + {} + virtual ~IndexTracker(); + + virtual bool isIndexTracker() const CATCH_OVERRIDE { return true; } + + static IndexTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size ) { + IndexTracker* tracker = CATCH_NULL; + + ITracker& currentTracker = ctx.currentTracker(); + if( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) { + assert( childTracker ); + assert( childTracker->isIndexTracker() ); + tracker = static_cast( childTracker ); + } + else { + tracker = new IndexTracker( nameAndLocation, ctx, ¤tTracker, size ); + currentTracker.addChild( tracker ); + } + + if( !ctx.completedCycle() && !tracker->isComplete() ) { + if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun ) + tracker->moveNext(); + tracker->open(); + } + + return *tracker; + } + + int index() const { return m_index; } + + void moveNext() { + m_index++; + m_children.clear(); + } + + virtual void close() CATCH_OVERRIDE { + TrackerBase::close(); + if( m_runState == CompletedSuccessfully && m_index < m_size-1 ) + m_runState = Executing; + } + }; + + inline ITracker& TrackerContext::startRun() { + m_rootTracker = new SectionTracker( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, CATCH_NULL ); + m_currentTracker = CATCH_NULL; + m_runState = Executing; + return *m_rootTracker; + } + +} // namespace TestCaseTracking + +using TestCaseTracking::ITracker; +using TestCaseTracking::TrackerContext; +using TestCaseTracking::SectionTracker; +using TestCaseTracking::IndexTracker; + +} // namespace Catch + +CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS + +// #included from: catch_fatal_condition.hpp +#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED + +namespace Catch { + + // Report the error condition + inline void reportFatal( std::string const& message ) { + IContext& context = Catch::getCurrentContext(); + IResultCapture* resultCapture = context.getResultCapture(); + resultCapture->handleFatalErrorCondition( message ); + } + +} // namespace Catch + +#if defined ( CATCH_PLATFORM_WINDOWS ) ///////////////////////////////////////// +// #included from: catch_windows_h_proxy.h + +#define TWOBLUECUBES_CATCH_WINDOWS_H_PROXY_H_INCLUDED + +#ifdef CATCH_DEFINES_NOMINMAX +# define NOMINMAX +#endif +#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +#endif + +#ifdef __AFXDLL +#include +#else +#include +#endif + +#ifdef CATCH_DEFINES_NOMINMAX +# undef NOMINMAX +#endif +#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN +# undef WIN32_LEAN_AND_MEAN +#endif + + +# if !defined ( CATCH_CONFIG_WINDOWS_SEH ) + +namespace Catch { + struct FatalConditionHandler { + void reset() {} + }; +} + +# else // CATCH_CONFIG_WINDOWS_SEH is defined + +namespace Catch { + + struct SignalDefs { DWORD id; const char* name; }; + extern SignalDefs signalDefs[]; + // There is no 1-1 mapping between signals and windows exceptions. + // Windows can easily distinguish between SO and SigSegV, + // but SigInt, SigTerm, etc are handled differently. + SignalDefs signalDefs[] = { + { EXCEPTION_ILLEGAL_INSTRUCTION, "SIGILL - Illegal instruction signal" }, + { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" }, + { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" }, + { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" }, + }; + + struct FatalConditionHandler { + + static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) { + for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) { + if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) { + reportFatal(signalDefs[i].name); + } + } + // If its not an exception we care about, pass it along. + // This stops us from eating debugger breaks etc. + return EXCEPTION_CONTINUE_SEARCH; + } + + FatalConditionHandler() { + isSet = true; + // 32k seems enough for Catch to handle stack overflow, + // but the value was found experimentally, so there is no strong guarantee + guaranteeSize = 32 * 1024; + exceptionHandlerHandle = CATCH_NULL; + // Register as first handler in current chain + exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException); + // Pass in guarantee size to be filled + SetThreadStackGuarantee(&guaranteeSize); + } + + static void reset() { + if (isSet) { + // Unregister handler and restore the old guarantee + RemoveVectoredExceptionHandler(exceptionHandlerHandle); + SetThreadStackGuarantee(&guaranteeSize); + exceptionHandlerHandle = CATCH_NULL; + isSet = false; + } + } + + ~FatalConditionHandler() { + reset(); + } + private: + static bool isSet; + static ULONG guaranteeSize; + static PVOID exceptionHandlerHandle; + }; + + bool FatalConditionHandler::isSet = false; + ULONG FatalConditionHandler::guaranteeSize = 0; + PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL; + +} // namespace Catch + +# endif // CATCH_CONFIG_WINDOWS_SEH + +#else // Not Windows - assumed to be POSIX compatible ////////////////////////// + +# if !defined(CATCH_CONFIG_POSIX_SIGNALS) + +namespace Catch { + struct FatalConditionHandler { + void reset() {} + }; +} + +# else // CATCH_CONFIG_POSIX_SIGNALS is defined + +#include + +namespace Catch { + + struct SignalDefs { + int id; + const char* name; + }; + extern SignalDefs signalDefs[]; + SignalDefs signalDefs[] = { + { SIGINT, "SIGINT - Terminal interrupt signal" }, + { SIGILL, "SIGILL - Illegal instruction signal" }, + { SIGFPE, "SIGFPE - Floating point error signal" }, + { SIGSEGV, "SIGSEGV - Segmentation violation signal" }, + { SIGTERM, "SIGTERM - Termination request signal" }, + { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" } + }; + + struct FatalConditionHandler { + + static bool isSet; + static struct sigaction oldSigActions [sizeof(signalDefs)/sizeof(SignalDefs)]; + static stack_t oldSigStack; + static char altStackMem[SIGSTKSZ]; + + static void handleSignal( int sig ) { + std::string name = ""; + for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) { + SignalDefs &def = signalDefs[i]; + if (sig == def.id) { + name = def.name; + break; + } + } + reset(); + reportFatal(name); + raise( sig ); + } + + FatalConditionHandler() { + isSet = true; + stack_t sigStack; + sigStack.ss_sp = altStackMem; + sigStack.ss_size = SIGSTKSZ; + sigStack.ss_flags = 0; + sigaltstack(&sigStack, &oldSigStack); + struct sigaction sa = { 0 }; + + sa.sa_handler = handleSignal; + sa.sa_flags = SA_ONSTACK; + for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) { + sigaction(signalDefs[i].id, &sa, &oldSigActions[i]); + } + } + + ~FatalConditionHandler() { + reset(); + } + static void reset() { + if( isSet ) { + // Set signals back to previous values -- hopefully nobody overwrote them in the meantime + for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) { + sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL); + } + // Return the old stack + sigaltstack(&oldSigStack, CATCH_NULL); + isSet = false; + } + } + }; + + bool FatalConditionHandler::isSet = false; + struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {}; + stack_t FatalConditionHandler::oldSigStack = {}; + char FatalConditionHandler::altStackMem[SIGSTKSZ] = {}; + +} // namespace Catch + +# endif // CATCH_CONFIG_POSIX_SIGNALS + +#endif // not Windows + +#include +#include + +namespace Catch { + + class StreamRedirect { + + public: + StreamRedirect( std::ostream& stream, std::string& targetString ) + : m_stream( stream ), + m_prevBuf( stream.rdbuf() ), + m_targetString( targetString ) + { + stream.rdbuf( m_oss.rdbuf() ); + } + + ~StreamRedirect() { + m_targetString += m_oss.str(); + m_stream.rdbuf( m_prevBuf ); + } + + private: + std::ostream& m_stream; + std::streambuf* m_prevBuf; + std::ostringstream m_oss; + std::string& m_targetString; + }; + + // StdErr has two constituent streams in C++, std::cerr and std::clog + // This means that we need to redirect 2 streams into 1 to keep proper + // order of writes and cannot use StreamRedirect on its own + class StdErrRedirect { + public: + StdErrRedirect(std::string& targetString) + :m_cerrBuf( cerr().rdbuf() ), m_clogBuf(clog().rdbuf()), + m_targetString(targetString){ + cerr().rdbuf(m_oss.rdbuf()); + clog().rdbuf(m_oss.rdbuf()); + } + ~StdErrRedirect() { + m_targetString += m_oss.str(); + cerr().rdbuf(m_cerrBuf); + clog().rdbuf(m_clogBuf); + } + private: + std::streambuf* m_cerrBuf; + std::streambuf* m_clogBuf; + std::ostringstream m_oss; + std::string& m_targetString; + }; + + /////////////////////////////////////////////////////////////////////////// + + class RunContext : public IResultCapture, public IRunner { + + RunContext( RunContext const& ); + void operator =( RunContext const& ); + + public: + + explicit RunContext( Ptr const& _config, Ptr const& reporter ) + : m_runInfo( _config->name() ), + m_context( getCurrentMutableContext() ), + m_activeTestCase( CATCH_NULL ), + m_config( _config ), + m_reporter( reporter ), + m_shouldReportUnexpected ( true ) + { + m_context.setRunner( this ); + m_context.setConfig( m_config ); + m_context.setResultCapture( this ); + m_reporter->testRunStarting( m_runInfo ); + } + + virtual ~RunContext() { + m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) ); + } + + void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) { + m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) ); + } + void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) { + m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) ); + } + + Totals runTest( TestCase const& testCase ) { + Totals prevTotals = m_totals; + + std::string redirectedCout; + std::string redirectedCerr; + + TestCaseInfo testInfo = testCase.getTestCaseInfo(); + + m_reporter->testCaseStarting( testInfo ); + + m_activeTestCase = &testCase; + + do { + ITracker& rootTracker = m_trackerContext.startRun(); + assert( rootTracker.isSectionTracker() ); + static_cast( rootTracker ).addInitialFilters( m_config->getSectionsToRun() ); + do { + m_trackerContext.startCycle(); + m_testCaseTracker = &SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( testInfo.name, testInfo.lineInfo ) ); + runCurrentTest( redirectedCout, redirectedCerr ); + } + while( !m_testCaseTracker->isSuccessfullyCompleted() && !aborting() ); + } + // !TBD: deprecated - this will be replaced by indexed trackers + while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() ); + + Totals deltaTotals = m_totals.delta( prevTotals ); + if( testInfo.expectedToFail() && deltaTotals.testCases.passed > 0 ) { + deltaTotals.assertions.failed++; + deltaTotals.testCases.passed--; + deltaTotals.testCases.failed++; + } + m_totals.testCases += deltaTotals.testCases; + m_reporter->testCaseEnded( TestCaseStats( testInfo, + deltaTotals, + redirectedCout, + redirectedCerr, + aborting() ) ); + + m_activeTestCase = CATCH_NULL; + m_testCaseTracker = CATCH_NULL; + + return deltaTotals; + } + + Ptr config() const { + return m_config; + } + + private: // IResultCapture + + virtual void assertionEnded( AssertionResult const& result ) { + if( result.getResultType() == ResultWas::Ok ) { + m_totals.assertions.passed++; + } + else if( !result.isOk() ) { + if( m_activeTestCase->getTestCaseInfo().okToFail() ) + m_totals.assertions.failedButOk++; + else + m_totals.assertions.failed++; + } + + // We have no use for the return value (whether messages should be cleared), because messages were made scoped + // and should be let to clear themselves out. + static_cast(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals))); + + // Reset working state + m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition ); + m_lastResult = result; + } + + virtual bool lastAssertionPassed() + { + return m_totals.assertions.passed == (m_prevPassed + 1); + } + + virtual void assertionPassed() + { + m_totals.assertions.passed++; + m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"; + m_lastAssertionInfo.macroName = ""; + } + + virtual void assertionRun() + { + m_prevPassed = m_totals.assertions.passed; + } + + virtual bool sectionStarted ( + SectionInfo const& sectionInfo, + Counts& assertions + ) + { + ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( sectionInfo.name, sectionInfo.lineInfo ) ); + if( !sectionTracker.isOpen() ) + return false; + m_activeSections.push_back( §ionTracker ); + + m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo; + + m_reporter->sectionStarting( sectionInfo ); + + assertions = m_totals.assertions; + + return true; + } + bool testForMissingAssertions( Counts& assertions ) { + if( assertions.total() != 0 ) + return false; + if( !m_config->warnAboutMissingAssertions() ) + return false; + if( m_trackerContext.currentTracker().hasChildren() ) + return false; + m_totals.assertions.failed++; + assertions.failed++; + return true; + } + + virtual void sectionEnded( SectionEndInfo const& endInfo ) { + Counts assertions = m_totals.assertions - endInfo.prevAssertions; + bool missingAssertions = testForMissingAssertions( assertions ); + + if( !m_activeSections.empty() ) { + m_activeSections.back()->close(); + m_activeSections.pop_back(); + } + + m_reporter->sectionEnded( SectionStats( endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions ) ); + m_messages.clear(); + } + + virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) { + if( m_unfinishedSections.empty() ) + m_activeSections.back()->fail(); + else + m_activeSections.back()->close(); + m_activeSections.pop_back(); + + m_unfinishedSections.push_back( endInfo ); + } + + virtual void pushScopedMessage( MessageInfo const& message ) { + m_messages.push_back( message ); + } + + virtual void popScopedMessage( MessageInfo const& message ) { + m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() ); + } + + virtual std::string getCurrentTestName() const { + return m_activeTestCase + ? m_activeTestCase->getTestCaseInfo().name + : std::string(); + } + + virtual const AssertionResult* getLastResult() const { + return &m_lastResult; + } + + virtual void exceptionEarlyReported() { + m_shouldReportUnexpected = false; + } + + virtual void handleFatalErrorCondition( std::string const& message ) { + // Don't rebuild the result -- the stringification itself can cause more fatal errors + // Instead, fake a result data. + AssertionResultData tempResult; + tempResult.resultType = ResultWas::FatalErrorCondition; + tempResult.message = message; + AssertionResult result(m_lastAssertionInfo, tempResult); + + getResultCapture().assertionEnded(result); + + handleUnfinishedSections(); + + // Recreate section for test case (as we will lose the one that was in scope) + TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); + SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description ); + + Counts assertions; + assertions.failed = 1; + SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false ); + m_reporter->sectionEnded( testCaseSectionStats ); + + TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo(); + + Totals deltaTotals; + deltaTotals.testCases.failed = 1; + deltaTotals.assertions.failed = 1; + m_reporter->testCaseEnded( TestCaseStats( testInfo, + deltaTotals, + std::string(), + std::string(), + false ) ); + m_totals.testCases.failed++; + testGroupEnded( std::string(), m_totals, 1, 1 ); + m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) ); + } + + public: + // !TBD We need to do this another way! + bool aborting() const { + return m_totals.assertions.failed == static_cast( m_config->abortAfter() ); + } + + private: + + void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) { + TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo(); + SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description ); + m_reporter->sectionStarting( testCaseSection ); + Counts prevAssertions = m_totals.assertions; + double duration = 0; + m_shouldReportUnexpected = true; + try { + m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal ); + + seedRng( *m_config ); + + Timer timer; + timer.start(); + if( m_reporter->getPreferences().shouldRedirectStdOut ) { + StreamRedirect coutRedir( Catch::cout(), redirectedCout ); + StdErrRedirect errRedir( redirectedCerr ); + invokeActiveTestCase(); + } + else { + invokeActiveTestCase(); + } + duration = timer.getElapsedSeconds(); + } + catch( TestFailureException& ) { + // This just means the test was aborted due to failure + } + catch(...) { + // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions + // are reported without translation at the point of origin. + if (m_shouldReportUnexpected) { + makeUnexpectedResultBuilder().useActiveException(); + } + } + m_testCaseTracker->close(); + handleUnfinishedSections(); + m_messages.clear(); + + Counts assertions = m_totals.assertions - prevAssertions; + bool missingAssertions = testForMissingAssertions( assertions ); + + SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions ); + m_reporter->sectionEnded( testCaseSectionStats ); + } + + void invokeActiveTestCase() { + FatalConditionHandler fatalConditionHandler; // Handle signals + m_activeTestCase->invoke(); + fatalConditionHandler.reset(); + } + + private: + + ResultBuilder makeUnexpectedResultBuilder() const { + return ResultBuilder( m_lastAssertionInfo.macroName, + m_lastAssertionInfo.lineInfo, + m_lastAssertionInfo.capturedExpression, + m_lastAssertionInfo.resultDisposition ); + } + + void handleUnfinishedSections() { + // If sections ended prematurely due to an exception we stored their + // infos here so we can tear them down outside the unwind process. + for( std::vector::const_reverse_iterator it = m_unfinishedSections.rbegin(), + itEnd = m_unfinishedSections.rend(); + it != itEnd; + ++it ) + sectionEnded( *it ); + m_unfinishedSections.clear(); + } + + TestRunInfo m_runInfo; + IMutableContext& m_context; + TestCase const* m_activeTestCase; + ITracker* m_testCaseTracker; + ITracker* m_currentSectionTracker; + AssertionResult m_lastResult; + + Ptr m_config; + Totals m_totals; + Ptr m_reporter; + std::vector m_messages; + AssertionInfo m_lastAssertionInfo; + std::vector m_unfinishedSections; + std::vector m_activeSections; + TrackerContext m_trackerContext; + size_t m_prevPassed; + bool m_shouldReportUnexpected; + }; + + IResultCapture& getResultCapture() { + if( IResultCapture* capture = getCurrentContext().getResultCapture() ) + return *capture; + else + throw std::logic_error( "No result capture instance" ); + } + +} // end namespace Catch + +// #included from: internal/catch_version.h +#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED + +namespace Catch { + + // Versioning information + struct Version { + Version( unsigned int _majorVersion, + unsigned int _minorVersion, + unsigned int _patchNumber, + char const * const _branchName, + unsigned int _buildNumber ); + + unsigned int const majorVersion; + unsigned int const minorVersion; + unsigned int const patchNumber; + + // buildNumber is only used if branchName is not null + char const * const branchName; + unsigned int const buildNumber; + + friend std::ostream& operator << ( std::ostream& os, Version const& version ); + + private: + void operator=( Version const& ); + }; + + inline Version libraryVersion(); +} + +#include +#include +#include + +namespace Catch { + + Ptr createReporter( std::string const& reporterName, Ptr const& config ) { + Ptr reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() ); + if( !reporter ) { + std::ostringstream oss; + oss << "No reporter registered with name: '" << reporterName << "'"; + throw std::domain_error( oss.str() ); + } + return reporter; + } + +#if !defined(CATCH_CONFIG_DEFAULT_REPORTER) +#define CATCH_CONFIG_DEFAULT_REPORTER "console" +#endif + + Ptr makeReporter( Ptr const& config ) { + std::vector reporters = config->getReporterNames(); + if( reporters.empty() ) + reporters.push_back( CATCH_CONFIG_DEFAULT_REPORTER ); + + Ptr reporter; + for( std::vector::const_iterator it = reporters.begin(), itEnd = reporters.end(); + it != itEnd; + ++it ) + reporter = addReporter( reporter, createReporter( *it, config ) ); + return reporter; + } + Ptr addListeners( Ptr const& config, Ptr reporters ) { + IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners(); + for( IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end(); + it != itEnd; + ++it ) + reporters = addReporter(reporters, (*it)->create( ReporterConfig( config ) ) ); + return reporters; + } + + Totals runTests( Ptr const& config ) { + + Ptr iconfig = config.get(); + + Ptr reporter = makeReporter( config ); + reporter = addListeners( iconfig, reporter ); + + RunContext context( iconfig, reporter ); + + Totals totals; + + context.testGroupStarting( config->name(), 1, 1 ); + + TestSpec testSpec = config->testSpec(); + if( !testSpec.hasFilters() ) + testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests + + std::vector const& allTestCases = getAllTestCasesSorted( *iconfig ); + for( std::vector::const_iterator it = allTestCases.begin(), itEnd = allTestCases.end(); + it != itEnd; + ++it ) { + if( !context.aborting() && matchTest( *it, testSpec, *iconfig ) ) + totals += context.runTest( *it ); + else + reporter->skipTest( *it ); + } + + context.testGroupEnded( iconfig->name(), totals, 1, 1 ); + return totals; + } + + void applyFilenamesAsTags( IConfig const& config ) { + std::vector const& tests = getAllTestCasesSorted( config ); + for(std::size_t i = 0; i < tests.size(); ++i ) { + TestCase& test = const_cast( tests[i] ); + std::set tags = test.tags; + + std::string filename = test.lineInfo.file; + std::string::size_type lastSlash = filename.find_last_of( "\\/" ); + if( lastSlash != std::string::npos ) + filename = filename.substr( lastSlash+1 ); + + std::string::size_type lastDot = filename.find_last_of( '.' ); + if( lastDot != std::string::npos ) + filename = filename.substr( 0, lastDot ); + + tags.insert( '#' + filename ); + setTags( test, tags ); + } + } + + class Session : NonCopyable { + static bool alreadyInstantiated; + + public: + + struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; }; + + Session() + : m_cli( makeCommandLineParser() ) { + if( alreadyInstantiated ) { + std::string msg = "Only one instance of Catch::Session can ever be used"; + Catch::cerr() << msg << std::endl; + throw std::logic_error( msg ); + } + alreadyInstantiated = true; + } + ~Session() { + Catch::cleanUp(); + } + + void showHelp( std::string const& processName ) { + Catch::cout() << "\nCatch v" << libraryVersion() << "\n"; + + m_cli.usage( Catch::cout(), processName ); + Catch::cout() << "For more detail usage please see the project docs\n" << std::endl; + } + void libIdentify() { + Catch::cout() + << std::left << std::setw(16) << "description: " << "A Catch test executable\n" + << std::left << std::setw(16) << "category: " << "testframework\n" + << std::left << std::setw(16) << "framework: " << "Catch Test\n" + << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl; + } + + int applyCommandLine( int argc, char const* const* const argv, OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) { + try { + m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail ); + m_unusedTokens = m_cli.parseInto( Clara::argsToVector( argc, argv ), m_configData ); + if( m_configData.showHelp ) + showHelp( m_configData.processName ); + if( m_configData.libIdentify ) + libIdentify(); + m_config.reset(); + } + catch( std::exception& ex ) { + { + Colour colourGuard( Colour::Red ); + Catch::cerr() + << "\nError(s) in input:\n" + << Text( ex.what(), TextAttributes().setIndent(2) ) + << "\n\n"; + } + m_cli.usage( Catch::cout(), m_configData.processName ); + return (std::numeric_limits::max)(); + } + return 0; + } + + void useConfigData( ConfigData const& _configData ) { + m_configData = _configData; + m_config.reset(); + } + + int run( int argc, char const* const* const argv ) { + + int returnCode = applyCommandLine( argc, argv ); + if( returnCode == 0 ) + returnCode = run(); + return returnCode; + } + + #if defined(WIN32) && defined(UNICODE) + int run( int argc, wchar_t const* const* const argv ) { + + char **utf8Argv = new char *[ argc ]; + + for ( int i = 0; i < argc; ++i ) { + int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL ); + + utf8Argv[ i ] = new char[ bufSize ]; + + WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL ); + } + + int returnCode = applyCommandLine( argc, utf8Argv ); + if( returnCode == 0 ) + returnCode = run(); + + for ( int i = 0; i < argc; ++i ) + delete [] utf8Argv[ i ]; + + delete [] utf8Argv; + + return returnCode; + } + #endif + + int run() { + if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) { + Catch::cout() << "...waiting for enter/ return before starting" << std::endl; + static_cast(std::getchar()); + } + int exitCode = runInternal(); + if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) { + Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl; + static_cast(std::getchar()); + } + return exitCode; + } + + Clara::CommandLine const& cli() const { + return m_cli; + } + std::vector const& unusedTokens() const { + return m_unusedTokens; + } + ConfigData& configData() { + return m_configData; + } + Config& config() { + if( !m_config ) + m_config = new Config( m_configData ); + return *m_config; + } + private: + + int runInternal() { + if( m_configData.showHelp || m_configData.libIdentify ) + return 0; + + try + { + config(); // Force config to be constructed + + seedRng( *m_config ); + + if( m_configData.filenamesAsTags ) + applyFilenamesAsTags( *m_config ); + + // Handle list request + if( Option listed = list( config() ) ) + return static_cast( *listed ); + + return static_cast( runTests( m_config ).assertions.failed ); + } + catch( std::exception& ex ) { + Catch::cerr() << ex.what() << std::endl; + return (std::numeric_limits::max)(); + } + } + + Clara::CommandLine m_cli; + std::vector m_unusedTokens; + ConfigData m_configData; + Ptr m_config; + }; + + bool Session::alreadyInstantiated = false; + +} // end namespace Catch + +// #included from: catch_registry_hub.hpp +#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED + +// #included from: catch_test_case_registry_impl.hpp +#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + + struct RandomNumberGenerator { + typedef unsigned int result_type; + + result_type operator()( result_type n ) const { return std::rand() % n; } + +#ifdef CATCH_CONFIG_CPP11_SHUFFLE + static constexpr result_type min() { return 0; } + static constexpr result_type max() { return 1000000; } + result_type operator()() const { return std::rand() % max(); } +#endif + template + static void shuffle( V& vector ) { + RandomNumberGenerator rng; +#ifdef CATCH_CONFIG_CPP11_SHUFFLE + std::shuffle( vector.begin(), vector.end(), rng ); +#else + std::random_shuffle( vector.begin(), vector.end(), rng ); +#endif + } + }; + + inline std::vector sortTests( IConfig const& config, std::vector const& unsortedTestCases ) { + + std::vector sorted = unsortedTestCases; + + switch( config.runOrder() ) { + case RunTests::InLexicographicalOrder: + std::sort( sorted.begin(), sorted.end() ); + break; + case RunTests::InRandomOrder: + { + seedRng( config ); + RandomNumberGenerator::shuffle( sorted ); + } + break; + case RunTests::InDeclarationOrder: + // already in declaration order + break; + } + return sorted; + } + bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) { + return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() ); + } + + void enforceNoDuplicateTestCases( std::vector const& functions ) { + std::set seenFunctions; + for( std::vector::const_iterator it = functions.begin(), itEnd = functions.end(); + it != itEnd; + ++it ) { + std::pair::const_iterator, bool> prev = seenFunctions.insert( *it ); + if( !prev.second ) { + std::ostringstream ss; + + ss << Colour( Colour::Red ) + << "error: TEST_CASE( \"" << it->name << "\" ) already defined.\n" + << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << '\n' + << "\tRedefined at " << it->getTestCaseInfo().lineInfo << std::endl; + + throw std::runtime_error(ss.str()); + } + } + } + + std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config ) { + std::vector filtered; + filtered.reserve( testCases.size() ); + for( std::vector::const_iterator it = testCases.begin(), itEnd = testCases.end(); + it != itEnd; + ++it ) + if( matchTest( *it, testSpec, config ) ) + filtered.push_back( *it ); + return filtered; + } + std::vector const& getAllTestCasesSorted( IConfig const& config ) { + return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config ); + } + + class TestRegistry : public ITestCaseRegistry { + public: + TestRegistry() + : m_currentSortOrder( RunTests::InDeclarationOrder ), + m_unnamedCount( 0 ) + {} + virtual ~TestRegistry(); + + virtual void registerTest( TestCase const& testCase ) { + std::string name = testCase.getTestCaseInfo().name; + if( name.empty() ) { + std::ostringstream oss; + oss << "Anonymous test case " << ++m_unnamedCount; + return registerTest( testCase.withName( oss.str() ) ); + } + m_functions.push_back( testCase ); + } + + virtual std::vector const& getAllTests() const { + return m_functions; + } + virtual std::vector const& getAllTestsSorted( IConfig const& config ) const { + if( m_sortedFunctions.empty() ) + enforceNoDuplicateTestCases( m_functions ); + + if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) { + m_sortedFunctions = sortTests( config, m_functions ); + m_currentSortOrder = config.runOrder(); + } + return m_sortedFunctions; + } + + private: + std::vector m_functions; + mutable RunTests::InWhatOrder m_currentSortOrder; + mutable std::vector m_sortedFunctions; + size_t m_unnamedCount; + std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised + }; + + /////////////////////////////////////////////////////////////////////////// + + class FreeFunctionTestCase : public SharedImpl { + public: + + FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {} + + virtual void invoke() const { + m_fun(); + } + + private: + virtual ~FreeFunctionTestCase(); + + TestFunction m_fun; + }; + + inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) { + 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; + } + + void registerTestCase + ( ITestCase* testCase, + char const* classOrQualifiedMethodName, + NameAndDesc const& nameAndDesc, + SourceLineInfo const& lineInfo ) { + + getMutableRegistryHub().registerTest + ( makeTestCase + ( testCase, + extractClassName( classOrQualifiedMethodName ), + nameAndDesc.name, + nameAndDesc.description, + lineInfo ) ); + } + void registerTestCaseFunction + ( TestFunction function, + SourceLineInfo const& lineInfo, + NameAndDesc const& nameAndDesc ) { + registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo ); + } + + /////////////////////////////////////////////////////////////////////////// + + AutoReg::AutoReg + ( TestFunction function, + SourceLineInfo const& lineInfo, + NameAndDesc const& nameAndDesc ) { + registerTestCaseFunction( function, lineInfo, nameAndDesc ); + } + + AutoReg::~AutoReg() {} + +} // end namespace Catch + +// #included from: catch_reporter_registry.hpp +#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED + +#include + +namespace Catch { + + class ReporterRegistry : public IReporterRegistry { + + public: + + virtual ~ReporterRegistry() CATCH_OVERRIDE {} + + virtual IStreamingReporter* create( std::string const& name, Ptr const& config ) const CATCH_OVERRIDE { + FactoryMap::const_iterator it = m_factories.find( name ); + if( it == m_factories.end() ) + return CATCH_NULL; + return it->second->create( ReporterConfig( config ) ); + } + + void registerReporter( std::string const& name, Ptr const& factory ) { + m_factories.insert( std::make_pair( name, factory ) ); + } + void registerListener( Ptr const& factory ) { + m_listeners.push_back( factory ); + } + + virtual FactoryMap const& getFactories() const CATCH_OVERRIDE { + return m_factories; + } + virtual Listeners const& getListeners() const CATCH_OVERRIDE { + return m_listeners; + } + + private: + FactoryMap m_factories; + Listeners m_listeners; + }; +} + +// #included from: catch_exception_translator_registry.hpp +#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED + +#ifdef __OBJC__ +#import "Foundation/Foundation.h" +#endif + +namespace Catch { + + class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry { + public: + ~ExceptionTranslatorRegistry() { + deleteAll( m_translators ); + } + + virtual void registerTranslator( const IExceptionTranslator* translator ) { + m_translators.push_back( translator ); + } + + virtual std::string translateActiveException() const { + try { +#ifdef __OBJC__ + // In Objective-C try objective-c exceptions first + @try { + return tryTranslators(); + } + @catch (NSException *exception) { + return Catch::toString( [exception description] ); + } +#else + return tryTranslators(); +#endif + } + catch( TestFailureException& ) { + throw; + } + catch( std::exception& ex ) { + return ex.what(); + } + catch( std::string& msg ) { + return msg; + } + catch( const char* msg ) { + return msg; + } + catch(...) { + return "Unknown exception"; + } + } + + std::string tryTranslators() const { + if( m_translators.empty() ) + throw; + else + return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() ); + } + + private: + std::vector m_translators; + }; +} + +// #included from: catch_tag_alias_registry.h +#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED + +#include + +namespace Catch { + + class TagAliasRegistry : public ITagAliasRegistry { + public: + virtual ~TagAliasRegistry(); + virtual Option find( std::string const& alias ) const; + virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const; + void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ); + + private: + std::map m_registry; + }; + +} // end namespace Catch + +namespace Catch { + + namespace { + + class RegistryHub : public IRegistryHub, public IMutableRegistryHub { + + RegistryHub( RegistryHub const& ); + void operator=( RegistryHub const& ); + + public: // IRegistryHub + RegistryHub() { + } + virtual IReporterRegistry const& getReporterRegistry() const CATCH_OVERRIDE { + return m_reporterRegistry; + } + virtual ITestCaseRegistry const& getTestCaseRegistry() const CATCH_OVERRIDE { + return m_testCaseRegistry; + } + virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() CATCH_OVERRIDE { + return m_exceptionTranslatorRegistry; + } + virtual ITagAliasRegistry const& getTagAliasRegistry() const CATCH_OVERRIDE { + return m_tagAliasRegistry; + } + + public: // IMutableRegistryHub + virtual void registerReporter( std::string const& name, Ptr const& factory ) CATCH_OVERRIDE { + m_reporterRegistry.registerReporter( name, factory ); + } + virtual void registerListener( Ptr const& factory ) CATCH_OVERRIDE { + m_reporterRegistry.registerListener( factory ); + } + virtual void registerTest( TestCase const& testInfo ) CATCH_OVERRIDE { + m_testCaseRegistry.registerTest( testInfo ); + } + virtual void registerTranslator( const IExceptionTranslator* translator ) CATCH_OVERRIDE { + m_exceptionTranslatorRegistry.registerTranslator( translator ); + } + virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) CATCH_OVERRIDE { + m_tagAliasRegistry.add( alias, tag, lineInfo ); + } + + private: + TestRegistry m_testCaseRegistry; + ReporterRegistry m_reporterRegistry; + ExceptionTranslatorRegistry m_exceptionTranslatorRegistry; + TagAliasRegistry m_tagAliasRegistry; + }; + + // Single, global, instance + inline RegistryHub*& getTheRegistryHub() { + static RegistryHub* theRegistryHub = CATCH_NULL; + if( !theRegistryHub ) + theRegistryHub = new RegistryHub(); + return theRegistryHub; + } + } + + IRegistryHub& getRegistryHub() { + return *getTheRegistryHub(); + } + IMutableRegistryHub& getMutableRegistryHub() { + return *getTheRegistryHub(); + } + void cleanUp() { + delete getTheRegistryHub(); + getTheRegistryHub() = CATCH_NULL; + cleanUpContext(); + } + std::string translateActiveException() { + return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException(); + } + +} // end namespace Catch + +// #included from: catch_notimplemented_exception.hpp +#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED + +#include + +namespace Catch { + + NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo ) + : m_lineInfo( lineInfo ) { + std::ostringstream oss; + oss << lineInfo << ": function "; + oss << "not implemented"; + m_what = oss.str(); + } + + const char* NotImplementedException::what() const CATCH_NOEXCEPT { + return m_what.c_str(); + } + +} // end namespace Catch + +// #included from: catch_context_impl.hpp +#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED + +// #included from: catch_stream.hpp +#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED + +#include +#include +#include + +namespace Catch { + + template + class StreamBufImpl : public StreamBufBase { + char data[bufferSize]; + WriterF m_writer; + + public: + StreamBufImpl() { + setp( data, data + sizeof(data) ); + } + + ~StreamBufImpl() CATCH_NOEXCEPT { + sync(); + } + + private: + int overflow( int c ) { + sync(); + + if( c != EOF ) { + if( pbase() == epptr() ) + m_writer( std::string( 1, static_cast( c ) ) ); + else + sputc( static_cast( c ) ); + } + return 0; + } + + int sync() { + if( pbase() != pptr() ) { + m_writer( std::string( pbase(), static_cast( pptr() - pbase() ) ) ); + setp( pbase(), epptr() ); + } + return 0; + } + }; + + /////////////////////////////////////////////////////////////////////////// + + FileStream::FileStream( std::string const& filename ) { + m_ofs.open( filename.c_str() ); + if( m_ofs.fail() ) { + std::ostringstream oss; + oss << "Unable to open file: '" << filename << '\''; + throw std::domain_error( oss.str() ); + } + } + + std::ostream& FileStream::stream() const { + return m_ofs; + } + + struct OutputDebugWriter { + + void operator()( std::string const&str ) { + writeToDebugConsole( str ); + } + }; + + DebugOutStream::DebugOutStream() + : m_streamBuf( new StreamBufImpl() ), + m_os( m_streamBuf.get() ) + {} + + std::ostream& DebugOutStream::stream() const { + return m_os; + } + + // Store the streambuf from cout up-front because + // cout may get redirected when running tests + CoutStream::CoutStream() + : m_os( Catch::cout().rdbuf() ) + {} + + std::ostream& CoutStream::stream() const { + return m_os; + } + +#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions + std::ostream& cout() { + return std::cout; + } + std::ostream& cerr() { + return std::cerr; + } + std::ostream& clog() { + return std::clog; + } +#endif +} + +namespace Catch { + + class Context : public IMutableContext { + + Context() : m_config( CATCH_NULL ), m_runner( CATCH_NULL ), m_resultCapture( CATCH_NULL ) {} + Context( Context const& ); + void operator=( Context const& ); + + public: + virtual ~Context() { + deleteAllValues( m_generatorsByTestName ); + } + + public: // IContext + virtual IResultCapture* getResultCapture() { + return m_resultCapture; + } + virtual IRunner* getRunner() { + return m_runner; + } + virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) { + return getGeneratorsForCurrentTest() + .getGeneratorInfo( fileInfo, totalSize ) + .getCurrentIndex(); + } + virtual bool advanceGeneratorsForCurrentTest() { + IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); + return generators && generators->moveNext(); + } + + virtual Ptr getConfig() const { + return m_config; + } + + public: // IMutableContext + virtual void setResultCapture( IResultCapture* resultCapture ) { + m_resultCapture = resultCapture; + } + virtual void setRunner( IRunner* runner ) { + m_runner = runner; + } + virtual void setConfig( Ptr const& config ) { + m_config = config; + } + + friend IMutableContext& getCurrentMutableContext(); + + private: + IGeneratorsForTest* findGeneratorsForCurrentTest() { + std::string testName = getResultCapture()->getCurrentTestName(); + + std::map::const_iterator it = + m_generatorsByTestName.find( testName ); + return it != m_generatorsByTestName.end() + ? it->second + : CATCH_NULL; + } + + IGeneratorsForTest& getGeneratorsForCurrentTest() { + IGeneratorsForTest* generators = findGeneratorsForCurrentTest(); + if( !generators ) { + std::string testName = getResultCapture()->getCurrentTestName(); + generators = createGeneratorsForTest(); + m_generatorsByTestName.insert( std::make_pair( testName, generators ) ); + } + return *generators; + } + + private: + Ptr m_config; + IRunner* m_runner; + IResultCapture* m_resultCapture; + std::map m_generatorsByTestName; + }; + + namespace { + Context* currentContext = CATCH_NULL; + } + IMutableContext& getCurrentMutableContext() { + if( !currentContext ) + currentContext = new Context(); + return *currentContext; + } + IContext& getCurrentContext() { + return getCurrentMutableContext(); + } + + void cleanUpContext() { + delete currentContext; + currentContext = CATCH_NULL; + } +} + +// #included from: catch_console_colour_impl.hpp +#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED + +// #included from: catch_errno_guard.hpp +#define TWOBLUECUBES_CATCH_ERRNO_GUARD_HPP_INCLUDED + +#include + +namespace Catch { + + class ErrnoGuard { + public: + ErrnoGuard():m_oldErrno(errno){} + ~ErrnoGuard() { errno = m_oldErrno; } + private: + int m_oldErrno; + }; + +} + +namespace Catch { + namespace { + + struct IColourImpl { + virtual ~IColourImpl() {} + virtual void use( Colour::Code _colourCode ) = 0; + }; + + struct NoColourImpl : IColourImpl { + void use( Colour::Code ) {} + + static IColourImpl* instance() { + static NoColourImpl s_instance; + return &s_instance; + } + }; + + } // anon namespace +} // namespace Catch + +#if !defined( CATCH_CONFIG_COLOUR_NONE ) && !defined( CATCH_CONFIG_COLOUR_WINDOWS ) && !defined( CATCH_CONFIG_COLOUR_ANSI ) +# ifdef CATCH_PLATFORM_WINDOWS +# define CATCH_CONFIG_COLOUR_WINDOWS +# else +# define CATCH_CONFIG_COLOUR_ANSI +# endif +#endif + +#if defined ( CATCH_CONFIG_COLOUR_WINDOWS ) ///////////////////////////////////////// + +namespace Catch { +namespace { + + class Win32ColourImpl : public IColourImpl { + public: + Win32ColourImpl() : stdoutHandle( GetStdHandle(STD_OUTPUT_HANDLE) ) + { + CONSOLE_SCREEN_BUFFER_INFO csbiInfo; + GetConsoleScreenBufferInfo( stdoutHandle, &csbiInfo ); + originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY ); + originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY ); + } + + virtual void use( Colour::Code _colourCode ) { + switch( _colourCode ) { + case Colour::None: return setTextAttribute( originalForegroundAttributes ); + case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); + case Colour::Red: return setTextAttribute( FOREGROUND_RED ); + case Colour::Green: return setTextAttribute( FOREGROUND_GREEN ); + case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE ); + case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN ); + case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN ); + case Colour::Grey: return setTextAttribute( 0 ); + + case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY ); + case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED ); + case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN ); + case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE ); + + case Colour::Bright: throw std::logic_error( "not a colour" ); + } + } + + private: + void setTextAttribute( WORD _textAttribute ) { + SetConsoleTextAttribute( stdoutHandle, _textAttribute | originalBackgroundAttributes ); + } + HANDLE stdoutHandle; + WORD originalForegroundAttributes; + WORD originalBackgroundAttributes; + }; + + IColourImpl* platformColourInstance() { + static Win32ColourImpl s_instance; + + Ptr config = getCurrentContext().getConfig(); + UseColour::YesOrNo colourMode = config + ? config->useColour() + : UseColour::Auto; + if( colourMode == UseColour::Auto ) + colourMode = !isDebuggerActive() + ? UseColour::Yes + : UseColour::No; + return colourMode == UseColour::Yes + ? &s_instance + : NoColourImpl::instance(); + } + +} // end anon namespace +} // end namespace Catch + +#elif defined( CATCH_CONFIG_COLOUR_ANSI ) ////////////////////////////////////// + +#include + +namespace Catch { +namespace { + + // use POSIX/ ANSI console terminal codes + // Thanks to Adam Strzelecki for original contribution + // (http://github.com/nanoant) + // https://github.com/philsquared/Catch/pull/131 + class PosixColourImpl : public IColourImpl { + public: + virtual void use( Colour::Code _colourCode ) { + switch( _colourCode ) { + case Colour::None: + case Colour::White: return setColour( "[0m" ); + case Colour::Red: return setColour( "[0;31m" ); + case Colour::Green: return setColour( "[0;32m" ); + case Colour::Blue: return setColour( "[0;34m" ); + case Colour::Cyan: return setColour( "[0;36m" ); + case Colour::Yellow: return setColour( "[0;33m" ); + case Colour::Grey: return setColour( "[1;30m" ); + + case Colour::LightGrey: return setColour( "[0;37m" ); + case Colour::BrightRed: return setColour( "[1;31m" ); + case Colour::BrightGreen: return setColour( "[1;32m" ); + case Colour::BrightWhite: return setColour( "[1;37m" ); + + case Colour::Bright: throw std::logic_error( "not a colour" ); + } + } + static IColourImpl* instance() { + static PosixColourImpl s_instance; + return &s_instance; + } + + private: + void setColour( const char* _escapeCode ) { + Catch::cout() << '\033' << _escapeCode; + } + }; + + IColourImpl* platformColourInstance() { + ErrnoGuard guard; + Ptr config = getCurrentContext().getConfig(); + UseColour::YesOrNo colourMode = config + ? config->useColour() + : UseColour::Auto; + if( colourMode == UseColour::Auto ) + colourMode = (!isDebuggerActive() && isatty(STDOUT_FILENO) ) + ? UseColour::Yes + : UseColour::No; + return colourMode == UseColour::Yes + ? PosixColourImpl::instance() + : NoColourImpl::instance(); + } + +} // end anon namespace +} // end namespace Catch + +#else // not Windows or ANSI /////////////////////////////////////////////// + +namespace Catch { + + static IColourImpl* platformColourInstance() { return NoColourImpl::instance(); } + +} // end namespace Catch + +#endif // Windows/ ANSI/ None + +namespace Catch { + + Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); } + Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast( _other ).m_moved = true; } + Colour::~Colour(){ if( !m_moved ) use( None ); } + + void Colour::use( Code _colourCode ) { + static IColourImpl* impl = platformColourInstance(); + impl->use( _colourCode ); + } + +} // end namespace Catch + +// #included from: catch_generators_impl.hpp +#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED + +#include +#include +#include + +namespace Catch { + + struct GeneratorInfo : IGeneratorInfo { + + GeneratorInfo( std::size_t size ) + : m_size( size ), + m_currentIndex( 0 ) + {} + + bool moveNext() { + if( ++m_currentIndex == m_size ) { + m_currentIndex = 0; + return false; + } + return true; + } + + std::size_t getCurrentIndex() const { + return m_currentIndex; + } + + std::size_t m_size; + std::size_t m_currentIndex; + }; + + /////////////////////////////////////////////////////////////////////////// + + class GeneratorsForTest : public IGeneratorsForTest { + + public: + ~GeneratorsForTest() { + deleteAll( m_generatorsInOrder ); + } + + IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) { + std::map::const_iterator it = m_generatorsByName.find( fileInfo ); + if( it == m_generatorsByName.end() ) { + IGeneratorInfo* info = new GeneratorInfo( size ); + m_generatorsByName.insert( std::make_pair( fileInfo, info ) ); + m_generatorsInOrder.push_back( info ); + return *info; + } + return *it->second; + } + + bool moveNext() { + std::vector::const_iterator it = m_generatorsInOrder.begin(); + std::vector::const_iterator itEnd = m_generatorsInOrder.end(); + for(; it != itEnd; ++it ) { + if( (*it)->moveNext() ) + return true; + } + return false; + } + + private: + std::map m_generatorsByName; + std::vector m_generatorsInOrder; + }; + + IGeneratorsForTest* createGeneratorsForTest() + { + return new GeneratorsForTest(); + } + +} // end namespace Catch + +// #included from: catch_assertionresult.hpp +#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED + +namespace Catch { + + AssertionInfo::AssertionInfo():macroName(""), capturedExpression(""), resultDisposition(ResultDisposition::Normal), secondArg(""){} + + AssertionInfo::AssertionInfo( char const * _macroName, + SourceLineInfo const& _lineInfo, + char const * _capturedExpression, + ResultDisposition::Flags _resultDisposition, + char const * _secondArg) + : macroName( _macroName ), + lineInfo( _lineInfo ), + capturedExpression( _capturedExpression ), + resultDisposition( _resultDisposition ), + secondArg( _secondArg ) + {} + + AssertionResult::AssertionResult() {} + + AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data ) + : m_info( info ), + m_resultData( data ) + {} + + AssertionResult::~AssertionResult() {} + + // Result was a success + bool AssertionResult::succeeded() const { + return Catch::isOk( m_resultData.resultType ); + } + + // Result was a success, or failure is suppressed + bool AssertionResult::isOk() const { + return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition ); + } + + ResultWas::OfType AssertionResult::getResultType() const { + return m_resultData.resultType; + } + + bool AssertionResult::hasExpression() const { + return m_info.capturedExpression[0] != 0; + } + + bool AssertionResult::hasMessage() const { + return !m_resultData.message.empty(); + } + + std::string capturedExpressionWithSecondArgument( char const * capturedExpression, char const * secondArg ) { + return (secondArg[0] == 0 || secondArg[0] == '"' && secondArg[1] == '"') + ? capturedExpression + : std::string(capturedExpression) + ", " + secondArg; + } + + std::string AssertionResult::getExpression() const { + if( isFalseTest( m_info.resultDisposition ) ) + return "!(" + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + ")"; + else + return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg); + } + std::string AssertionResult::getExpressionInMacro() const { + if( m_info.macroName[0] == 0 ) + return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg); + else + return std::string(m_info.macroName) + "( " + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + " )"; + } + + bool AssertionResult::hasExpandedExpression() const { + return hasExpression() && getExpandedExpression() != getExpression(); + } + + std::string AssertionResult::getExpandedExpression() const { + return m_resultData.reconstructExpression(); + } + + std::string AssertionResult::getMessage() const { + return m_resultData.message; + } + SourceLineInfo AssertionResult::getSourceInfo() const { + return m_info.lineInfo; + } + + std::string AssertionResult::getTestMacroName() const { + return m_info.macroName; + } + + void AssertionResult::discardDecomposedExpression() const { + m_resultData.decomposedExpression = CATCH_NULL; + } + + void AssertionResult::expandDecomposedExpression() const { + m_resultData.reconstructExpression(); + } + +} // end namespace Catch + +// #included from: catch_test_case_info.hpp +#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED + +#include + +namespace Catch { + + inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) { + if( startsWith( tag, '.' ) || + tag == "hide" || + tag == "!hide" ) + return TestCaseInfo::IsHidden; + else if( tag == "!throws" ) + return TestCaseInfo::Throws; + else if( tag == "!shouldfail" ) + return TestCaseInfo::ShouldFail; + else if( tag == "!mayfail" ) + return TestCaseInfo::MayFail; + else if( tag == "!nonportable" ) + return TestCaseInfo::NonPortable; + else + return TestCaseInfo::None; + } + inline bool isReservedTag( std::string const& tag ) { + return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( tag[0] ); + } + inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) { + if( isReservedTag( tag ) ) { + std::ostringstream ss; + ss << Colour(Colour::Red) + << "Tag name [" << tag << "] not allowed.\n" + << "Tag names starting with non alpha-numeric characters are reserved\n" + << Colour(Colour::FileName) + << _lineInfo << '\n'; + throw std::runtime_error(ss.str()); + } + } + + TestCase makeTestCase( ITestCase* _testCase, + std::string const& _className, + std::string const& _name, + std::string const& _descOrTags, + SourceLineInfo const& _lineInfo ) + { + bool isHidden( startsWith( _name, "./" ) ); // Legacy support + + // Parse out tags + std::set tags; + std::string desc, tag; + bool inTag = false; + for( std::size_t i = 0; i < _descOrTags.size(); ++i ) { + char c = _descOrTags[i]; + if( !inTag ) { + if( c == '[' ) + inTag = true; + else + desc += c; + } + else { + if( c == ']' ) { + TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag ); + if( prop == TestCaseInfo::IsHidden ) + isHidden = true; + else if( prop == TestCaseInfo::None ) + enforceNotReservedTag( tag, _lineInfo ); + + tags.insert( tag ); + tag.clear(); + inTag = false; + } + else + tag += c; + } + } + if( isHidden ) { + tags.insert( "hide" ); + tags.insert( "." ); + } + + TestCaseInfo info( _name, _className, desc, tags, _lineInfo ); + return TestCase( _testCase, info ); + } + + void setTags( TestCaseInfo& testCaseInfo, std::set const& tags ) + { + testCaseInfo.tags = tags; + testCaseInfo.lcaseTags.clear(); + + std::ostringstream oss; + for( std::set::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it ) { + oss << '[' << *it << ']'; + std::string lcaseTag = toLower( *it ); + testCaseInfo.properties = static_cast( testCaseInfo.properties | parseSpecialTag( lcaseTag ) ); + testCaseInfo.lcaseTags.insert( lcaseTag ); + } + testCaseInfo.tagsAsString = oss.str(); + } + + TestCaseInfo::TestCaseInfo( std::string const& _name, + std::string const& _className, + std::string const& _description, + std::set const& _tags, + SourceLineInfo const& _lineInfo ) + : name( _name ), + className( _className ), + description( _description ), + lineInfo( _lineInfo ), + properties( None ) + { + setTags( *this, _tags ); + } + + TestCaseInfo::TestCaseInfo( TestCaseInfo const& other ) + : name( other.name ), + className( other.className ), + description( other.description ), + tags( other.tags ), + lcaseTags( other.lcaseTags ), + tagsAsString( other.tagsAsString ), + lineInfo( other.lineInfo ), + properties( other.properties ) + {} + + bool TestCaseInfo::isHidden() const { + return ( properties & IsHidden ) != 0; + } + bool TestCaseInfo::throws() const { + return ( properties & Throws ) != 0; + } + bool TestCaseInfo::okToFail() const { + return ( properties & (ShouldFail | MayFail ) ) != 0; + } + bool TestCaseInfo::expectedToFail() const { + return ( properties & (ShouldFail ) ) != 0; + } + + TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {} + + TestCase::TestCase( TestCase const& other ) + : TestCaseInfo( other ), + test( other.test ) + {} + + TestCase TestCase::withName( std::string const& _newName ) const { + TestCase other( *this ); + other.name = _newName; + return other; + } + + void TestCase::swap( TestCase& other ) { + test.swap( other.test ); + name.swap( other.name ); + className.swap( other.className ); + description.swap( other.description ); + tags.swap( other.tags ); + lcaseTags.swap( other.lcaseTags ); + tagsAsString.swap( other.tagsAsString ); + std::swap( TestCaseInfo::properties, static_cast( other ).properties ); + std::swap( lineInfo, other.lineInfo ); + } + + void TestCase::invoke() const { + test->invoke(); + } + + bool TestCase::operator == ( TestCase const& other ) const { + return test.get() == other.test.get() && + name == other.name && + className == other.className; + } + + bool TestCase::operator < ( TestCase const& other ) const { + return name < other.name; + } + TestCase& TestCase::operator = ( TestCase const& other ) { + TestCase temp( other ); + swap( temp ); + return *this; + } + + TestCaseInfo const& TestCase::getTestCaseInfo() const + { + return *this; + } + +} // end namespace Catch + +// #included from: catch_version.hpp +#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED + +namespace Catch { + + Version::Version + ( unsigned int _majorVersion, + unsigned int _minorVersion, + unsigned int _patchNumber, + char const * const _branchName, + unsigned int _buildNumber ) + : majorVersion( _majorVersion ), + minorVersion( _minorVersion ), + patchNumber( _patchNumber ), + branchName( _branchName ), + buildNumber( _buildNumber ) + {} + + std::ostream& operator << ( std::ostream& os, Version const& version ) { + 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; + } + + inline Version libraryVersion() { + static Version version( 1, 11, 0, "", 0 ); + return version; + } + +} + +// #included from: catch_message.hpp +#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED + +namespace Catch { + + MessageInfo::MessageInfo( std::string const& _macroName, + SourceLineInfo const& _lineInfo, + ResultWas::OfType _type ) + : macroName( _macroName ), + lineInfo( _lineInfo ), + type( _type ), + sequence( ++globalCount ) + {} + + // This may need protecting if threading support is added + unsigned int MessageInfo::globalCount = 0; + + //////////////////////////////////////////////////////////////////////////// + + ScopedMessage::ScopedMessage( MessageBuilder const& builder ) + : m_info( builder.m_info ) + { + m_info.message = builder.m_stream.str(); + getResultCapture().pushScopedMessage( m_info ); + } + ScopedMessage::ScopedMessage( ScopedMessage const& other ) + : m_info( other.m_info ) + {} + + ScopedMessage::~ScopedMessage() { + if ( !std::uncaught_exception() ){ + getResultCapture().popScopedMessage(m_info); + } + } + +} // end namespace Catch + +// #included from: catch_legacy_reporter_adapter.hpp +#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED + +// #included from: catch_legacy_reporter_adapter.h +#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED + +namespace Catch +{ + // Deprecated + struct IReporter : IShared { + virtual ~IReporter(); + + virtual bool shouldRedirectStdout() const = 0; + + virtual void StartTesting() = 0; + virtual void EndTesting( Totals const& totals ) = 0; + virtual void StartGroup( std::string const& groupName ) = 0; + virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0; + virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0; + virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0; + virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0; + virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0; + virtual void NoAssertionsInSection( std::string const& sectionName ) = 0; + virtual void NoAssertionsInTestCase( std::string const& testName ) = 0; + virtual void Aborted() = 0; + virtual void Result( AssertionResult const& result ) = 0; + }; + + class LegacyReporterAdapter : public SharedImpl + { + public: + LegacyReporterAdapter( Ptr const& legacyReporter ); + virtual ~LegacyReporterAdapter(); + + virtual ReporterPreferences getPreferences() const; + virtual void noMatchingTestCases( std::string const& ); + virtual void testRunStarting( TestRunInfo const& ); + virtual void testGroupStarting( GroupInfo const& groupInfo ); + virtual void testCaseStarting( TestCaseInfo const& testInfo ); + virtual void sectionStarting( SectionInfo const& sectionInfo ); + virtual void assertionStarting( AssertionInfo const& ); + virtual bool assertionEnded( AssertionStats const& assertionStats ); + virtual void sectionEnded( SectionStats const& sectionStats ); + virtual void testCaseEnded( TestCaseStats const& testCaseStats ); + virtual void testGroupEnded( TestGroupStats const& testGroupStats ); + virtual void testRunEnded( TestRunStats const& testRunStats ); + virtual void skipTest( TestCaseInfo const& ); + + private: + Ptr m_legacyReporter; + }; +} + +namespace Catch +{ + LegacyReporterAdapter::LegacyReporterAdapter( Ptr const& legacyReporter ) + : m_legacyReporter( legacyReporter ) + {} + LegacyReporterAdapter::~LegacyReporterAdapter() {} + + ReporterPreferences LegacyReporterAdapter::getPreferences() const { + ReporterPreferences prefs; + prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout(); + return prefs; + } + + void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {} + void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) { + m_legacyReporter->StartTesting(); + } + void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) { + m_legacyReporter->StartGroup( groupInfo.name ); + } + void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) { + m_legacyReporter->StartTestCase( testInfo ); + } + void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) { + m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description ); + } + void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) { + // Not on legacy interface + } + + bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) { + if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) { + for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); + it != itEnd; + ++it ) { + if( it->type == ResultWas::Info ) { + ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal ); + rb << it->message; + rb.setResultType( ResultWas::Info ); + AssertionResult result = rb.build(); + m_legacyReporter->Result( result ); + } + } + } + m_legacyReporter->Result( assertionStats.assertionResult ); + return true; + } + void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) { + if( sectionStats.missingAssertions ) + m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name ); + m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions ); + } + void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) { + m_legacyReporter->EndTestCase + ( testCaseStats.testInfo, + testCaseStats.totals, + testCaseStats.stdOut, + testCaseStats.stdErr ); + } + void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) { + if( testGroupStats.aborting ) + m_legacyReporter->Aborted(); + m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals ); + } + void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) { + m_legacyReporter->EndTesting( testRunStats.totals ); + } + void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) { + } +} + +// #included from: catch_timer.hpp + +#ifdef __clang__ +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wc++11-long-long" +#endif + +#ifdef CATCH_PLATFORM_WINDOWS + +#else + +#include + +#endif + +namespace Catch { + + namespace { +#ifdef CATCH_PLATFORM_WINDOWS + UInt64 getCurrentTicks() { + static UInt64 hz=0, hzo=0; + if (!hz) { + QueryPerformanceFrequency( reinterpret_cast( &hz ) ); + QueryPerformanceCounter( reinterpret_cast( &hzo ) ); + } + UInt64 t; + QueryPerformanceCounter( reinterpret_cast( &t ) ); + return ((t-hzo)*1000000)/hz; + } +#else + UInt64 getCurrentTicks() { + timeval t; + gettimeofday(&t,CATCH_NULL); + return static_cast( t.tv_sec ) * 1000000ull + static_cast( t.tv_usec ); + } +#endif + } + + void Timer::start() { + m_ticks = getCurrentTicks(); + } + unsigned int Timer::getElapsedMicroseconds() const { + return static_cast(getCurrentTicks() - m_ticks); + } + unsigned int Timer::getElapsedMilliseconds() const { + return static_cast(getElapsedMicroseconds()/1000); + } + double Timer::getElapsedSeconds() const { + return getElapsedMicroseconds()/1000000.0; + } + +} // namespace Catch + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif +// #included from: catch_common.hpp +#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED + +#include +#include + +namespace Catch { + + bool startsWith( std::string const& s, std::string const& prefix ) { + return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin()); + } + bool startsWith( std::string const& s, char prefix ) { + return !s.empty() && s[0] == prefix; + } + bool endsWith( std::string const& s, std::string const& suffix ) { + return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin()); + } + bool endsWith( std::string const& s, char suffix ) { + return !s.empty() && s[s.size()-1] == suffix; + } + bool contains( std::string const& s, std::string const& infix ) { + return s.find( infix ) != std::string::npos; + } + char toLowerCh(char c) { + return static_cast( std::tolower( c ) ); + } + void toLowerInPlace( std::string& s ) { + std::transform( s.begin(), s.end(), s.begin(), toLowerCh ); + } + std::string toLower( std::string const& s ) { + std::string lc = s; + toLowerInPlace( lc ); + return lc; + } + std::string trim( std::string const& str ) { + 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(); + } + + bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) { + 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; + } + + pluralise::pluralise( std::size_t count, std::string const& label ) + : m_count( count ), + m_label( label ) + {} + + std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) { + os << pluraliser.m_count << ' ' << pluraliser.m_label; + if( pluraliser.m_count != 1 ) + os << 's'; + return os; + } + + SourceLineInfo::SourceLineInfo() : file(""), line( 0 ){} + SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line ) + : file( _file ), + line( _line ) + {} + bool SourceLineInfo::empty() const { + return file[0] == '\0'; + } + bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const { + return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0); + } + bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const { + return line < other.line || ( line == other.line && (std::strcmp(file, other.file) < 0)); + } + + void seedRng( IConfig const& config ) { + if( config.rngSeed() != 0 ) + std::srand( config.rngSeed() ); + } + unsigned int rngSeed() { + return getCurrentContext().getConfig()->rngSeed(); + } + + std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) { +#ifndef __GNUG__ + os << info.file << '(' << info.line << ')'; +#else + os << info.file << ':' << info.line; +#endif + return os; + } + + void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) { + std::ostringstream oss; + oss << locationInfo << ": Internal Catch error: '" << message << '\''; + if( alwaysTrue() ) + throw std::logic_error( oss.str() ); + } +} + +// #included from: catch_section.hpp +#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED + +namespace Catch { + + SectionInfo::SectionInfo + ( SourceLineInfo const& _lineInfo, + std::string const& _name, + std::string const& _description ) + : name( _name ), + description( _description ), + lineInfo( _lineInfo ) + {} + + Section::Section( SectionInfo const& info ) + : m_info( info ), + m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) ) + { + m_timer.start(); + } + +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17 +#endif + Section::~Section() { + if( m_sectionIncluded ) { + SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() ); + if( std::uncaught_exception() ) + getResultCapture().sectionEndedEarly( endInfo ); + else + getResultCapture().sectionEnded( endInfo ); + } + } +#if defined(_MSC_VER) +#pragma warning(pop) +#endif + + // This indicates whether the section should be executed or not + Section::operator bool() const { + return m_sectionIncluded; + } + +} // end namespace Catch + +// #included from: catch_debugger.hpp +#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED + +#ifdef CATCH_PLATFORM_MAC + + #include + #include + #include + #include + #include + + namespace Catch{ + + // The following function is taken directly from the following technical note: + // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html + + // Returns true if the current process is being debugged (either + // running under the debugger or has a debugger attached post facto). + bool isDebuggerActive(){ + + int mib[4]; + struct kinfo_proc info; + size_t size; + + // Initialize the flags so that, if sysctl fails for some bizarre + // reason, we get a predictable result. + + info.kp_proc.p_flag = 0; + + // Initialize mib, which tells sysctl the info we want, in this case + // we're looking for information about a specific process ID. + + mib[0] = CTL_KERN; + mib[1] = KERN_PROC; + mib[2] = KERN_PROC_PID; + mib[3] = getpid(); + + // Call sysctl. + + size = sizeof(info); + if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, CATCH_NULL, 0) != 0 ) { + Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl; + return false; + } + + // We're being debugged if the P_TRACED flag is set. + + return ( (info.kp_proc.p_flag & P_TRACED) != 0 ); + } + } // namespace Catch + +#elif defined(CATCH_PLATFORM_LINUX) + #include + #include + + namespace Catch{ + // The standard POSIX way of detecting a debugger is to attempt to + // ptrace() the process, but this needs to be done from a child and not + // this process itself to still allow attaching to this process later + // if wanted, so is rather heavy. Under Linux we have the PID of the + // "debugger" (which doesn't need to be gdb, of course, it could also + // be strace, for example) in /proc/$PID/status, so just get it from + // there instead. + bool isDebuggerActive(){ + // Libstdc++ has a bug, where std::ifstream sets errno to 0 + // This way our users can properly assert over errno values + ErrnoGuard guard; + std::ifstream in("/proc/self/status"); + for( std::string line; std::getline(in, line); ) { + static const int PREFIX_LEN = 11; + if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) { + // We're traced if the PID is not 0 and no other PID starts + // with 0 digit, so it's enough to check for just a single + // character. + return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0'; + } + } + + return false; + } + } // namespace Catch +#elif defined(_MSC_VER) + extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); + namespace Catch { + bool isDebuggerActive() { + return IsDebuggerPresent() != 0; + } + } +#elif defined(__MINGW32__) + extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent(); + namespace Catch { + bool isDebuggerActive() { + return IsDebuggerPresent() != 0; + } + } +#else + namespace Catch { + inline bool isDebuggerActive() { return false; } + } +#endif // Platform + +#ifdef CATCH_PLATFORM_WINDOWS + + namespace Catch { + void writeToDebugConsole( std::string const& text ) { + ::OutputDebugStringA( text.c_str() ); + } + } +#else + namespace Catch { + void writeToDebugConsole( std::string const& text ) { + // !TBD: Need a version for Mac/ XCode and other IDEs + Catch::cout() << text; + } + } +#endif // Platform + +// #included from: catch_tostring.hpp +#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED + +namespace Catch { + +namespace Detail { + + const std::string unprintableString = "{?}"; + + namespace { + const int hexThreshold = 255; + + struct Endianness { + enum Arch { Big, Little }; + + static Arch which() { + union _{ + int asInt; + char asChar[sizeof (int)]; + } u; + + u.asInt = 1; + return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little; + } + }; + } + + std::string rawMemoryToString( const void *object, std::size_t size ) + { + // Reverse order for little endian architectures + int i = 0, end = static_cast( size ), inc = 1; + if( Endianness::which() == Endianness::Little ) { + i = end-1; + end = inc = -1; + } + + unsigned char const *bytes = static_cast(object); + std::ostringstream os; + os << "0x" << std::setfill('0') << std::hex; + for( ; i != end; i += inc ) + os << std::setw(2) << static_cast(bytes[i]); + return os.str(); + } +} + +std::string toString( std::string const& value ) { + std::string s = value; + if( getCurrentContext().getConfig()->showInvisibles() ) { + for(size_t i = 0; i < s.size(); ++i ) { + std::string subs; + switch( s[i] ) { + case '\n': subs = "\\n"; break; + case '\t': subs = "\\t"; break; + default: break; + } + if( !subs.empty() ) { + s = s.substr( 0, i ) + subs + s.substr( i+1 ); + ++i; + } + } + } + return '"' + s + '"'; +} +std::string toString( std::wstring const& value ) { + + std::string s; + s.reserve( value.size() ); + for(size_t i = 0; i < value.size(); ++i ) + s += value[i] <= 0xff ? static_cast( value[i] ) : '?'; + return Catch::toString( s ); +} + +std::string toString( const char* const value ) { + return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" ); +} + +std::string toString( char* const value ) { + return Catch::toString( static_cast( value ) ); +} + +std::string toString( const wchar_t* const value ) +{ + return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" ); +} + +std::string toString( wchar_t* const value ) +{ + return Catch::toString( static_cast( value ) ); +} + +std::string toString( int value ) { + std::ostringstream oss; + oss << value; + if( value > Detail::hexThreshold ) + oss << " (0x" << std::hex << value << ')'; + return oss.str(); +} + +std::string toString( unsigned long value ) { + std::ostringstream oss; + oss << value; + if( value > Detail::hexThreshold ) + oss << " (0x" << std::hex << value << ')'; + return oss.str(); +} + +std::string toString( unsigned int value ) { + return Catch::toString( static_cast( value ) ); +} + +template +std::string fpToString( T value, int precision ) { + std::ostringstream oss; + oss << std::setprecision( precision ) + << std::fixed + << value; + std::string d = oss.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; +} + +std::string toString( const double value ) { + return fpToString( value, 10 ); +} +std::string toString( const float value ) { + return fpToString( value, 5 ) + 'f'; +} + +std::string toString( bool value ) { + return value ? "true" : "false"; +} + +std::string toString( char value ) { + if ( value == '\r' ) + return "'\\r'"; + if ( value == '\f' ) + return "'\\f'"; + if ( value == '\n' ) + return "'\\n'"; + if ( value == '\t' ) + return "'\\t'"; + if ( '\0' <= value && value < ' ' ) + return toString( static_cast( value ) ); + char chstr[] = "' '"; + chstr[1] = value; + return chstr; +} + +std::string toString( signed char value ) { + return toString( static_cast( value ) ); +} + +std::string toString( unsigned char value ) { + return toString( static_cast( value ) ); +} + +#ifdef CATCH_CONFIG_CPP11_LONG_LONG +std::string toString( long long value ) { + std::ostringstream oss; + oss << value; + if( value > Detail::hexThreshold ) + oss << " (0x" << std::hex << value << ')'; + return oss.str(); +} +std::string toString( unsigned long long value ) { + std::ostringstream oss; + oss << value; + if( value > Detail::hexThreshold ) + oss << " (0x" << std::hex << value << ')'; + return oss.str(); +} +#endif + +#ifdef CATCH_CONFIG_CPP11_NULLPTR +std::string toString( std::nullptr_t ) { + return "nullptr"; +} +#endif + +#ifdef __OBJC__ + std::string toString( NSString const * const& nsstring ) { + if( !nsstring ) + return "nil"; + return "@" + toString([nsstring UTF8String]); + } + std::string toString( NSString * CATCH_ARC_STRONG & nsstring ) { + if( !nsstring ) + return "nil"; + return "@" + toString([nsstring UTF8String]); + } + std::string toString( NSObject* const& nsObject ) { + return toString( [nsObject description] ); + } +#endif + +} // end namespace Catch + +// #included from: catch_result_builder.hpp +#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED + +namespace Catch { + + ResultBuilder::ResultBuilder( char const* macroName, + SourceLineInfo const& lineInfo, + char const* capturedExpression, + ResultDisposition::Flags resultDisposition, + char const* secondArg ) + : m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition, secondArg ), + m_shouldDebugBreak( false ), + m_shouldThrow( false ), + m_guardException( false ), + m_usedStream( false ) + {} + + ResultBuilder::~ResultBuilder() { +#if defined(CATCH_CONFIG_FAST_COMPILE) + if ( m_guardException ) { + stream().oss << "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"; + captureResult( ResultWas::ThrewException ); + getCurrentContext().getResultCapture()->exceptionEarlyReported(); + } +#endif + } + + ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) { + m_data.resultType = result; + return *this; + } + ResultBuilder& ResultBuilder::setResultType( bool result ) { + m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed; + return *this; + } + + void ResultBuilder::endExpression( DecomposedExpression const& expr ) { + // Flip bool results if FalseTest flag is set + if( isFalseTest( m_assertionInfo.resultDisposition ) ) { + m_data.negate( expr.isBinaryExpression() ); + } + + getResultCapture().assertionRun(); + + if(getCurrentContext().getConfig()->includeSuccessfulResults() || m_data.resultType != ResultWas::Ok) + { + AssertionResult result = build( expr ); + handleResult( result ); + } + else + getResultCapture().assertionPassed(); + } + + void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) { + m_assertionInfo.resultDisposition = resultDisposition; + stream().oss << Catch::translateActiveException(); + captureResult( ResultWas::ThrewException ); + } + + void ResultBuilder::captureResult( ResultWas::OfType resultType ) { + setResultType( resultType ); + captureExpression(); + } + + void ResultBuilder::captureExpectedException( std::string const& expectedMessage ) { + if( expectedMessage.empty() ) + captureExpectedException( Matchers::Impl::MatchAllOf() ); + else + captureExpectedException( Matchers::Equals( expectedMessage ) ); + } + + void ResultBuilder::captureExpectedException( Matchers::Impl::MatcherBase const& matcher ) { + + assert( !isFalseTest( m_assertionInfo.resultDisposition ) ); + AssertionResultData data = m_data; + data.resultType = ResultWas::Ok; + data.reconstructedExpression = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg); + + std::string actualMessage = Catch::translateActiveException(); + if( !matcher.match( actualMessage ) ) { + data.resultType = ResultWas::ExpressionFailed; + data.reconstructedExpression = actualMessage; + } + AssertionResult result( m_assertionInfo, data ); + handleResult( result ); + } + + void ResultBuilder::captureExpression() { + AssertionResult result = build(); + handleResult( result ); + } + + void ResultBuilder::handleResult( AssertionResult const& result ) + { + getResultCapture().assertionEnded( result ); + + if( !result.isOk() ) { + if( getCurrentContext().getConfig()->shouldDebugBreak() ) + m_shouldDebugBreak = true; + if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) ) + m_shouldThrow = true; + } + } + + void ResultBuilder::react() { +#if defined(CATCH_CONFIG_FAST_COMPILE) + if (m_shouldDebugBreak) { + /////////////////////////////////////////////////////////////////// + // To inspect the state during test, you need to go one level up the callstack + // To go back to the test and change execution, jump over the throw statement + /////////////////////////////////////////////////////////////////// + CATCH_BREAK_INTO_DEBUGGER(); + } +#endif + if( m_shouldThrow ) + throw Catch::TestFailureException(); + } + + bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; } + bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); } + + AssertionResult ResultBuilder::build() const + { + return build( *this ); + } + + // CAVEAT: The returned AssertionResult stores a pointer to the argument expr, + // a temporary DecomposedExpression, which in turn holds references to + // operands, possibly temporary as well. + // It should immediately be passed to handleResult; if the expression + // needs to be reported, its string expansion must be composed before + // the temporaries are destroyed. + AssertionResult ResultBuilder::build( DecomposedExpression const& expr ) const + { + assert( m_data.resultType != ResultWas::Unknown ); + AssertionResultData data = m_data; + + if(m_usedStream) + data.message = m_stream().oss.str(); + data.decomposedExpression = &expr; // for lazy reconstruction + return AssertionResult( m_assertionInfo, data ); + } + + void ResultBuilder::reconstructExpression( std::string& dest ) const { + dest = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg); + } + + void ResultBuilder::setExceptionGuard() { + m_guardException = true; + } + void ResultBuilder::unsetExceptionGuard() { + m_guardException = false; + } + +} // end namespace Catch + +// #included from: catch_tag_alias_registry.hpp +#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED + +namespace Catch { + + TagAliasRegistry::~TagAliasRegistry() {} + + Option TagAliasRegistry::find( std::string const& alias ) const { + std::map::const_iterator it = m_registry.find( alias ); + if( it != m_registry.end() ) + return it->second; + else + return Option(); + } + + std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const { + std::string expandedTestSpec = unexpandedTestSpec; + for( std::map::const_iterator it = m_registry.begin(), itEnd = m_registry.end(); + it != itEnd; + ++it ) { + std::size_t pos = expandedTestSpec.find( it->first ); + if( pos != std::string::npos ) { + expandedTestSpec = expandedTestSpec.substr( 0, pos ) + + it->second.tag + + expandedTestSpec.substr( pos + it->first.size() ); + } + } + return expandedTestSpec; + } + + void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) { + + if( !startsWith( alias, "[@" ) || !endsWith( alias, ']' ) ) { + std::ostringstream oss; + oss << Colour( Colour::Red ) + << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n" + << Colour( Colour::FileName ) + << lineInfo << '\n'; + throw std::domain_error( oss.str().c_str() ); + } + if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) { + std::ostringstream oss; + oss << Colour( Colour::Red ) + << "error: tag alias, \"" << alias << "\" already registered.\n" + << "\tFirst seen at " + << Colour( Colour::Red ) << find(alias)->lineInfo << '\n' + << Colour( Colour::Red ) << "\tRedefined at " + << Colour( Colour::FileName) << lineInfo << '\n'; + throw std::domain_error( oss.str().c_str() ); + } + } + + ITagAliasRegistry::~ITagAliasRegistry() {} + + ITagAliasRegistry const& ITagAliasRegistry::get() { + return getRegistryHub().getTagAliasRegistry(); + } + + RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) { + getMutableRegistryHub().registerTagAlias( alias, tag, lineInfo ); + } + +} // end namespace Catch + +// #included from: catch_matchers_string.hpp + +namespace Catch { +namespace Matchers { + + namespace StdString { + + CasedString::CasedString( std::string const& str, CaseSensitive::Choice caseSensitivity ) + : m_caseSensitivity( caseSensitivity ), + m_str( adjustString( str ) ) + {} + std::string CasedString::adjustString( std::string const& str ) const { + return m_caseSensitivity == CaseSensitive::No + ? toLower( str ) + : str; + } + std::string CasedString::caseSensitivitySuffix() const { + return m_caseSensitivity == CaseSensitive::No + ? " (case insensitive)" + : std::string(); + } + + StringMatcherBase::StringMatcherBase( std::string const& operation, CasedString const& comparator ) + : m_comparator( comparator ), + m_operation( operation ) { + } + + std::string StringMatcherBase::describe() const { + std::string description; + description.reserve(5 + m_operation.size() + m_comparator.m_str.size() + + m_comparator.caseSensitivitySuffix().size()); + description += m_operation; + description += ": \""; + description += m_comparator.m_str; + description += "\""; + description += m_comparator.caseSensitivitySuffix(); + return description; + } + + EqualsMatcher::EqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals", comparator ) {} + + bool EqualsMatcher::match( std::string const& source ) const { + return m_comparator.adjustString( source ) == m_comparator.m_str; + } + + ContainsMatcher::ContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains", comparator ) {} + + bool ContainsMatcher::match( std::string const& source ) const { + return contains( m_comparator.adjustString( source ), m_comparator.m_str ); + } + + StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with", comparator ) {} + + bool StartsWithMatcher::match( std::string const& source ) const { + return startsWith( m_comparator.adjustString( source ), m_comparator.m_str ); + } + + EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with", comparator ) {} + + bool EndsWithMatcher::match( std::string const& source ) const { + return endsWith( m_comparator.adjustString( source ), m_comparator.m_str ); + } + + } // namespace StdString + + StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) { + return StdString::EqualsMatcher( StdString::CasedString( str, caseSensitivity) ); + } + StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity ) { + return StdString::ContainsMatcher( StdString::CasedString( str, caseSensitivity) ); + } + StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) { + return StdString::EndsWithMatcher( StdString::CasedString( str, caseSensitivity) ); + } + StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity ) { + return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) ); + } + +} // namespace Matchers +} // namespace Catch +// #included from: ../reporters/catch_reporter_multi.hpp +#define TWOBLUECUBES_CATCH_REPORTER_MULTI_HPP_INCLUDED + +namespace Catch { + +class MultipleReporters : public SharedImpl { + typedef std::vector > Reporters; + Reporters m_reporters; + +public: + void add( Ptr const& reporter ) { + m_reporters.push_back( reporter ); + } + +public: // IStreamingReporter + + virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE { + return m_reporters[0]->getPreferences(); + } + + virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->noMatchingTestCases( spec ); + } + + virtual void testRunStarting( TestRunInfo const& testRunInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testRunStarting( testRunInfo ); + } + + virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testGroupStarting( groupInfo ); + } + + virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testCaseStarting( testInfo ); + } + + virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->sectionStarting( sectionInfo ); + } + + virtual void assertionStarting( AssertionInfo const& assertionInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->assertionStarting( assertionInfo ); + } + + // The return value indicates if the messages buffer should be cleared: + virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE { + bool clearBuffer = false; + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + clearBuffer |= (*it)->assertionEnded( assertionStats ); + return clearBuffer; + } + + virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->sectionEnded( sectionStats ); + } + + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testCaseEnded( testCaseStats ); + } + + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testGroupEnded( testGroupStats ); + } + + virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->testRunEnded( testRunStats ); + } + + virtual void skipTest( TestCaseInfo const& testInfo ) CATCH_OVERRIDE { + for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end(); + it != itEnd; + ++it ) + (*it)->skipTest( testInfo ); + } + + virtual MultipleReporters* tryAsMulti() CATCH_OVERRIDE { + return this; + } + +}; + +Ptr addReporter( Ptr const& existingReporter, Ptr const& additionalReporter ) { + Ptr resultingReporter; + + if( existingReporter ) { + MultipleReporters* multi = existingReporter->tryAsMulti(); + if( !multi ) { + multi = new MultipleReporters; + resultingReporter = Ptr( multi ); + if( existingReporter ) + multi->add( existingReporter ); + } + else + resultingReporter = existingReporter; + multi->add( additionalReporter ); + } + else + resultingReporter = additionalReporter; + + return resultingReporter; +} + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_xml.hpp +#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED + +// #included from: catch_reporter_bases.hpp +#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + + namespace { + // Because formatting using c++ streams is stateful, drop down to C is required + // Alternatively we could use stringstream, but its performance is... not good. + std::string getFormattedDuration( double duration ) { + // 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 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 + sprintf(buffer, "%.3f", duration); +#endif + return std::string(buffer); + } + } + + struct StreamingReporterBase : SharedImpl { + + StreamingReporterBase( ReporterConfig const& _config ) + : m_config( _config.fullConfig() ), + stream( _config.stream() ) + { + m_reporterPrefs.shouldRedirectStdOut = false; + } + + virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE { + return m_reporterPrefs; + } + + virtual ~StreamingReporterBase() CATCH_OVERRIDE; + + virtual void noMatchingTestCases( std::string const& ) CATCH_OVERRIDE {} + + virtual void testRunStarting( TestRunInfo const& _testRunInfo ) CATCH_OVERRIDE { + currentTestRunInfo = _testRunInfo; + } + virtual void testGroupStarting( GroupInfo const& _groupInfo ) CATCH_OVERRIDE { + currentGroupInfo = _groupInfo; + } + + virtual void testCaseStarting( TestCaseInfo const& _testInfo ) CATCH_OVERRIDE { + currentTestCaseInfo = _testInfo; + } + virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE { + m_sectionStack.push_back( _sectionInfo ); + } + + virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) CATCH_OVERRIDE { + m_sectionStack.pop_back(); + } + virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) CATCH_OVERRIDE { + currentTestCaseInfo.reset(); + } + virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) CATCH_OVERRIDE { + currentGroupInfo.reset(); + } + virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) CATCH_OVERRIDE { + currentTestCaseInfo.reset(); + currentGroupInfo.reset(); + currentTestRunInfo.reset(); + } + + virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE { + // Don't do anything with this by default. + // It can optionally be overridden in the derived class. + } + + Ptr m_config; + std::ostream& stream; + + LazyStat currentTestRunInfo; + LazyStat currentGroupInfo; + LazyStat currentTestCaseInfo; + + std::vector m_sectionStack; + ReporterPreferences m_reporterPrefs; + }; + + struct CumulativeReporterBase : SharedImpl { + template + struct Node : SharedImpl<> { + explicit Node( T const& _value ) : value( _value ) {} + virtual ~Node() {} + + typedef std::vector > ChildNodes; + T value; + ChildNodes children; + }; + struct SectionNode : SharedImpl<> { + explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {} + virtual ~SectionNode(); + + bool operator == ( SectionNode const& other ) const { + return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo; + } + bool operator == ( Ptr const& other ) const { + return operator==( *other ); + } + + SectionStats stats; + typedef std::vector > ChildSections; + typedef std::vector Assertions; + ChildSections childSections; + Assertions assertions; + std::string stdOut; + std::string stdErr; + }; + + struct BySectionInfo { + BySectionInfo( SectionInfo const& other ) : m_other( other ) {} + BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {} + bool operator() ( Ptr const& node ) const { + return ((node->stats.sectionInfo.name == m_other.name) && + (node->stats.sectionInfo.lineInfo == m_other.lineInfo)); + } + private: + void operator=( BySectionInfo const& ); + SectionInfo const& m_other; + }; + + typedef Node TestCaseNode; + typedef Node TestGroupNode; + typedef Node TestRunNode; + + CumulativeReporterBase( ReporterConfig const& _config ) + : m_config( _config.fullConfig() ), + stream( _config.stream() ) + { + m_reporterPrefs.shouldRedirectStdOut = false; + } + ~CumulativeReporterBase(); + + virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE { + return m_reporterPrefs; + } + + virtual void testRunStarting( TestRunInfo const& ) CATCH_OVERRIDE {} + virtual void testGroupStarting( GroupInfo const& ) CATCH_OVERRIDE {} + + virtual void testCaseStarting( TestCaseInfo const& ) CATCH_OVERRIDE {} + + virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE { + SectionStats incompleteStats( sectionInfo, Counts(), 0, false ); + Ptr node; + if( m_sectionStack.empty() ) { + if( !m_rootSection ) + m_rootSection = new SectionNode( incompleteStats ); + node = m_rootSection; + } + else { + SectionNode& parentNode = *m_sectionStack.back(); + SectionNode::ChildSections::const_iterator it = + std::find_if( parentNode.childSections.begin(), + parentNode.childSections.end(), + BySectionInfo( sectionInfo ) ); + if( it == parentNode.childSections.end() ) { + node = new SectionNode( incompleteStats ); + parentNode.childSections.push_back( node ); + } + else + node = *it; + } + m_sectionStack.push_back( node ); + m_deepestSection = node; + } + + virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {} + + virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE { + assert( !m_sectionStack.empty() ); + SectionNode& sectionNode = *m_sectionStack.back(); + sectionNode.assertions.push_back( assertionStats ); + // AssertionResult holds a pointer to a temporary DecomposedExpression, + // which getExpandedExpression() calls to build the expression string. + // Our section stack copy of the assertionResult will likely outlive the + // temporary, so it must be expanded or discarded now to avoid calling + // a destroyed object later. + prepareExpandedExpression( sectionNode.assertions.back().assertionResult ); + return true; + } + virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE { + assert( !m_sectionStack.empty() ); + SectionNode& node = *m_sectionStack.back(); + node.stats = sectionStats; + m_sectionStack.pop_back(); + } + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { + Ptr node = new TestCaseNode( testCaseStats ); + assert( m_sectionStack.size() == 0 ); + node->children.push_back( m_rootSection ); + m_testCases.push_back( node ); + m_rootSection.reset(); + + assert( m_deepestSection ); + m_deepestSection->stdOut = testCaseStats.stdOut; + m_deepestSection->stdErr = testCaseStats.stdErr; + } + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { + Ptr node = new TestGroupNode( testGroupStats ); + node->children.swap( m_testCases ); + m_testGroups.push_back( node ); + } + virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE { + Ptr node = new TestRunNode( testRunStats ); + node->children.swap( m_testGroups ); + m_testRuns.push_back( node ); + testRunEndedCumulative(); + } + virtual void testRunEndedCumulative() = 0; + + virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {} + + virtual void prepareExpandedExpression( AssertionResult& result ) const { + if( result.isOk() ) + result.discardDecomposedExpression(); + else + result.expandDecomposedExpression(); + } + + Ptr m_config; + std::ostream& stream; + std::vector m_assertions; + std::vector > > m_sections; + std::vector > m_testCases; + std::vector > m_testGroups; + + std::vector > m_testRuns; + + Ptr m_rootSection; + Ptr m_deepestSection; + std::vector > m_sectionStack; + ReporterPreferences m_reporterPrefs; + + }; + + template + char const* getLineOfChars() { + 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; + } + + struct TestEventListenerBase : StreamingReporterBase { + TestEventListenerBase( ReporterConfig const& _config ) + : StreamingReporterBase( _config ) + {} + + virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {} + virtual bool assertionEnded( AssertionStats const& ) CATCH_OVERRIDE { + return false; + } + }; + +} // end namespace Catch + +// #included from: ../internal/catch_reporter_registrars.hpp +#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED + +namespace Catch { + + template + class LegacyReporterRegistrar { + + class ReporterFactory : public IReporterFactory { + virtual IStreamingReporter* create( ReporterConfig const& config ) const { + return new LegacyReporterAdapter( new T( config ) ); + } + + virtual std::string getDescription() const { + return T::getDescription(); + } + }; + + public: + + LegacyReporterRegistrar( std::string const& name ) { + getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); + } + }; + + template + class ReporterRegistrar { + + class ReporterFactory : public SharedImpl { + + // *** Please Note ***: + // - If you end up here looking at a compiler error because it's trying to register + // your custom reporter class be aware that the native reporter interface has changed + // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via + // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter. + // However please consider updating to the new interface as the old one is now + // deprecated and will probably be removed quite soon! + // Please contact me via github if you have any questions at all about this. + // In fact, ideally, please contact me anyway to let me know you've hit this - as I have + // no idea who is actually using custom reporters at all (possibly no-one!). + // The new interface is designed to minimise exposure to interface changes in the future. + virtual IStreamingReporter* create( ReporterConfig const& config ) const { + return new T( config ); + } + + virtual std::string getDescription() const { + return T::getDescription(); + } + }; + + public: + + ReporterRegistrar( std::string const& name ) { + getMutableRegistryHub().registerReporter( name, new ReporterFactory() ); + } + }; + + template + class ListenerRegistrar { + + class ListenerFactory : public SharedImpl { + + virtual IStreamingReporter* create( ReporterConfig const& config ) const { + return new T( config ); + } + virtual std::string getDescription() const { + return std::string(); + } + }; + + public: + + ListenerRegistrar() { + getMutableRegistryHub().registerListener( new ListenerFactory() ); + } + }; +} + +#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \ + namespace{ Catch::LegacyReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } + +#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \ + namespace{ Catch::ReporterRegistrar catch_internal_RegistrarFor##reporterType( name ); } + +// Deprecated - use the form without INTERNAL_ +#define INTERNAL_CATCH_REGISTER_LISTENER( listenerType ) \ + namespace{ Catch::ListenerRegistrar catch_internal_RegistrarFor##listenerType; } + +#define CATCH_REGISTER_LISTENER( listenerType ) \ + namespace{ Catch::ListenerRegistrar catch_internal_RegistrarFor##listenerType; } + +// #included from: ../internal/catch_xmlwriter.hpp +#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED + +#include +#include +#include +#include + +namespace Catch { + + class XmlEncode { + public: + enum ForWhat { ForTextNodes, ForAttributes }; + + XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes ) + : m_str( str ), + m_forWhat( forWhat ) + {} + + void encodeTo( std::ostream& os ) const { + + // Apostrophe escaping not necessary if we always use " to write attributes + // (see: http://www.w3.org/TR/xml/#syntax) + + for( std::size_t i = 0; i < m_str.size(); ++ i ) { + char c = m_str[i]; + switch( c ) { + case '<': os << "<"; break; + case '&': os << "&"; break; + + case '>': + // See: http://www.w3.org/TR/xml/#syntax + if( i > 2 && m_str[i-1] == ']' && m_str[i-2] == ']' ) + os << ">"; + else + os << c; + break; + + case '\"': + if( m_forWhat == ForAttributes ) + os << """; + else + os << c; + break; + + default: + // Escape control chars - based on contribution by @espenalb in PR #465 and + // by @mrpi PR #588 + if ( ( c >= 0 && c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' ) { + // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0 + os << "\\x" << std::uppercase << std::hex << std::setfill('0') << std::setw(2) + << static_cast( c ); + } + else + os << c; + } + } + } + + friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) { + xmlEncode.encodeTo( os ); + return os; + } + + private: + std::string m_str; + ForWhat m_forWhat; + }; + + class XmlWriter { + public: + + class ScopedElement { + public: + ScopedElement( XmlWriter* writer ) + : m_writer( writer ) + {} + + ScopedElement( ScopedElement const& other ) + : m_writer( other.m_writer ){ + other.m_writer = CATCH_NULL; + } + + ~ScopedElement() { + if( m_writer ) + m_writer->endElement(); + } + + ScopedElement& writeText( std::string const& text, bool indent = true ) { + m_writer->writeText( text, indent ); + return *this; + } + + template + ScopedElement& writeAttribute( std::string const& name, T const& attribute ) { + m_writer->writeAttribute( name, attribute ); + return *this; + } + + private: + mutable XmlWriter* m_writer; + }; + + XmlWriter() + : m_tagIsOpen( false ), + m_needsNewline( false ), + m_os( Catch::cout() ) + { + writeDeclaration(); + } + + XmlWriter( std::ostream& os ) + : m_tagIsOpen( false ), + m_needsNewline( false ), + m_os( os ) + { + writeDeclaration(); + } + + ~XmlWriter() { + while( !m_tags.empty() ) + endElement(); + } + + XmlWriter& startElement( std::string const& name ) { + ensureTagClosed(); + newlineIfNecessary(); + m_os << m_indent << '<' << name; + m_tags.push_back( name ); + m_indent += " "; + m_tagIsOpen = true; + return *this; + } + + ScopedElement scopedElement( std::string const& name ) { + ScopedElement scoped( this ); + startElement( name ); + return scoped; + } + + XmlWriter& endElement() { + newlineIfNecessary(); + m_indent = m_indent.substr( 0, m_indent.size()-2 ); + if( m_tagIsOpen ) { + m_os << "/>"; + m_tagIsOpen = false; + } + else { + m_os << m_indent << ""; + } + m_os << std::endl; + m_tags.pop_back(); + return *this; + } + + XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) { + if( !name.empty() && !attribute.empty() ) + m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"'; + return *this; + } + + XmlWriter& writeAttribute( std::string const& name, bool attribute ) { + m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"'; + return *this; + } + + template + XmlWriter& writeAttribute( std::string const& name, T const& attribute ) { + std::ostringstream oss; + oss << attribute; + return writeAttribute( name, oss.str() ); + } + + XmlWriter& writeText( std::string const& text, bool indent = true ) { + if( !text.empty() ){ + bool tagWasOpen = m_tagIsOpen; + ensureTagClosed(); + if( tagWasOpen && indent ) + m_os << m_indent; + m_os << XmlEncode( text ); + m_needsNewline = true; + } + return *this; + } + + XmlWriter& writeComment( std::string const& text ) { + ensureTagClosed(); + m_os << m_indent << ""; + m_needsNewline = true; + return *this; + } + + void writeStylesheetRef( std::string const& url ) { + m_os << "\n"; + } + + XmlWriter& writeBlankLine() { + ensureTagClosed(); + m_os << '\n'; + return *this; + } + + void ensureTagClosed() { + if( m_tagIsOpen ) { + m_os << ">" << std::endl; + m_tagIsOpen = false; + } + } + + private: + XmlWriter( XmlWriter const& ); + void operator=( XmlWriter const& ); + + void writeDeclaration() { + m_os << "\n"; + } + + void newlineIfNecessary() { + if( m_needsNewline ) { + m_os << std::endl; + m_needsNewline = false; + } + } + + bool m_tagIsOpen; + bool m_needsNewline; + std::vector m_tags; + std::string m_indent; + std::ostream& m_os; + }; + +} + +namespace Catch { + class XmlReporter : public StreamingReporterBase { + public: + XmlReporter( ReporterConfig const& _config ) + : StreamingReporterBase( _config ), + m_xml(_config.stream()), + m_sectionDepth( 0 ) + { + m_reporterPrefs.shouldRedirectStdOut = true; + } + + virtual ~XmlReporter() CATCH_OVERRIDE; + + static std::string getDescription() { + return "Reports test results as an XML document"; + } + + virtual std::string getStylesheetRef() const { + return std::string(); + } + + void writeSourceInfo( SourceLineInfo const& sourceInfo ) { + m_xml + .writeAttribute( "filename", sourceInfo.file ) + .writeAttribute( "line", sourceInfo.line ); + } + + public: // StreamingReporterBase + + virtual void noMatchingTestCases( std::string const& s ) CATCH_OVERRIDE { + StreamingReporterBase::noMatchingTestCases( s ); + } + + virtual void testRunStarting( TestRunInfo const& testInfo ) CATCH_OVERRIDE { + StreamingReporterBase::testRunStarting( testInfo ); + std::string stylesheetRef = getStylesheetRef(); + if( !stylesheetRef.empty() ) + m_xml.writeStylesheetRef( stylesheetRef ); + m_xml.startElement( "Catch" ); + if( !m_config->name().empty() ) + m_xml.writeAttribute( "name", m_config->name() ); + } + + virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE { + StreamingReporterBase::testGroupStarting( groupInfo ); + m_xml.startElement( "Group" ) + .writeAttribute( "name", groupInfo.name ); + } + + virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE { + StreamingReporterBase::testCaseStarting(testInfo); + m_xml.startElement( "TestCase" ) + .writeAttribute( "name", trim( testInfo.name ) ) + .writeAttribute( "description", testInfo.description ) + .writeAttribute( "tags", testInfo.tagsAsString ); + + writeSourceInfo( testInfo.lineInfo ); + + if ( m_config->showDurations() == ShowDurations::Always ) + m_testCaseTimer.start(); + m_xml.ensureTagClosed(); + } + + virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE { + StreamingReporterBase::sectionStarting( sectionInfo ); + if( m_sectionDepth++ > 0 ) { + m_xml.startElement( "Section" ) + .writeAttribute( "name", trim( sectionInfo.name ) ) + .writeAttribute( "description", sectionInfo.description ); + writeSourceInfo( sectionInfo.lineInfo ); + m_xml.ensureTagClosed(); + } + } + + virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE { } + + virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE { + + AssertionResult const& result = assertionStats.assertionResult; + + bool includeResults = m_config->includeSuccessfulResults() || !result.isOk(); + + if( includeResults ) { + // Print any info messages in tags. + for( std::vector::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end(); + it != itEnd; + ++it ) { + if( it->type == ResultWas::Info ) { + m_xml.scopedElement( "Info" ) + .writeText( it->message ); + } else if ( it->type == ResultWas::Warning ) { + m_xml.scopedElement( "Warning" ) + .writeText( it->message ); + } + } + } + + // Drop out if result was successful but we're not printing them. + if( !includeResults && result.getResultType() != ResultWas::Warning ) + return true; + + // Print the expression if there is one. + if( result.hasExpression() ) { + m_xml.startElement( "Expression" ) + .writeAttribute( "success", result.succeeded() ) + .writeAttribute( "type", result.getTestMacroName() ); + + writeSourceInfo( result.getSourceInfo() ); + + m_xml.scopedElement( "Original" ) + .writeText( result.getExpression() ); + m_xml.scopedElement( "Expanded" ) + .writeText( result.getExpandedExpression() ); + } + + // And... Print a result applicable to each result type. + switch( result.getResultType() ) { + case ResultWas::ThrewException: + m_xml.startElement( "Exception" ); + writeSourceInfo( result.getSourceInfo() ); + m_xml.writeText( result.getMessage() ); + m_xml.endElement(); + break; + case ResultWas::FatalErrorCondition: + m_xml.startElement( "FatalErrorCondition" ); + writeSourceInfo( result.getSourceInfo() ); + m_xml.writeText( result.getMessage() ); + m_xml.endElement(); + break; + case ResultWas::Info: + m_xml.scopedElement( "Info" ) + .writeText( result.getMessage() ); + break; + case ResultWas::Warning: + // Warning will already have been written + break; + case ResultWas::ExplicitFailure: + m_xml.startElement( "Failure" ); + writeSourceInfo( result.getSourceInfo() ); + m_xml.writeText( result.getMessage() ); + m_xml.endElement(); + break; + default: + break; + } + + if( result.hasExpression() ) + m_xml.endElement(); + + return true; + } + + virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE { + StreamingReporterBase::sectionEnded( sectionStats ); + if( --m_sectionDepth > 0 ) { + XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" ); + e.writeAttribute( "successes", sectionStats.assertions.passed ); + e.writeAttribute( "failures", sectionStats.assertions.failed ); + e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk ); + + if ( m_config->showDurations() == ShowDurations::Always ) + e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds ); + + m_xml.endElement(); + } + } + + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { + StreamingReporterBase::testCaseEnded( testCaseStats ); + XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" ); + e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() ); + + if ( m_config->showDurations() == ShowDurations::Always ) + e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() ); + + if( !testCaseStats.stdOut.empty() ) + m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false ); + if( !testCaseStats.stdErr.empty() ) + m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false ); + + m_xml.endElement(); + } + + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { + StreamingReporterBase::testGroupEnded( testGroupStats ); + // TODO: Check testGroupStats.aborting and act accordingly. + m_xml.scopedElement( "OverallResults" ) + .writeAttribute( "successes", testGroupStats.totals.assertions.passed ) + .writeAttribute( "failures", testGroupStats.totals.assertions.failed ) + .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk ); + m_xml.endElement(); + } + + virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE { + StreamingReporterBase::testRunEnded( testRunStats ); + m_xml.scopedElement( "OverallResults" ) + .writeAttribute( "successes", testRunStats.totals.assertions.passed ) + .writeAttribute( "failures", testRunStats.totals.assertions.failed ) + .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk ); + m_xml.endElement(); + } + + private: + Timer m_testCaseTimer; + XmlWriter m_xml; + int m_sectionDepth; + }; + + INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter ) + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_junit.hpp +#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED + +#include + +namespace Catch { + + namespace { + std::string getCurrentTimestamp() { + // Beware, this is not reentrant because of backward compatibility issues + // Also, UTC only, again because of backward compatibility (%z is C++11) + time_t rawtime; + std::time(&rawtime); + const size_t timeStampSize = sizeof("2017-01-16T17:06:45Z"); + +#ifdef _MSC_VER + std::tm timeInfo = {}; + gmtime_s(&timeInfo, &rawtime); +#else + std::tm* timeInfo; + timeInfo = std::gmtime(&rawtime); +#endif + + char timeStamp[timeStampSize]; + const char * const fmt = "%Y-%m-%dT%H:%M:%SZ"; + +#ifdef _MSC_VER + std::strftime(timeStamp, timeStampSize, fmt, &timeInfo); +#else + std::strftime(timeStamp, timeStampSize, fmt, timeInfo); +#endif + return std::string(timeStamp); + } + + } + + class JunitReporter : public CumulativeReporterBase { + public: + JunitReporter( ReporterConfig const& _config ) + : CumulativeReporterBase( _config ), + xml( _config.stream() ), + unexpectedExceptions( 0 ), + m_okToFail( false ) + { + m_reporterPrefs.shouldRedirectStdOut = true; + } + + virtual ~JunitReporter() CATCH_OVERRIDE; + + static std::string getDescription() { + return "Reports test results in an XML format that looks like Ant's junitreport target"; + } + + virtual void noMatchingTestCases( std::string const& /*spec*/ ) CATCH_OVERRIDE {} + + virtual void testRunStarting( TestRunInfo const& runInfo ) CATCH_OVERRIDE { + CumulativeReporterBase::testRunStarting( runInfo ); + xml.startElement( "testsuites" ); + } + + virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE { + suiteTimer.start(); + stdOutForSuite.str(""); + stdErrForSuite.str(""); + unexpectedExceptions = 0; + CumulativeReporterBase::testGroupStarting( groupInfo ); + } + + virtual void testCaseStarting( TestCaseInfo const& testCaseInfo ) CATCH_OVERRIDE { + m_okToFail = testCaseInfo.okToFail(); + } + virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE { + if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail ) + unexpectedExceptions++; + return CumulativeReporterBase::assertionEnded( assertionStats ); + } + + virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE { + stdOutForSuite << testCaseStats.stdOut; + stdErrForSuite << testCaseStats.stdErr; + CumulativeReporterBase::testCaseEnded( testCaseStats ); + } + + virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE { + double suiteTime = suiteTimer.getElapsedSeconds(); + CumulativeReporterBase::testGroupEnded( testGroupStats ); + writeGroup( *m_testGroups.back(), suiteTime ); + } + + virtual void testRunEndedCumulative() CATCH_OVERRIDE { + xml.endElement(); + } + + void writeGroup( TestGroupNode const& groupNode, double suiteTime ) { + XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" ); + TestGroupStats const& stats = groupNode.value; + xml.writeAttribute( "name", stats.groupInfo.name ); + xml.writeAttribute( "errors", unexpectedExceptions ); + xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions ); + xml.writeAttribute( "tests", stats.totals.assertions.total() ); + xml.writeAttribute( "hostname", "tbd" ); // !TBD + if( m_config->showDurations() == ShowDurations::Never ) + xml.writeAttribute( "time", "" ); + else + xml.writeAttribute( "time", suiteTime ); + xml.writeAttribute( "timestamp", getCurrentTimestamp() ); + + // Write test cases + for( TestGroupNode::ChildNodes::const_iterator + it = groupNode.children.begin(), itEnd = groupNode.children.end(); + it != itEnd; + ++it ) + writeTestCase( **it ); + + xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false ); + xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false ); + } + + void writeTestCase( TestCaseNode const& testCaseNode ) { + TestCaseStats const& stats = testCaseNode.value; + + // All test cases have exactly one section - which represents the + // test case itself. That section may have 0-n nested sections + assert( testCaseNode.children.size() == 1 ); + SectionNode const& rootSection = *testCaseNode.children.front(); + + std::string className = stats.testInfo.className; + + if( className.empty() ) { + if( rootSection.childSections.empty() ) + className = "global"; + } + writeSection( className, "", rootSection ); + } + + void writeSection( std::string const& className, + std::string const& rootName, + SectionNode const& sectionNode ) { + std::string name = trim( sectionNode.stats.sectionInfo.name ); + if( !rootName.empty() ) + name = rootName + '/' + name; + + if( !sectionNode.assertions.empty() || + !sectionNode.stdOut.empty() || + !sectionNode.stdErr.empty() ) { + XmlWriter::ScopedElement e = xml.scopedElement( "testcase" ); + if( className.empty() ) { + xml.writeAttribute( "classname", name ); + xml.writeAttribute( "name", "root" ); + } + else { + xml.writeAttribute( "classname", className ); + xml.writeAttribute( "name", name ); + } + xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) ); + + writeAssertions( sectionNode ); + + if( !sectionNode.stdOut.empty() ) + xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false ); + if( !sectionNode.stdErr.empty() ) + xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false ); + } + for( SectionNode::ChildSections::const_iterator + it = sectionNode.childSections.begin(), + itEnd = sectionNode.childSections.end(); + it != itEnd; + ++it ) + if( className.empty() ) + writeSection( name, "", **it ); + else + writeSection( className, name, **it ); + } + + void writeAssertions( SectionNode const& sectionNode ) { + for( SectionNode::Assertions::const_iterator + it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end(); + it != itEnd; + ++it ) + writeAssertion( *it ); + } + void writeAssertion( AssertionStats const& stats ) { + AssertionResult const& result = stats.assertionResult; + if( !result.isOk() ) { + std::string elementName; + switch( result.getResultType() ) { + case ResultWas::ThrewException: + case ResultWas::FatalErrorCondition: + elementName = "error"; + break; + case ResultWas::ExplicitFailure: + elementName = "failure"; + break; + case ResultWas::ExpressionFailed: + elementName = "failure"; + break; + case ResultWas::DidntThrowException: + elementName = "failure"; + break; + + // We should never see these here: + case ResultWas::Info: + case ResultWas::Warning: + case ResultWas::Ok: + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + elementName = "internalError"; + break; + } + + XmlWriter::ScopedElement e = xml.scopedElement( elementName ); + + xml.writeAttribute( "message", result.getExpandedExpression() ); + xml.writeAttribute( "type", result.getTestMacroName() ); + + std::ostringstream oss; + if( !result.getMessage().empty() ) + oss << result.getMessage() << '\n'; + for( std::vector::const_iterator + it = stats.infoMessages.begin(), + itEnd = stats.infoMessages.end(); + it != itEnd; + ++it ) + if( it->type == ResultWas::Info ) + oss << it->message << '\n'; + + oss << "at " << result.getSourceInfo(); + xml.writeText( oss.str(), false ); + } + } + + XmlWriter xml; + Timer suiteTimer; + std::ostringstream stdOutForSuite; + std::ostringstream stdErrForSuite; + unsigned int unexpectedExceptions; + bool m_okToFail; + }; + + INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter ) + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_console.hpp +#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED + +#include +#include + +namespace Catch { + + struct ConsoleReporter : StreamingReporterBase { + ConsoleReporter( ReporterConfig const& _config ) + : StreamingReporterBase( _config ), + m_headerPrinted( false ) + {} + + virtual ~ConsoleReporter() CATCH_OVERRIDE; + static std::string getDescription() { + return "Reports test results as plain lines of text"; + } + + virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE { + stream << "No test cases matched '" << spec << '\'' << std::endl; + } + + virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE { + } + + virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_OVERRIDE { + AssertionResult const& result = _assertionStats.assertionResult; + + bool includeResults = m_config->includeSuccessfulResults() || !result.isOk(); + + // Drop out if result was successful but we're not printing them. + if( !includeResults && result.getResultType() != ResultWas::Warning ) + return false; + + lazyPrint(); + + AssertionPrinter printer( stream, _assertionStats, includeResults ); + printer.print(); + stream << std::endl; + return true; + } + + virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE { + m_headerPrinted = false; + StreamingReporterBase::sectionStarting( _sectionInfo ); + } + virtual void sectionEnded( SectionStats const& _sectionStats ) CATCH_OVERRIDE { + if( _sectionStats.missingAssertions ) { + lazyPrint(); + Colour colour( Colour::ResultError ); + if( m_sectionStack.size() > 1 ) + stream << "\nNo assertions in section"; + else + stream << "\nNo assertions in test case"; + stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl; + } + if( m_config->showDurations() == ShowDurations::Always ) { + stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl; + } + if( m_headerPrinted ) { + m_headerPrinted = false; + } + StreamingReporterBase::sectionEnded( _sectionStats ); + } + + virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) CATCH_OVERRIDE { + StreamingReporterBase::testCaseEnded( _testCaseStats ); + m_headerPrinted = false; + } + virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE { + if( currentGroupInfo.used ) { + printSummaryDivider(); + stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n"; + printTotals( _testGroupStats.totals ); + stream << '\n' << std::endl; + } + StreamingReporterBase::testGroupEnded( _testGroupStats ); + } + virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE { + printTotalsDivider( _testRunStats.totals ); + printTotals( _testRunStats.totals ); + stream << std::endl; + StreamingReporterBase::testRunEnded( _testRunStats ); + } + + private: + + class AssertionPrinter { + void operator= ( AssertionPrinter const& ); + public: + AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) + : stream( _stream ), + stats( _stats ), + result( _stats.assertionResult ), + colour( Colour::None ), + message( result.getMessage() ), + messages( _stats.infoMessages ), + printInfoMessages( _printInfoMessages ) + { + switch( result.getResultType() ) { + case ResultWas::Ok: + colour = Colour::Success; + passOrFail = "PASSED"; + //if( result.hasMessage() ) + if( _stats.infoMessages.size() == 1 ) + messageLabel = "with message"; + if( _stats.infoMessages.size() > 1 ) + messageLabel = "with messages"; + break; + case ResultWas::ExpressionFailed: + if( result.isOk() ) { + colour = Colour::Success; + passOrFail = "FAILED - but was ok"; + } + else { + colour = Colour::Error; + passOrFail = "FAILED"; + } + if( _stats.infoMessages.size() == 1 ) + messageLabel = "with message"; + if( _stats.infoMessages.size() > 1 ) + messageLabel = "with messages"; + break; + case ResultWas::ThrewException: + colour = Colour::Error; + passOrFail = "FAILED"; + messageLabel = "due to unexpected exception with "; + if (_stats.infoMessages.size() == 1) + messageLabel += "message"; + if (_stats.infoMessages.size() > 1) + messageLabel += "messages"; + break; + case ResultWas::FatalErrorCondition: + colour = Colour::Error; + passOrFail = "FAILED"; + messageLabel = "due to a fatal error condition"; + break; + case ResultWas::DidntThrowException: + colour = Colour::Error; + passOrFail = "FAILED"; + messageLabel = "because no exception was thrown where one was expected"; + break; + case ResultWas::Info: + messageLabel = "info"; + break; + case ResultWas::Warning: + messageLabel = "warning"; + break; + case ResultWas::ExplicitFailure: + passOrFail = "FAILED"; + colour = Colour::Error; + if( _stats.infoMessages.size() == 1 ) + messageLabel = "explicitly with message"; + if( _stats.infoMessages.size() > 1 ) + messageLabel = "explicitly with messages"; + break; + // These cases are here to prevent compiler warnings + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + passOrFail = "** internal error **"; + colour = Colour::Error; + break; + } + } + + void print() const { + printSourceInfo(); + if( stats.totals.assertions.total() > 0 ) { + if( result.isOk() ) + stream << '\n'; + printResultType(); + printOriginalExpression(); + printReconstructedExpression(); + } + else { + stream << '\n'; + } + printMessage(); + } + + private: + void printResultType() const { + if( !passOrFail.empty() ) { + Colour colourGuard( colour ); + stream << passOrFail << ":\n"; + } + } + void printOriginalExpression() const { + if( result.hasExpression() ) { + Colour colourGuard( Colour::OriginalExpression ); + stream << " "; + stream << result.getExpressionInMacro(); + stream << '\n'; + } + } + void printReconstructedExpression() const { + if( result.hasExpandedExpression() ) { + stream << "with expansion:\n"; + Colour colourGuard( Colour::ReconstructedExpression ); + stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << '\n'; + } + } + void printMessage() const { + if( !messageLabel.empty() ) + stream << messageLabel << ':' << '\n'; + for( std::vector::const_iterator it = messages.begin(), itEnd = messages.end(); + it != itEnd; + ++it ) { + // If this assertion is a warning ignore any INFO messages + if( printInfoMessages || it->type != ResultWas::Info ) + stream << Text( it->message, TextAttributes().setIndent(2) ) << '\n'; + } + } + void printSourceInfo() const { + Colour colourGuard( Colour::FileName ); + stream << result.getSourceInfo() << ": "; + } + + std::ostream& stream; + AssertionStats const& stats; + AssertionResult const& result; + Colour::Code colour; + std::string passOrFail; + std::string messageLabel; + std::string message; + std::vector messages; + bool printInfoMessages; + }; + + void lazyPrint() { + + if( !currentTestRunInfo.used ) + lazyPrintRunInfo(); + if( !currentGroupInfo.used ) + lazyPrintGroupInfo(); + + if( !m_headerPrinted ) { + printTestCaseAndSectionHeader(); + m_headerPrinted = true; + } + } + void lazyPrintRunInfo() { + stream << '\n' << getLineOfChars<'~'>() << '\n'; + Colour colour( Colour::SecondaryText ); + stream << currentTestRunInfo->name + << " is a Catch v" << libraryVersion() << " host application.\n" + << "Run with -? for options\n\n"; + + if( m_config->rngSeed() != 0 ) + stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n"; + + currentTestRunInfo.used = true; + } + void lazyPrintGroupInfo() { + if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) { + printClosedHeader( "Group: " + currentGroupInfo->name ); + currentGroupInfo.used = true; + } + } + void printTestCaseAndSectionHeader() { + assert( !m_sectionStack.empty() ); + printOpenHeader( currentTestCaseInfo->name ); + + if( m_sectionStack.size() > 1 ) { + Colour colourGuard( Colour::Headers ); + + std::vector::const_iterator + it = m_sectionStack.begin()+1, // Skip first section (test case) + itEnd = m_sectionStack.end(); + for( ; it != itEnd; ++it ) + printHeaderString( it->name, 2 ); + } + + SourceLineInfo lineInfo = m_sectionStack.back().lineInfo; + + if( !lineInfo.empty() ){ + stream << getLineOfChars<'-'>() << '\n'; + Colour colourGuard( Colour::FileName ); + stream << lineInfo << '\n'; + } + stream << getLineOfChars<'.'>() << '\n' << std::endl; + } + + void printClosedHeader( std::string const& _name ) { + printOpenHeader( _name ); + stream << getLineOfChars<'.'>() << '\n'; + } + void printOpenHeader( std::string const& _name ) { + stream << getLineOfChars<'-'>() << '\n'; + { + Colour colourGuard( Colour::Headers ); + printHeaderString( _name ); + } + } + + // if string has a : in first line will set indent to follow it on + // subsequent lines + void printHeaderString( std::string const& _string, std::size_t indent = 0 ) { + std::size_t i = _string.find( ": " ); + if( i != std::string::npos ) + i+=2; + else + i = 0; + stream << Text( _string, TextAttributes() + .setIndent( indent+i) + .setInitialIndent( indent ) ) << '\n'; + } + + struct SummaryColumn { + + SummaryColumn( std::string const& _label, Colour::Code _colour ) + : label( _label ), + colour( _colour ) + {} + SummaryColumn addRow( std::size_t count ) { + std::ostringstream oss; + oss << count; + std::string row = oss.str(); + for( std::vector::iterator it = rows.begin(); it != rows.end(); ++it ) { + while( it->size() < row.size() ) + *it = ' ' + *it; + while( it->size() > row.size() ) + row = ' ' + row; + } + rows.push_back( row ); + return *this; + } + + std::string label; + Colour::Code colour; + std::vector rows; + + }; + + void printTotals( Totals const& totals ) { + if( totals.testCases.total() == 0 ) { + stream << Colour( Colour::Warning ) << "No tests ran\n"; + } + else if( totals.assertions.total() > 0 && totals.testCases.allPassed() ) { + stream << Colour( Colour::ResultSuccess ) << "All tests passed"; + stream << " (" + << pluralise( totals.assertions.passed, "assertion" ) << " in " + << pluralise( totals.testCases.passed, "test case" ) << ')' + << '\n'; + } + else { + + std::vector columns; + columns.push_back( SummaryColumn( "", Colour::None ) + .addRow( totals.testCases.total() ) + .addRow( totals.assertions.total() ) ); + columns.push_back( SummaryColumn( "passed", Colour::Success ) + .addRow( totals.testCases.passed ) + .addRow( totals.assertions.passed ) ); + columns.push_back( SummaryColumn( "failed", Colour::ResultError ) + .addRow( totals.testCases.failed ) + .addRow( totals.assertions.failed ) ); + columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure ) + .addRow( totals.testCases.failedButOk ) + .addRow( totals.assertions.failedButOk ) ); + + printSummaryRow( "test cases", columns, 0 ); + printSummaryRow( "assertions", columns, 1 ); + } + } + void printSummaryRow( std::string const& label, std::vector const& cols, std::size_t row ) { + for( std::vector::const_iterator it = cols.begin(); it != cols.end(); ++it ) { + std::string value = it->rows[row]; + if( it->label.empty() ) { + stream << label << ": "; + if( value != "0" ) + stream << value; + else + stream << Colour( Colour::Warning ) << "- none -"; + } + else if( value != "0" ) { + stream << Colour( Colour::LightGrey ) << " | "; + stream << Colour( it->colour ) + << value << ' ' << it->label; + } + } + stream << '\n'; + } + + static std::size_t makeRatio( std::size_t number, std::size_t total ) { + std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0; + return ( ratio == 0 && number > 0 ) ? 1 : ratio; + } + static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) { + if( i > j && i > k ) + return i; + else if( j > k ) + return j; + else + return k; + } + + void printTotalsDivider( Totals const& totals ) { + if( totals.testCases.total() > 0 ) { + std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() ); + std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() ); + std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() ); + while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 ) + findMax( failedRatio, failedButOkRatio, passedRatio )++; + while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 ) + findMax( failedRatio, failedButOkRatio, passedRatio )--; + + stream << Colour( Colour::Error ) << std::string( failedRatio, '=' ); + stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' ); + if( totals.testCases.allPassed() ) + stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' ); + else + stream << Colour( Colour::Success ) << std::string( passedRatio, '=' ); + } + else { + stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' ); + } + stream << '\n'; + } + void printSummaryDivider() { + stream << getLineOfChars<'-'>() << '\n'; + } + + private: + bool m_headerPrinted; + }; + + INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter ) + +} // end namespace Catch + +// #included from: ../reporters/catch_reporter_compact.hpp +#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED + +namespace Catch { + + struct CompactReporter : StreamingReporterBase { + + CompactReporter( ReporterConfig const& _config ) + : StreamingReporterBase( _config ) + {} + + virtual ~CompactReporter(); + + static std::string getDescription() { + return "Reports test results on a single line, suitable for IDEs"; + } + + virtual ReporterPreferences getPreferences() const { + ReporterPreferences prefs; + prefs.shouldRedirectStdOut = false; + return prefs; + } + + virtual void noMatchingTestCases( std::string const& spec ) { + stream << "No test cases matched '" << spec << '\'' << std::endl; + } + + virtual void assertionStarting( AssertionInfo const& ) {} + + virtual bool assertionEnded( AssertionStats const& _assertionStats ) { + AssertionResult const& result = _assertionStats.assertionResult; + + bool printInfoMessages = true; + + // Drop out if result was successful and we're not printing those + if( !m_config->includeSuccessfulResults() && result.isOk() ) { + if( result.getResultType() != ResultWas::Warning ) + return false; + printInfoMessages = false; + } + + AssertionPrinter printer( stream, _assertionStats, printInfoMessages ); + printer.print(); + + stream << std::endl; + return true; + } + + virtual void sectionEnded(SectionStats const& _sectionStats) CATCH_OVERRIDE { + if (m_config->showDurations() == ShowDurations::Always) { + stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl; + } + } + + virtual void testRunEnded( TestRunStats const& _testRunStats ) { + printTotals( _testRunStats.totals ); + stream << '\n' << std::endl; + StreamingReporterBase::testRunEnded( _testRunStats ); + } + + private: + class AssertionPrinter { + void operator= ( AssertionPrinter const& ); + public: + AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages ) + : stream( _stream ) + , stats( _stats ) + , result( _stats.assertionResult ) + , messages( _stats.infoMessages ) + , itMessage( _stats.infoMessages.begin() ) + , printInfoMessages( _printInfoMessages ) + {} + + void print() { + printSourceInfo(); + + itMessage = messages.begin(); + + switch( result.getResultType() ) { + case ResultWas::Ok: + printResultType( Colour::ResultSuccess, passedString() ); + printOriginalExpression(); + printReconstructedExpression(); + if ( ! result.hasExpression() ) + printRemainingMessages( Colour::None ); + else + printRemainingMessages(); + break; + case ResultWas::ExpressionFailed: + if( result.isOk() ) + printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) ); + else + printResultType( Colour::Error, failedString() ); + printOriginalExpression(); + printReconstructedExpression(); + printRemainingMessages(); + break; + case ResultWas::ThrewException: + printResultType( Colour::Error, failedString() ); + printIssue( "unexpected exception with message:" ); + printMessage(); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::FatalErrorCondition: + printResultType( Colour::Error, failedString() ); + printIssue( "fatal error condition with message:" ); + printMessage(); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::DidntThrowException: + printResultType( Colour::Error, failedString() ); + printIssue( "expected exception, got none" ); + printExpressionWas(); + printRemainingMessages(); + break; + case ResultWas::Info: + printResultType( Colour::None, "info" ); + printMessage(); + printRemainingMessages(); + break; + case ResultWas::Warning: + printResultType( Colour::None, "warning" ); + printMessage(); + printRemainingMessages(); + break; + case ResultWas::ExplicitFailure: + printResultType( Colour::Error, failedString() ); + printIssue( "explicitly" ); + printRemainingMessages( Colour::None ); + break; + // These cases are here to prevent compiler warnings + case ResultWas::Unknown: + case ResultWas::FailureBit: + case ResultWas::Exception: + printResultType( Colour::Error, "** internal error **" ); + break; + } + } + + private: + // Colour::LightGrey + + static Colour::Code dimColour() { return Colour::FileName; } + +#ifdef CATCH_PLATFORM_MAC + static const char* failedString() { return "FAILED"; } + static const char* passedString() { return "PASSED"; } +#else + static const char* failedString() { return "failed"; } + static const char* passedString() { return "passed"; } +#endif + + void printSourceInfo() const { + Colour colourGuard( Colour::FileName ); + stream << result.getSourceInfo() << ':'; + } + + void printResultType( Colour::Code colour, std::string const& passOrFail ) const { + if( !passOrFail.empty() ) { + { + Colour colourGuard( colour ); + stream << ' ' << passOrFail; + } + stream << ':'; + } + } + + void printIssue( std::string const& issue ) const { + stream << ' ' << issue; + } + + void printExpressionWas() { + if( result.hasExpression() ) { + stream << ';'; + { + Colour colour( dimColour() ); + stream << " expression was:"; + } + printOriginalExpression(); + } + } + + void printOriginalExpression() const { + if( result.hasExpression() ) { + stream << ' ' << result.getExpression(); + } + } + + void printReconstructedExpression() const { + if( result.hasExpandedExpression() ) { + { + Colour colour( dimColour() ); + stream << " for: "; + } + stream << result.getExpandedExpression(); + } + } + + void printMessage() { + if ( itMessage != messages.end() ) { + stream << " '" << itMessage->message << '\''; + ++itMessage; + } + } + + void printRemainingMessages( Colour::Code colour = dimColour() ) { + if ( itMessage == messages.end() ) + return; + + // using messages.end() directly yields compilation error: + std::vector::const_iterator itEnd = messages.end(); + const std::size_t N = static_cast( std::distance( itMessage, itEnd ) ); + + { + Colour colourGuard( colour ); + stream << " with " << pluralise( N, "message" ) << ':'; + } + + for(; itMessage != itEnd; ) { + // If this assertion is a warning ignore any INFO messages + if( printInfoMessages || itMessage->type != ResultWas::Info ) { + stream << " '" << itMessage->message << '\''; + if ( ++itMessage != itEnd ) { + Colour colourGuard( dimColour() ); + stream << " and"; + } + } + } + } + + private: + std::ostream& stream; + AssertionStats const& stats; + AssertionResult const& result; + std::vector messages; + std::vector::const_iterator itMessage; + bool printInfoMessages; + }; + + // Colour, message variants: + // - white: No tests ran. + // - red: Failed [both/all] N test cases, failed [both/all] M assertions. + // - white: Passed [both/all] N test cases (no assertions). + // - red: Failed N tests cases, failed M assertions. + // - green: Passed [both/all] N tests cases with M assertions. + + std::string bothOrAll( std::size_t count ) const { + return count == 1 ? std::string() : count == 2 ? "both " : "all " ; + } + + void printTotals( const Totals& totals ) const { + if( totals.testCases.total() == 0 ) { + stream << "No tests ran."; + } + else if( totals.testCases.failed == totals.testCases.total() ) { + Colour colour( Colour::ResultError ); + const std::string qualify_assertions_failed = + totals.assertions.failed == totals.assertions.total() ? + bothOrAll( totals.assertions.failed ) : std::string(); + stream << + "Failed " << bothOrAll( totals.testCases.failed ) + << pluralise( totals.testCases.failed, "test case" ) << ", " + "failed " << qualify_assertions_failed << + pluralise( totals.assertions.failed, "assertion" ) << '.'; + } + else if( totals.assertions.total() == 0 ) { + stream << + "Passed " << bothOrAll( totals.testCases.total() ) + << pluralise( totals.testCases.total(), "test case" ) + << " (no assertions)."; + } + else if( totals.assertions.failed ) { + Colour colour( Colour::ResultError ); + stream << + "Failed " << pluralise( totals.testCases.failed, "test case" ) << ", " + "failed " << pluralise( totals.assertions.failed, "assertion" ) << '.'; + } + else { + Colour colour( Colour::ResultSuccess ); + stream << + "Passed " << bothOrAll( totals.testCases.passed ) + << pluralise( totals.testCases.passed, "test case" ) << + " with " << pluralise( totals.assertions.passed, "assertion" ) << '.'; + } + } + }; + + INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter ) + +} // end namespace Catch + +namespace Catch { + // These are all here to avoid warnings about not having any out of line + // virtual methods + NonCopyable::~NonCopyable() {} + IShared::~IShared() {} + IStream::~IStream() CATCH_NOEXCEPT {} + FileStream::~FileStream() CATCH_NOEXCEPT {} + CoutStream::~CoutStream() CATCH_NOEXCEPT {} + DebugOutStream::~DebugOutStream() CATCH_NOEXCEPT {} + StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {} + IContext::~IContext() {} + IResultCapture::~IResultCapture() {} + ITestCase::~ITestCase() {} + ITestCaseRegistry::~ITestCaseRegistry() {} + IRegistryHub::~IRegistryHub() {} + IMutableRegistryHub::~IMutableRegistryHub() {} + IExceptionTranslator::~IExceptionTranslator() {} + IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {} + IReporter::~IReporter() {} + IReporterFactory::~IReporterFactory() {} + IReporterRegistry::~IReporterRegistry() {} + IStreamingReporter::~IStreamingReporter() {} + AssertionStats::~AssertionStats() {} + SectionStats::~SectionStats() {} + TestCaseStats::~TestCaseStats() {} + TestGroupStats::~TestGroupStats() {} + TestRunStats::~TestRunStats() {} + CumulativeReporterBase::SectionNode::~SectionNode() {} + CumulativeReporterBase::~CumulativeReporterBase() {} + + StreamingReporterBase::~StreamingReporterBase() {} + ConsoleReporter::~ConsoleReporter() {} + CompactReporter::~CompactReporter() {} + IRunner::~IRunner() {} + IMutableContext::~IMutableContext() {} + IConfig::~IConfig() {} + XmlReporter::~XmlReporter() {} + JunitReporter::~JunitReporter() {} + TestRegistry::~TestRegistry() {} + FreeFunctionTestCase::~FreeFunctionTestCase() {} + IGeneratorInfo::~IGeneratorInfo() {} + IGeneratorsForTest::~IGeneratorsForTest() {} + WildcardPattern::~WildcardPattern() {} + TestSpec::Pattern::~Pattern() {} + TestSpec::NamePattern::~NamePattern() {} + TestSpec::TagPattern::~TagPattern() {} + TestSpec::ExcludedPattern::~ExcludedPattern() {} + Matchers::Impl::MatcherUntypedBase::~MatcherUntypedBase() {} + + void Config::dummy() {} + + namespace TestCaseTracking { + ITracker::~ITracker() {} + TrackerBase::~TrackerBase() {} + SectionTracker::~SectionTracker() {} + IndexTracker::~IndexTracker() {} + } +} + +#ifdef __clang__ +#pragma clang diagnostic pop +#endif + +#endif + +#ifdef CATCH_CONFIG_MAIN +// #included from: internal/catch_default_main.hpp +#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED + +#ifndef __OBJC__ + +#if defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN) +// Standard C/C++ Win32 Unicode wmain entry point +extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) { +#else +// Standard C/C++ main entry point +int main (int argc, char * argv[]) { +#endif + + int result = Catch::Session().run( argc, argv ); + return ( result < 0xff ? result : 0xff ); +} + +#else // __OBJC__ + +// Objective-C entry point +int main (int argc, char * const argv[]) { +#if !CATCH_ARC_ENABLED + NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; +#endif + + Catch::registerTestMethods(); + int result = Catch::Session().run( argc, (char* const*)argv ); + +#if !CATCH_ARC_ENABLED + [pool drain]; +#endif + + return ( result < 0xff ? result : 0xff ); +} + +#endif // __OBJC__ + +#endif + +#ifdef CLARA_CONFIG_MAIN_NOT_DEFINED +# undef CLARA_CONFIG_MAIN +#endif + +////// + +// If this config identifier is defined then all CATCH macros are prefixed with CATCH_ +#ifdef CATCH_CONFIG_PREFIX_ALL + +#if defined(CATCH_CONFIG_FAST_COMPILE) +#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr ) +#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr ) +#else +#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr ) +#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr ) +#endif + +#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr ) +#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr ) +#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr ) +#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr ) + +#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, expr ) +#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr ) +#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr ) +#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr ) +#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr ) + +#define CATCH_CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr ) +#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr ) +#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr ) +#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr ) + +#define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg ) + +#if defined(CATCH_CONFIG_FAST_COMPILE) +#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg ) +#else +#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg ) +#endif + +#define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg ) +#define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg ) +#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg ) +#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) ) +#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) ) + +#ifdef CATCH_CONFIG_VARIADIC_MACROS + #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) + #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) + #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) + #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ ) + #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) + #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ ) + #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) + #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) +#else + #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) + #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) + #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) + #define CATCH_REGISTER_TEST_CASE( function, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( function, name, description ) + #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) + #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg ) + #define CATCH_FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg ) + #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg ) +#endif +#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) + +#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) +#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) + +#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) + +// "BDD-style" convenience wrappers +#ifdef CATCH_CONFIG_VARIADIC_MACROS +#define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ ) +#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) +#else +#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags ) +#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags ) +#endif +#define CATCH_GIVEN( desc ) CATCH_SECTION( std::string( "Given: ") + desc, "" ) +#define CATCH_WHEN( desc ) CATCH_SECTION( std::string( " When: ") + desc, "" ) +#define CATCH_AND_WHEN( desc ) CATCH_SECTION( std::string( " And: ") + desc, "" ) +#define CATCH_THEN( desc ) CATCH_SECTION( std::string( " Then: ") + desc, "" ) +#define CATCH_AND_THEN( desc ) CATCH_SECTION( std::string( " And: ") + desc, "" ) + +// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required +#else + +#if defined(CATCH_CONFIG_FAST_COMPILE) +#define REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE", Catch::ResultDisposition::Normal, expr ) +#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr ) + +#else +#define REQUIRE( expr ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, expr ) +#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr ) +#endif + +#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr ) +#define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr ) +#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr ) +#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr ) + +#define CHECK( expr ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, expr ) +#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr ) +#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr ) +#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr ) +#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr ) + +#define CHECK_THROWS( expr ) INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr ) +#define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr ) +#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr ) +#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr ) + +#define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg ) + +#if defined(CATCH_CONFIG_FAST_COMPILE) +#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg ) +#else +#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg ) +#endif + +#define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg ) +#define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg ) +#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg ) +#define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) ) +#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) ) + +#ifdef CATCH_CONFIG_VARIADIC_MACROS +#define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ ) +#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ ) +#define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ ) +#define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ ) +#define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ ) +#define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ ) +#define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) +#define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ ) +#else +#define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description ) + #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description ) + #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description ) + #define REGISTER_TEST_CASE( method, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( method, name, description ) + #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description ) + #define FAIL( msg ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg ) + #define FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg ) + #define SUCCEED( msg ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg ) +#endif +#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" ) + +#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) +#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) + +#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr ) + +#endif + +#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) + +// "BDD-style" convenience wrappers +#ifdef CATCH_CONFIG_VARIADIC_MACROS +#define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ ) +#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ ) +#else +#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags ) +#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags ) +#endif +#define GIVEN( desc ) SECTION( std::string(" Given: ") + desc, "" ) +#define WHEN( desc ) SECTION( std::string(" When: ") + desc, "" ) +#define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc, "" ) +#define THEN( desc ) SECTION( std::string(" Then: ") + desc, "" ) +#define AND_THEN( desc ) SECTION( std::string(" And: ") + desc, "" ) + +using Catch::Detail::Approx; + +// #included from: internal/catch_reenable_warnings.h + +#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED + +#ifdef __clang__ +# ifdef __ICC // icpc defines the __clang__ macro +# pragma warning(pop) +# else +# pragma clang diagnostic pop +# endif +#elif defined __GNUC__ +# pragma GCC diagnostic pop +#endif + +#endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED + diff --git a/tests/tests b/tests/tests new file mode 100755 index 0000000000000000000000000000000000000000..2bb9f3877e14811e4309b1a54652fdb502d580ab GIT binary patch literal 1433380 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

#WhE&%;8H73<;yke{ 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%0A8>KRr9Xls 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

k2OqQ4xP%Z_K`r+5Fb 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

~H|K1Rx~X~rR^}Ja@u+Ju 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 literal 0 HcmV?d00001 diff --git a/tests/tests-main.cpp b/tests/tests-main.cpp new file mode 100644 index 0000000..0c7c351 --- /dev/null +++ b/tests/tests-main.cpp @@ -0,0 +1,2 @@ +#define CATCH_CONFIG_MAIN +#include "catch.hpp" diff --git a/tests/tests-main.o b/tests/tests-main.o new file mode 100644 index 0000000000000000000000000000000000000000..32e6d9080090ab6b96cc3ab16efa52adedbe4372 GIT binary patch literal 1507392 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

v5F!k-+fnSxWKn)6cWpZfk19EEB2Rp1Hbc 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

x+2jwsvG0qXcm00j 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 arwj}%5EsOdGeFqKqV*0~3={;!fBzp(kb&p` literal 0 HcmV?d00001 diff --git a/tests/tests-readfile.cpp b/tests/tests-readfile.cpp new file mode 100644 index 0000000..fe6b0b5 --- /dev/null +++ b/tests/tests-readfile.cpp @@ -0,0 +1,15 @@ +#include "catch.hpp" +#include +#include "../src/readfile.h" + +TEST_CASE( "readfile works as specified", "[readfile]" ) { + std::string valid_path = "catch.hpp", invalid_path = "invalid.hpp"; + std::string buf; + + REQUIRE( ReadFile::run(valid_path, buf) == true ); + REQUIRE( buf.at(0) == '/' ); + + buf.clear(); + REQUIRE( ReadFile::run(invalid_path, buf) == false ); + REQUIRE( buf.length() == 0 ); +} diff --git a/tests/tests-replace.cpp b/tests/tests-replace.cpp new file mode 100644 index 0000000..2804e36 --- /dev/null +++ b/tests/tests-replace.cpp @@ -0,0 +1,19 @@ +#include "catch.hpp" +#include +#include "../src/replace.h" + +TEST_CASE( "replace works as specified", "[replace]" ) { + std::string orig = "when shall we three meet again"; + std::string find = "THREE"; + std::string replace = "four"; + + // case insensitive + std::string buf = orig; + REQUIRE( Replace::run(buf, find, replace, false) == 1 ); + REQUIRE( buf == "when shall we four meet again" ); + + // case sensitive + buf = orig; + REQUIRE( Replace::run(buf, find, replace, true) == 0 ); + REQUIRE( buf == "when shall we three meet again" ); +} diff --git a/tests/tests-stringset.cpp b/tests/tests-stringset.cpp new file mode 100644 index 0000000..d6db8f8 --- /dev/null +++ b/tests/tests-stringset.cpp @@ -0,0 +1,19 @@ +#include "catch.hpp" +#include +#include +#include "../src/stringset.h" + +TEST_CASE( "stringset works as specified", "[stringset]" ) { + std::string buf = "test"; + std::auto_ptr > dict ( new StringSet() ); + + REQUIRE( dict->find(buf) == 0 ); + REQUIRE( dict->empty() == true ); + REQUIRE( dict->count() == 0 ); + + dict->insert(buf); + + REQUIRE( dict->find(buf) != 0 ); + REQUIRE( dict->empty() == false); + REQUIRE( dict->count() == 1); +} diff --git a/tests/tests-stringset.o b/tests/tests-stringset.o new file mode 100644 index 0000000000000000000000000000000000000000..a7f6155f20bf6dbd1bdb3e06ff85bb86932bbc35 GIT binary patch literal 50792 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 literal 0 HcmV?d00001