3rd-party/catch2
1
0
Fork 0
mirror of https://github.com/catchorg/Catch2.git synced 2024-11-26 15:26:11 +01:00
Code Issues Packages Projects Releases Wiki Activity

Some formating clean-up

Browse Source
This commit is contained in:
Phil Nash 2011-01-28 18:56:26 +00:00
parent d944e69b18
commit 44488f6331
6 changed files with 160 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
internal/catch_generators_impl.hpp
View File

@ -21,9 +21,9 @@
namespace Catch namespace Catch
{ {
struct GeneratorInfo struct GeneratorInfo
{ {
///////////////////////////////////////////////////////////////////////
GeneratorInfo GeneratorInfo
( (
std::size_t size std::size_t size
@ -33,6 +33,7 @@ namespace Catch
{ {
} }
///////////////////////////////////////////////////////////////////////
bool moveNext bool moveNext
() ()
{ {
@ -44,6 +45,7 @@ namespace Catch
return true; return true;
} }
///////////////////////////////////////////////////////////////////////
std::size_t getCurrentIndex std::size_t getCurrentIndex
() ()
const const
@ -55,16 +57,21 @@ namespace Catch
std::size_t m_currentIndex; std::size_t m_currentIndex;
}; };
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class GeneratorsForTest class GeneratorsForTest
{ {
public: public:
///////////////////////////////////////////////////////////////////////
~GeneratorsForTest ~GeneratorsForTest
() ()
{ {
deleteAll( m_generatorsInOrder ); deleteAll( m_generatorsInOrder );
} }
///////////////////////////////////////////////////////////////////////
GeneratorInfo& getGeneratorInfo GeneratorInfo& getGeneratorInfo
( (
const std::string& fileInfo, const std::string& fileInfo,
@ -82,6 +89,7 @@ namespace Catch
return *it->second; return *it->second;
} }
///////////////////////////////////////////////////////////////////////
bool moveNext bool moveNext
() ()
{ {

2
internal/catch_hub.h
View File

@ -65,12 +65,14 @@ namespace Catch
( const std::string& fileInfo, ( const std::string& fileInfo,
size_t totalSize size_t totalSize
); );
static bool advanceGeneratorsForCurrentTest static bool advanceGeneratorsForCurrentTest
(); ();
private: private:
GeneratorsForTest* findGeneratorsForCurrentTest GeneratorsForTest* findGeneratorsForCurrentTest
(); ();
GeneratorsForTest& getGeneratorsForCurrentTest GeneratorsForTest& getGeneratorsForCurrentTest
(); ();

47
internal/catch_resultinfo.hpp
View File

@ -22,7 +22,8 @@ namespace Catch
public: public:
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
ResultInfo() ResultInfo
()
: m_line( 0 ), : m_line( 0 ),
m_result( ResultWas::Unknown ), m_result( ResultWas::Unknown ),
m_isNot( false ), m_isNot( false ),
@ -53,37 +54,49 @@ namespace Catch
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
bool ok() const bool ok
()
const
{ {
return ( m_result & ResultWas::FailureBit ) != ResultWas::FailureBit; return ( m_result & ResultWas::FailureBit ) != ResultWas::FailureBit;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
ResultWas::OfType getResultType() const ResultWas::OfType getResultType
()
const
{ {
return m_result; return m_result;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
bool hasExpression() const bool hasExpression
()
const
{ {
return !m_expr.empty(); return !m_expr.empty();
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
bool hasMessage() const bool hasMessage
()
const
{ {
return !m_message.empty(); return !m_message.empty();
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
std::string getExpression() const std::string getExpression
()
const
{ {
return m_expr; return m_expr;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
std::string getExpandedExpression() const std::string getExpandedExpression
()
const
{ {
if( !hasExpression() ) if( !hasExpression() )
return ""; return "";
@ -94,25 +107,33 @@ namespace Catch
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
std::string getMessage() const std::string getMessage
()
const
{ {
return m_message; return m_message;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
std::string getFilename() const std::string getFilename
()
const
{ {
return m_filename; return m_filename;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
std::size_t getLine() const std::size_t getLine
()
const
{ {
return m_line; return m_line;
} }
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
std::string getTestMacroName() const std::string getTestMacroName
()
const
{ {
return m_macroName; return m_macroName;
} }
@ -120,7 +141,9 @@ namespace Catch
protected: protected:
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
std::string getExpandedExpressionInternal() const std::string getExpandedExpressionInternal
()
const
{ {
if( m_op == "" || m_isNot ) if( m_op == "" || m_isNot )
return m_lhs.empty() ? m_expr : m_op + m_lhs; return m_lhs.empty() ? m_expr : m_op + m_lhs;

64
internal/catch_runner_impl.hpp
View File

@ -24,7 +24,11 @@ namespace Catch
class TestSpec class TestSpec
{ {
public: public:
TestSpec( const std::string& rawSpec ) ///////////////////////////////////////////////////////////////////////
TestSpec
(
const std::string& rawSpec
)
: m_rawSpec( rawSpec ), : m_rawSpec( rawSpec ),
m_isWildcarded( false ) m_isWildcarded( false )
{ {
@ -35,7 +39,12 @@ namespace Catch
} }
} }
bool matches( const std::string& testName ) const ///////////////////////////////////////////////////////////////////////
bool matches
(
const std::string& testName
)
const
{ {
if( !m_isWildcarded ) if( !m_isWildcarded )
return m_rawSpec == testName; return m_rawSpec == testName;
@ -48,37 +57,60 @@ namespace Catch
bool m_isWildcarded; bool m_isWildcarded;
}; };
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class RunningTest class RunningTest
{ {
public: public:
explicit RunningTest( const TestCaseInfo* info = NULL ) ///////////////////////////////////////////////////////////////////////
explicit RunningTest
(
const TestCaseInfo* info = NULL
)
: m_info( info ), : m_info( info ),
m_sectionSeen( false ) m_sectionSeen( false )
{ {
} }
size_t sectionsSeenCount() const ///////////////////////////////////////////////////////////////////////
size_t sectionsSeenCount
()
const
{ {
return m_sectionsSeen.size(); return m_sectionsSeen.size();
} }
bool wasSectionSeen() const ///////////////////////////////////////////////////////////////////////
bool wasSectionSeen
()
const
{ {
return m_sectionSeen; return m_sectionSeen;
} }
void resetSectionSeen()
///////////////////////////////////////////////////////////////////////
void resetSectionSeen
()
{ {
m_sectionSeen = false; m_sectionSeen = false;
} }
bool addSection( const std::string& name ) ///////////////////////////////////////////////////////////////////////
bool addSection
(
const std::string& name
)
{ {
if( m_sectionsSeen.find( name ) != m_sectionsSeen.end() ) if( m_sectionsSeen.find( name ) != m_sectionsSeen.end() )
return false; return false;
m_sectionsSeen.insert( name ); m_sectionsSeen.insert( name );
return m_sectionSeen = true; return m_sectionSeen = true;
} }
const TestCaseInfo& getTestCaseInfo() const ///////////////////////////////////////////////////////////////////////
const TestCaseInfo& getTestCaseInfo
()
const
{ {
return *m_info; return *m_info;
} }
@ -90,10 +122,18 @@ namespace Catch
}; };
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class StreamRedirect class StreamRedirect
{ {
public: public:
StreamRedirect( std::ostream& stream, std::string& targetString ) ///////////////////////////////////////////////////////////////////////
StreamRedirect
(
std::ostream& stream,
std::string& targetString
)
: m_stream( stream ), : m_stream( stream ),
m_prevBuf( stream.rdbuf() ), m_prevBuf( stream.rdbuf() ),
m_targetString( targetString ) m_targetString( targetString )
@ -101,7 +141,9 @@ namespace Catch
stream.rdbuf( m_oss.rdbuf() ); stream.rdbuf( m_oss.rdbuf() );
} }
~StreamRedirect() ///////////////////////////////////////////////////////////////////////
~StreamRedirect
()
{ {
m_targetString = m_oss.str(); m_targetString = m_oss.str();
m_stream.rdbuf( m_prevBuf ); m_stream.rdbuf( m_prevBuf );
@ -114,6 +156,8 @@ namespace Catch
std::string& m_targetString; std::string& m_targetString;
}; };
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
class Runner : public IResultCapture, public IRunner class Runner : public IResultCapture, public IRunner
{ {

15
internal/catch_section.hpp
View File

@ -22,20 +22,29 @@ namespace Catch
class Section class Section
{ {
public: public:
Section( const std::string& name, const std::string& description ) ///////////////////////////////////////////////////////////////////////
Section
(
const std::string& name,
const std::string& description
)
: m_name( name ), : m_name( name ),
m_sectionIncluded( Hub::getResultCapture().sectionStarted( name, description, m_successes, m_failures ) ) m_sectionIncluded( Hub::getResultCapture().sectionStarted( name, description, m_successes, m_failures ) )
{ {
} }
~Section() ///////////////////////////////////////////////////////////////////////
~Section
()
{ {
if( m_sectionIncluded ) if( m_sectionIncluded )
Hub::getResultCapture().sectionEnded( m_name, m_successes, m_failures ); Hub::getResultCapture().sectionEnded( m_name, m_successes, m_failures );
} }
///////////////////////////////////////////////////////////////////////
// This indicates whether the section should be executed or not // This indicates whether the section should be executed or not
operator bool() operator bool
()
{ {
return m_sectionIncluded; return m_sectionIncluded;
} }

49
internal/catch_test_case_registry_impl.hpp
View File

@ -23,12 +23,18 @@ namespace Catch
class TestRegistry : public ITestCaseRegistry class TestRegistry : public ITestCaseRegistry
{ {
public: public:
TestRegistry() ///////////////////////////////////////////////////////////////////////////
TestRegistry
()
: m_unnamedCount( 0 ) : m_unnamedCount( 0 )
{ {
} }
virtual void registerTest( const TestCaseInfo& testInfo ) ///////////////////////////////////////////////////////////////////////////
virtual void registerTest
(
const TestCaseInfo& testInfo
)
{ {
if( testInfo.getName() == "" ) if( testInfo.getName() == "" )
{ {
@ -43,7 +49,10 @@ namespace Catch
} }
} }
virtual const std::vector<TestCaseInfo>& getAllTests() const ///////////////////////////////////////////////////////////////////////////
virtual const std::vector<TestCaseInfo>& getAllTests
()
const
{ {
return m_functionsInOrder; return m_functionsInOrder;
} }
@ -55,29 +64,53 @@ namespace Catch
size_t m_unnamedCount; size_t m_unnamedCount;
}; };
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
struct FreeFunctionTestCase : ITestCase struct FreeFunctionTestCase : ITestCase
{ {
FreeFunctionTestCase( TestFunction fun ) ///////////////////////////////////////////////////////////////////////////
FreeFunctionTestCase
(
TestFunction fun
)
: fun( fun ) : fun( fun )
{} {}
virtual void invoke() const ///////////////////////////////////////////////////////////////////////////
virtual void invoke
()
const
{ {
fun(); fun();
} }
virtual ITestCase* clone() const ///////////////////////////////////////////////////////////////////////////
virtual ITestCase* clone
()
const
{ {
return new FreeFunctionTestCase( fun ); return new FreeFunctionTestCase( fun );
} }
virtual bool operator == ( const ITestCase& other ) const ///////////////////////////////////////////////////////////////////////////
virtual bool operator ==
(
const ITestCase& other
)
const
{ {
const FreeFunctionTestCase* ffOther = dynamic_cast<const FreeFunctionTestCase*> ( &other ); const FreeFunctionTestCase* ffOther = dynamic_cast<const FreeFunctionTestCase*> ( &other );
return ffOther && fun == ffOther->fun; return ffOther && fun == ffOther->fun;
} }
virtual bool operator < ( const ITestCase& other ) const ///////////////////////////////////////////////////////////////////////////
virtual bool operator <
(
const ITestCase& other
)
const
{ {
const FreeFunctionTestCase* ffOther = dynamic_cast<const FreeFunctionTestCase*> ( &other ); const FreeFunctionTestCase* ffOther = dynamic_cast<const FreeFunctionTestCase*> ( &other );
return ffOther && fun < ffOther->fun; return ffOther && fun < ffOther->fun;