3rd-party
/
catch2
mirror of https://github.com/catchorg/Catch2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

More reformatting

This commit is contained in:
Phil Nash 2012-05-15 08:02:36 +01:00
parent 2efc1146bf
commit d0be9ed5d9
11 changed files with 124 additions and 396 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
include/internal/catch_common.h
View File

@ -25,8 +25,8 @@
#include <stdexcept>
#include <algorithm>
namespace Catch
{
namespace Catch {
class NonCopyable {
NonCopyable( const NonCopyable& );
void operator = ( const NonCopyable& );
@ -64,8 +64,8 @@ namespace Catch
std::for_each( container.begin(), container.end(), function );
}
struct SourceLineInfo
{
struct SourceLineInfo {
SourceLineInfo() : line( 0 ){}
SourceLineInfo( const std::string& _file, std::size_t _line )
: file( _file ),

14
include/internal/catch_console_colour.hpp
View File

@ -1,29 +1,23 @@
/*
* catch_console_colour.hpp
* Catch
*
* Created by Phil on 25/2/2012.
* Copyright 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_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
#include "catch_common.h"
namespace Catch
{
namespace Catch {
struct ConsoleColourImpl;
class TextColour : NonCopyable
{
class TextColour : NonCopyable {
public:
enum Colours
{
enum Colours {
None,
FileName,

27
include/internal/catch_debugger.hpp
View File

@ -1,7 +1,4 @@
/*
* catch_debugger.hpp
* Catch
*
* Created by Phil on 27/12/2010.
* Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
*
@ -10,7 +7,6 @@
*
* Provides a BreakIntoDebugger() macro for Windows and Mac (so far)
*/
#ifndef TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED
@ -32,15 +28,15 @@
#include <unistd.h>
#include <sys/sysctl.h>
namespace Catch
{
namespace Catch{
// The following function is taken directly from the following technical note:
// http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
inline bool isDebuggerActive()
// Returns true if the current process is being debugged (either
// running under the debugger or has a debugger attached post facto).
{
inline bool isDebuggerActive(){
int junk;
int mib[4];
struct kinfo_proc info;
@ -76,8 +72,7 @@
#ifdef DEBUG
#if defined(__ppc64__) || defined(__ppc__)
#define BreakIntoDebugger() \
if( Catch::isDebuggerActive() ) \
{ \
if( Catch::isDebuggerActive() ) { \
__asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
: : : "memory","r0","r3","r4" ); \
}
@ -91,16 +86,14 @@
#elif defined(_MSC_VER)
extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
#define BreakIntoDebugger() if (IsDebuggerPresent() ) { __debugbreak(); }
inline bool isDebuggerActive()
{
inline bool isDebuggerActive() {
return IsDebuggerPresent() != 0;
}
#elif defined(__MINGW32__)
extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
extern "C" __declspec(dllimport) void __stdcall DebugBreak();
#define BreakIntoDebugger() if (IsDebuggerPresent() ) { DebugBreak(); }
inline bool isDebuggerActive()
{
inline bool isDebuggerActive() {
return IsDebuggerPresent() != 0;
}
#else
@ -110,13 +103,11 @@
#ifdef CATCH_PLATFORM_WINDOWS
extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA( const char* );
inline void writeToDebugConsole( const std::string& text )
{
inline void writeToDebugConsole( const std::string& text ) {
::OutputDebugStringA( text.c_str() );
}
#else
inline void writeToDebugConsole( const std::string& text )
{
inline void writeToDebugConsole( const std::string& text ) {
// !TBD: Need a version for Mac/ XCode and other IDEs
std::cout << text;
}

69
include/internal/catch_interfaces_capture.h
View File

@ -1,13 +1,9 @@
/*
* catch_interfaces_capture.h
* Catch
*
* Created by Phil on 07/01/2011.
* Copyright 2011 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_CATCH_INTERFACES_CAPTURE_H_INCLUDED
#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED
@ -16,59 +12,34 @@
#include "catch_result_type.h"
#include "catch_totals.hpp"
namespace Catch
{
namespace Catch {
class TestCaseInfo;
class ScopedInfo;
class ResultInfoBuilder;
class ResultInfo;
struct IResultCapture
{
virtual ~IResultCapture
()
{}
struct IResultCapture {
virtual ~IResultCapture(){}
virtual void testEnded
( const ResultInfo& result
) = 0;
virtual bool sectionStarted
( const std::string& name,
const std::string& description,
const SourceLineInfo& lineInfo,
Counts& assertions
) = 0;
virtual void sectionEnded
( const std::string& name,
const Counts& assertions
) = 0;
virtual void pushScopedInfo
( ScopedInfo* scopedInfo
) = 0;
virtual void popScopedInfo
( ScopedInfo* scopedInfo
) = 0;
virtual bool shouldDebugBreak
() const = 0;
virtual void testEnded( const ResultInfo& result ) = 0;
virtual bool sectionStarted( const std::string& name,
const std::string& description,
const SourceLineInfo& lineInfo,
Counts& assertions ) = 0;
virtual void sectionEnded( const std::string& name, const Counts& assertions ) = 0;
virtual void pushScopedInfo( ScopedInfo* scopedInfo ) = 0;
virtual void popScopedInfo( ScopedInfo* scopedInfo ) = 0;
virtual bool shouldDebugBreak() const = 0;
virtual ResultAction::Value acceptResult
( bool result
) = 0;
virtual ResultAction::Value acceptResult
( ResultWas::OfType result
) = 0;
virtual ResultAction::Value acceptExpression
( const ResultInfoBuilder& resultInfo
) = 0;
virtual void acceptMessage
( const std::string& msg
) = 0;
virtual std::string getCurrentTestName
() const = 0;
virtual const ResultInfo* getLastResult
() const = 0;
virtual ResultAction::Value acceptResult( bool result ) = 0;
virtual ResultAction::Value acceptResult( ResultWas::OfType result ) = 0;
virtual ResultAction::Value acceptExpression( const ResultInfoBuilder& resultInfo ) = 0;
virtual void acceptMessage( const std::string& msg ) = 0;
virtual std::string getCurrentTestName() const = 0;
virtual const ResultInfo* getLastResult() const = 0;
};
}

54
include/internal/catch_interfaces_exception.h
View File

@ -1,67 +1,45 @@
/*
* catch_exception_interfaces.h
* Catch
*
* Created by Phil on 20/04/2011.
* Copyright 2011 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_CATCH_INTERFACES_EXCEPTIONS_H_INCLUDED
#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTIONS_H_INCLUDED
#include <string>
namespace Catch
{
namespace Catch {
typedef std::string(*exceptionTranslateFunction)();
struct IExceptionTranslator
{
struct IExceptionTranslator {
virtual ~IExceptionTranslator(){}
virtual std::string translate() const = 0;
};
struct IExceptionTranslatorRegistry
{
virtual ~IExceptionTranslatorRegistry
()
{}
virtual void registerTranslator
( IExceptionTranslator* translator
) = 0;
virtual std::string translateActiveException
() const = 0;
struct IExceptionTranslatorRegistry {
virtual ~IExceptionTranslatorRegistry(){}
virtual void registerTranslator( IExceptionTranslator* translator ) = 0;
virtual std::string translateActiveException() const = 0;
};
class ExceptionTranslatorRegistrar
{
class ExceptionTranslatorRegistrar {
template<typename T>
class ExceptionTranslator : public IExceptionTranslator
{
class ExceptionTranslator : public IExceptionTranslator {
public:
ExceptionTranslator
(
std::string(*translateFunction)( T& )
)
ExceptionTranslator( std::string(*translateFunction)( T& ) )
: m_translateFunction( translateFunction )
{}
virtual std::string translate
()
const
{
try
{
virtual std::string translate() const {
try {
throw;
}
catch( T& ex )
{
catch( T& ex ) {
return m_translateFunction( ex );
}
}
@ -72,11 +50,7 @@ namespace Catch
public:
template<typename T>
ExceptionTranslatorRegistrar
(
std::string(*translateFunction)( T& )
)
{
ExceptionTranslatorRegistrar( std::string(*translateFunction)( T& ) ) {
Catch::Context::getExceptionTranslatorRegistry().registerTranslator
( new ExceptionTranslator<T>( translateFunction ) );
}

3
include/internal/catch_interfaces_reporter.h
View File

@ -57,8 +57,7 @@ namespace Catch
virtual const FactoryMap& getFactories() const = 0;
};
inline std::string trim( const std::string& str )
{
inline std::string trim( const std::string& str ) {
std::string::size_type start = str.find_first_not_of( "\n\r\t " );
std::string::size_type end = str.find_last_not_of( "\n\r\t " );

29
include/internal/catch_interfaces_runner.h
View File

@ -1,13 +1,9 @@
/*
* catch_interfaces_runner.h
* Catch
*
* Created by Phil on 07/01/2011.
* Copyright 2011 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_INTERNAL_CATCH_INTERFACES_RUNNER_H_INCLUDED
#define TWOBLUECUBES_INTERNAL_CATCH_INTERFACES_RUNNER_H_INCLUDED
@ -16,27 +12,14 @@
#include <string>
namespace Catch
{
namespace Catch {
class TestCaseInfo;
struct IRunner
{
virtual ~IRunner
()
{}
virtual void runAll
( bool runHiddenTests = false
) = 0;
virtual std::size_t runMatching
( const std::string& rawTestSpec
) = 0;
virtual Totals getTotals
() const = 0;
struct IRunner {
virtual ~IRunner() {}
virtual void runAll( bool runHiddenTests = false ) = 0;
virtual std::size_t runMatching( const std::string& rawTestSpec ) = 0;
virtual Totals getTotals() const = 0;
};
}

56
include/internal/catch_interfaces_testcase.h
View File

@ -1,64 +1,32 @@
/*
* catch_interfaces_testcase.h
* Catch
*
* Created by Phil on 07/01/2011.
* Copyright 2011 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_CATCH_INTERFACES_TESTCASE_H_INCLUDED
#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED
#include <vector>
namespace Catch
{
struct ITestCase
{
virtual ~ITestCase
()
{}
virtual void invoke
() const = 0;
virtual ITestCase* clone
() const = 0;
virtual bool operator ==
( const ITestCase& other
) const = 0;
virtual bool operator <
( const ITestCase& other
) const = 0;
namespace Catch {
struct ITestCase {
virtual ~ITestCase(){}
virtual void invoke () const = 0;
virtual ITestCase* clone() const = 0;
virtual bool operator == ( const ITestCase& other ) const = 0;
virtual bool operator < ( const ITestCase& other ) const = 0;
};
class TestCaseInfo;
struct ITestCaseRegistry
{
virtual ~ITestCaseRegistry
()
{}
virtual void registerTest
( const TestCaseInfo& testInfo
) = 0;
virtual const std::vector<TestCaseInfo>& getAllTests
() const = 0;
virtual std::vector<TestCaseInfo> getMatchingTestCases
( const std::string& rawTestSpec
) = 0;
struct ITestCaseRegistry {
virtual ~ITestCaseRegistry(){}
virtual void registerTest( const TestCaseInfo& testInfo ) = 0;
virtual const std::vector<TestCaseInfo>& getAllTests() const = 0;
virtual std::vector<TestCaseInfo> getMatchingTestCases( const std::string& rawTestSpec ) = 0;
};
}
#endif // TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED

11
include/internal/catch_ptr.hpp
View File

@ -1,27 +1,22 @@
/*
* catch_ptr.hpp
* Catch
*
* Created by Phil on 02/05/2012.
* Copyright 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_CATCH_PTR_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED
#include "catch_common.h"
namespace Catch
{
namespace Catch {
// An intrusive reference counting smart pointer.
// T must implement addRef() and release() methods
// typically implementing the IShared interface
template<typename T>
class Ptr
{
class Ptr {
public:
Ptr() : m_p( NULL ){}
Ptr( T* p ) : m_p( p ){

51
include/internal/catch_stream.hpp
View File

@ -1,7 +1,4 @@
/*
* catch_stream.hpp
* Catch
*
* Created by Phil on 17/01/2011.
* Copyright 2011 Two Blue Cubes Ltd. All rights reserved.
*
@ -9,47 +6,33 @@
* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*
*/
#ifndef TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED
#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED
#include <stdexcept>
#include <cstdio>
namespace Catch
{
namespace Catch {
template<typename WriterF, size_t bufferSize=256>
class StreamBufImpl : public StreamBufBase
{
class StreamBufImpl : public StreamBufBase {
char data[bufferSize];
WriterF m_writer;
public:
///////////////////////////////////////////////////////////////////////
StreamBufImpl
()
{
StreamBufImpl() {
setp( data, data + sizeof(data) );
}
///////////////////////////////////////////////////////////////////////
~StreamBufImpl
()
{
~StreamBufImpl() {
sync();
}
private:
///////////////////////////////////////////////////////////////////////
int overflow
(
int c
)
{
int overflow( int c ) {
sync();
if( c != EOF )
{
if( c != EOF ) {
if( pbase() == epptr() )
m_writer( std::string( 1, static_cast<char>( c ) ) );
else
@ -58,12 +41,8 @@ namespace Catch
return 0;
}
///////////////////////////////////////////////////////////////////////
int sync
()
{
if( pbase() != pptr() )
{
int sync() {
if( pbase() != pptr() ) {
m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
setp( pbase(), epptr() );
}
@ -71,17 +50,11 @@ namespace Catch
}
};
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
struct OutputDebugWriter
{
///////////////////////////////////////////////////////////////////////
void operator()
(
const std::string &str
)
{
struct OutputDebugWriter {
void operator()( const std::string &str ) {
writeToDebugConsole( str );
}
};

198
include/internal/catch_xmlwriter.hpp
View File

@ -1,7 +1,4 @@
/*
* catch_xmlwriter.hpp
* Catch
*
* Created by Phil on 09/12/2010.
* Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
*
@ -15,60 +12,34 @@
#include <string>
#include <vector>
namespace Catch
{
class XmlWriter
{
namespace Catch {
class XmlWriter {
public:
class ScopedElement
{
class ScopedElement {
public:
///////////////////////////////////////////////////////////////////
ScopedElement
(
XmlWriter* writer
)
ScopedElement( XmlWriter* writer )
: m_writer( writer )
{
}
{}
///////////////////////////////////////////////////////////////////
ScopedElement
(
const ScopedElement& other
)
: m_writer( other.m_writer )
{
ScopedElement( const ScopedElement& other )
: m_writer( other.m_writer ){
other.m_writer = NULL;
}
///////////////////////////////////////////////////////////////////
~ScopedElement
()
{
~ScopedElement() {
if( m_writer )
m_writer->endElement();
}
///////////////////////////////////////////////////////////////////
ScopedElement& writeText
(
const std::string& text
)
{
ScopedElement& writeText( const std::string& text ) {
m_writer->writeText( text );
return *this;
}
///////////////////////////////////////////////////////////////////
template<typename T>
ScopedElement& writeAttribute
(
const std::string& name,
const T& attribute
)
{
ScopedElement& writeAttribute( const std::string& name, const T& attribute ) {
m_writer->writeAttribute( name, attribute );
return *this;
}
@ -77,53 +48,30 @@ namespace Catch
mutable XmlWriter* m_writer;
};
///////////////////////////////////////////////////////////////////////
XmlWriter
()
XmlWriter()
: m_tagIsOpen( false ),
m_needsNewline( false ),
m_os( &std::cout )
{
}
{}
///////////////////////////////////////////////////////////////////////
XmlWriter
(
std::ostream& os
)
XmlWriter( std::ostream& os )
: m_tagIsOpen( false ),
m_needsNewline( false ),
m_os( &os )
{
}
{}
///////////////////////////////////////////////////////////////////////
~XmlWriter
()
{
~XmlWriter() {
while( !m_tags.empty() )
{
endElement();
}
}
///////////////////////////////////////////////////////////////////////
XmlWriter& operator =
(
const XmlWriter& other
)
{
XmlWriter& operator = ( const XmlWriter& other ) {
XmlWriter temp( other );
swap( temp );
return *this;
}
///////////////////////////////////////////////////////////////////////
void swap
(
XmlWriter& other
)
{
void swap( XmlWriter& other ) {
std::swap( m_tagIsOpen, other.m_tagIsOpen );
std::swap( m_needsNewline, other.m_needsNewline );
std::swap( m_tags, other.m_tags );
@ -131,12 +79,7 @@ namespace Catch
std::swap( m_os, other.m_os );
}
///////////////////////////////////////////////////////////////////////
XmlWriter& startElement
(
const std::string& name
)
{
XmlWriter& startElement( const std::string& name ) {
ensureTagClosed();
newlineIfNecessary();
stream() << m_indent << "<" << name;
@ -146,45 +89,28 @@ namespace Catch
return *this;
}
///////////////////////////////////////////////////////////////////////
ScopedElement scopedElement
(
const std::string& name
)
{
ScopedElement scopedElement( const std::string& name ) {
ScopedElement scoped( this );
startElement( name );
return scoped;
}
///////////////////////////////////////////////////////////////////////
XmlWriter& endElement
()
{
XmlWriter& endElement() {
newlineIfNecessary();
m_indent = m_indent.substr( 0, m_indent.size()-2 );
if( m_tagIsOpen )
{
if( m_tagIsOpen ) {
stream() << "/>\n";
m_tagIsOpen = false;
}
else
{
else {
stream() << m_indent << "</" << m_tags.back() << ">\n";
}
m_tags.pop_back();
return *this;
}
///////////////////////////////////////////////////////////////////////
XmlWriter& writeAttribute
(
const std::string& name,
const std::string& attribute
)
{
if( !name.empty() && !attribute.empty() )
{
XmlWriter& writeAttribute( const std::string& name, const std::string& attribute ) {
if( !name.empty() && !attribute.empty() ) {
stream() << " " << name << "=\"";
writeEncodedText( attribute );
stream() << "\"";
@ -192,40 +118,20 @@ namespace Catch
return *this;
}
///////////////////////////////////////////////////////////////////////
XmlWriter& writeAttribute
(
const std::string& name,
bool attribute
)
{
XmlWriter& writeAttribute( const std::string& name, bool attribute ) {
stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\"";
return *this;
}
///////////////////////////////////////////////////////////////////////
template<typename T>
XmlWriter& writeAttribute
(
const std::string& name,
const T& attribute
)
{
XmlWriter& writeAttribute( const std::string& name, const T& attribute ) {
if( !name.empty() )
{
stream() << " " << name << "=\"" << attribute << "\"";
}
return *this;
}
///////////////////////////////////////////////////////////////////////
XmlWriter& writeText
(
const std::string& text
)
{
if( !text.empty() )
{
XmlWriter& writeText( const std::string& text ) {
if( !text.empty() ){
bool tagWasOpen = m_tagIsOpen;
ensureTagClosed();
if( tagWasOpen )
@ -236,22 +142,14 @@ namespace Catch
return *this;
}
///////////////////////////////////////////////////////////////////////
XmlWriter& writeComment
(
const std::string& text
)
{
XmlWriter& writeComment( const std::string& text ) {
ensureTagClosed();
stream() << m_indent << "<!--" << text << "-->";
m_needsNewline = true;
return *this;
}
///////////////////////////////////////////////////////////////////////
XmlWriter& writeBlankLine
()
{
XmlWriter& writeBlankLine() {
ensureTagClosed();
stream() << "\n";
return *this;
@ -259,50 +157,32 @@ namespace Catch
private:
///////////////////////////////////////////////////////////////////////
std::ostream& stream
()
{
std::ostream& stream() {
return *m_os;
}
///////////////////////////////////////////////////////////////////////
void ensureTagClosed
()
{
if( m_tagIsOpen )
{
void ensureTagClosed() {
if( m_tagIsOpen ) {
stream() << ">\n";
m_tagIsOpen = false;
}
}
///////////////////////////////////////////////////////////////////////
void newlineIfNecessary
()
{
if( m_needsNewline )
{
void newlineIfNecessary() {
if( m_needsNewline ) {
stream() << "\n";
m_needsNewline = false;
}
}
///////////////////////////////////////////////////////////////////////
void writeEncodedText
(
const std::string& text
)
{
void writeEncodedText( const std::string& text ) {
static const char* charsToEncode = "<&\"";
std::string mtext = text;
std::string::size_type pos = mtext.find_first_of( charsToEncode );
while( pos != std::string::npos )
{
while( pos != std::string::npos ) {
stream() << mtext.substr( 0, pos );
switch( mtext[pos] )
{
switch( mtext[pos] ) {
case '<':
stream() << "&lt;";
break;