diff --git a/include/internal/catch_commandline.hpp b/include/internal/catch_commandline.hpp index 7fa7e573..84926719 100644 --- a/include/internal/catch_commandline.hpp +++ b/include/internal/catch_commandline.hpp @@ -1,27 +1,17 @@ /* - * catch_commandline.hpp - * Catch - * * Created by Phil on 02/11/2010. * Copyright 2010 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_COMMANDLINE_HPP_INCLUDED #define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED #include "catch_config.hpp" #include "catch_runner_impl.hpp" -namespace Catch -{ - // !TBD: This could be refactored to be more "declarative" - // have a table up front that relates the mode, option strings, # arguments, names of arguments - // - may not be worth it at this scale - +namespace Catch { // -l, --list tests [xml] lists available tests (optionally in xml) // -l, --list reporters [xml] lists available reports (optionally in xml) // -l, --list all [xml] lists available tests and reports (optionally in xml) @@ -31,10 +21,9 @@ namespace Catch // -s, --success report successful cases too // -b, --break breaks into debugger on test failure // -n, --name specifies an optional name for the test run - class ArgParser : NonCopyable - { - enum Mode - { + class ArgParser : NonCopyable { + + enum Mode { modeNone, modeList, modeTest, @@ -49,20 +38,12 @@ namespace Catch }; public: - /////////////////////////////////////////////////////////////////////// - ArgParser - ( - int argc, - char * const argv[], - Config& config - ) + ArgParser ( int argc, char * const argv[], Config& config ) : m_mode( modeNone ), - m_config( config ) - { - for( int i=1; i < argc; ++i ) - { - if( argv[i][0] == '-' ) - { + m_config( config ) { + + for( int i=1; i < argc; ++i ) { + if( argv[i][0] == '-' ) { std::string cmd = ( argv[i] ); if( cmd == "-l" || cmd == "--list" ) changeMode( cmd, modeList ); @@ -81,8 +62,7 @@ namespace Catch else if( cmd == "-h" || cmd == "-?" || cmd == "--help" ) changeMode( cmd, modeHelp ); } - else - { + else { m_args.push_back( argv[i] ); } if( m_mode == modeError ) @@ -92,15 +72,11 @@ namespace Catch } private: - /////////////////////////////////////////////////////////////////////// - std::string argsAsString - () - { + std::string argsAsString() { std::ostringstream oss; std::vector::const_iterator it = m_args.begin(); std::vector::const_iterator itEnd = m_args.end(); - for( bool first = true; it != itEnd; ++it, first = false ) - { + for( bool first = true; it != itEnd; ++it, first = false ) { if( !first ) oss << " "; oss << *it; @@ -108,30 +84,20 @@ namespace Catch return oss.str(); } - /////////////////////////////////////////////////////////////////////// - void changeMode - ( - const std::string& cmd, - Mode mode - ) - { + void changeMode( const std::string& cmd, Mode mode ) { m_command = cmd; - switch( m_mode ) - { + switch( m_mode ) { case modeNone: if( m_args.size() > 0 ) return setErrorMode( "Unexpected arguments before " + m_command + ": " + argsAsString() ); break; case modeList: - if( m_args.size() > 2 ) - { + if( m_args.size() > 2 ) { return setErrorMode( m_command + " expected upto 2 arguments but recieved: " + argsAsString() ); } - else - { + else { Config::List::What listSpec = Config::List::All; - if( m_args.size() >= 1 ) - { + if( m_args.size() >= 1 ) { if( m_args[0] == "tests" ) listSpec = Config::List::Tests; else if( m_args[0] == "reporters" ) @@ -139,8 +105,7 @@ namespace Catch else return setErrorMode( m_command + " expected [tests] or [reporters] but recieved: [" + m_args[0] + "]" ); } - if( m_args.size() >= 2 ) - { + if( m_args.size() >= 2 ) { if( m_args[1] == "xml" ) listSpec = static_cast( listSpec | Config::List::AsXml ); else if( m_args[1] == "text" ) @@ -202,12 +167,7 @@ namespace Catch m_mode = mode; } - /////////////////////////////////////////////////////////////////////// - void setErrorMode - ( - const std::string& errorMessage - ) - { + void setErrorMode( const std::string& errorMessage ) { m_mode = modeError; m_command = ""; m_config.setError( errorMessage ); diff --git a/include/internal/catch_config.hpp b/include/internal/catch_config.hpp index c9595862..6f26a64d 100644 --- a/include/internal/catch_config.hpp +++ b/include/internal/catch_config.hpp @@ -1,15 +1,10 @@ /* - * catch_config.hpp - * Catch - * * Created by Phil on 08/11/2010. * Copyright 2010 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_RUNNERCONFIG_HPP_INCLUDED #define TWOBLUECUBES_CATCH_RUNNERCONFIG_HPP_INCLUDED @@ -21,24 +16,20 @@ #include #include -namespace Catch -{ - - class Config : public IReporterConfig - { +namespace Catch { + + class Config : public IReporterConfig { private: Config( const Config& other ); Config& operator = ( const Config& other ); public: - struct Include { enum What - { + struct Include { enum What { FailedOnly, SuccessfulResults }; }; - struct List{ enum What - { + struct List{ enum What { None = 0, Reports = 1, @@ -54,7 +45,6 @@ namespace Catch }; }; - /////////////////////////////////////////////////////////////////////////// Config() : m_listSpec( List::None ), m_shouldDebugBreak( false ), @@ -64,167 +54,115 @@ namespace Catch m_includeWhat( Include::FailedOnly ) {} - /////////////////////////////////////////////////////////////////////////// - ~Config() - { + ~Config() { m_os.rdbuf( std::cout.rdbuf() ); delete m_streambuf; } - /////////////////////////////////////////////////////////////////////////// - void setReporter( const std::string& reporterName ) - { + void setReporter( const std::string& reporterName ) { if( m_reporter.get() ) return setError( "Only one reporter may be specified" ); setReporter( Context::getReporterRegistry().create( reporterName, *this ) ); } - /////////////////////////////////////////////////////////////////////////// - void addTestSpec( const std::string& testSpec ) - { + void addTestSpec( const std::string& testSpec ) { m_testSpecs.push_back( testSpec ); } - /////////////////////////////////////////////////////////////////////////// - bool testsSpecified() const - { + bool testsSpecified() const { return !m_testSpecs.empty(); } - /////////////////////////////////////////////////////////////////////////// - const std::vector& getTestSpecs() const - { + const std::vector& getTestSpecs() const { return m_testSpecs; } - /////////////////////////////////////////////////////////////////////////// - List::What getListSpec( void ) const - { + List::What getListSpec( void ) const { return m_listSpec; } - /////////////////////////////////////////////////////////////////////////// - void setListSpec( List::What listSpec ) - { + void setListSpec( List::What listSpec ) { m_listSpec = listSpec; } - /////////////////////////////////////////////////////////////////////////// - void setFilename( const std::string& filename ) - { + void setFilename( const std::string& filename ) { m_filename = filename; } - /////////////////////////////////////////////////////////////////////////// - const std::string& getFilename() const - { + const std::string& getFilename() const { return m_filename; } - /////////////////////////////////////////////////////////////////////////// - const std::string& getMessage() const - { + const std::string& getMessage() const { return m_message; } - /////////////////////////////////////////////////////////////////////////// - void setError( const std::string& errorMessage ) - { + void setError( const std::string& errorMessage ) { m_message = errorMessage + "\n\n" + "Usage: ..."; } - /////////////////////////////////////////////////////////////////////////// - void setReporter( IReporter* reporter ) - { + void setReporter( IReporter* reporter ) { m_reporter = reporter; } - /////////////////////////////////////////////////////////////////////////// - Ptr getReporter() - { + Ptr getReporter() { if( !m_reporter.get() ) const_cast( this )->setReporter( Context::getReporterRegistry().create( "basic", *this ) ); return m_reporter; } - /////////////////////////////////////////////////////////////////////////// - List::What listWhat() const - { + List::What listWhat() const { return static_cast( m_listSpec & List::WhatMask ); } - /////////////////////////////////////////////////////////////////////////// - List::What listAs() const - { + List::What listAs() const { return static_cast( m_listSpec & List::AsMask ); } - /////////////////////////////////////////////////////////////////////////// - void setIncludeWhat( Include::What includeWhat ) - { + void setIncludeWhat( Include::What includeWhat ) { m_includeWhat = includeWhat; } - /////////////////////////////////////////////////////////////////////////// - void setShouldDebugBreak( bool shouldDebugBreakFlag ) - { + void setShouldDebugBreak( bool shouldDebugBreakFlag ) { m_shouldDebugBreak = shouldDebugBreakFlag; } - /////////////////////////////////////////////////////////////////////////// - void setName( const std::string& name ) - { + void setName( const std::string& name ) { m_name = name; } - /////////////////////////////////////////////////////////////////////////// - std::string getName() const - { + std::string getName() const { return m_name; } - /////////////////////////////////////////////////////////////////////////// - bool shouldDebugBreak() const - { + bool shouldDebugBreak() const { return m_shouldDebugBreak; } - /////////////////////////////////////////////////////////////////////////// - void setShowHelp( bool showHelpFlag ) - { + void setShowHelp( bool showHelpFlag ) { m_showHelp = showHelpFlag; } - /////////////////////////////////////////////////////////////////////////// - bool showHelp() const - { + bool showHelp() const { return m_showHelp; } - /////////////////////////////////////////////////////////////////////////// - virtual std::ostream& stream() const - { + virtual std::ostream& stream() const { return m_os; } - /////////////////////////////////////////////////////////////////////////// - void setStreamBuf( std::streambuf* buf ) - { + void setStreamBuf( std::streambuf* buf ) { m_os.rdbuf( buf ? buf : std::cout.rdbuf() ); } - /////////////////////////////////////////////////////////////////////////// - void useStream( const std::string& streamName ) - { + void useStream( const std::string& streamName ) { std::streambuf* newBuf = Context::createStreamBuf( streamName ); setStreamBuf( newBuf ); delete m_streambuf; m_streambuf = newBuf; } - /////////////////////////////////////////////////////////////////////////// - virtual bool includeSuccessfulResults() const - { + virtual bool includeSuccessfulResults() const { return m_includeWhat == Include::SuccessfulResults; } diff --git a/include/internal/catch_context.h b/include/internal/catch_context.h index ada177c5..1e3711e7 100644 --- a/include/internal/catch_context.h +++ b/include/internal/catch_context.h @@ -14,8 +14,8 @@ #include #include -namespace Catch -{ +namespace Catch { + class TestCaseInfo; struct IResultCapture; struct ITestCaseRegistry; @@ -25,8 +25,8 @@ namespace Catch class StreamBufBase : public std::streambuf{}; - class Context - { + class Context { + Context(); Context( const Context& ); void operator=( const Context& ); diff --git a/include/internal/catch_list.hpp b/include/internal/catch_list.hpp index 5b7026b9..773547f5 100644 --- a/include/internal/catch_list.hpp +++ b/include/internal/catch_list.hpp @@ -1,69 +1,51 @@ /* - * catch_list.hpp - * Catch - * * Created by Phil on 5/11/2010. * Copyright 2010 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_LIST_HPP_INCLUDED #define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED #include "catch_commandline.hpp" #include -namespace Catch -{ - /////////////////////////////////////////////////////////////////////////// - inline int List - ( - Config& config - ) - { - if( config.listWhat() & Config::List::Reports ) - { +namespace Catch { + inline int List( Config& config ) { + + if( config.listWhat() & Config::List::Reports ) { std::cout << "Available reports:\n"; IReporterRegistry::FactoryMap::const_iterator it = Context::getReporterRegistry().getFactories().begin(); IReporterRegistry::FactoryMap::const_iterator itEnd = Context::getReporterRegistry().getFactories().end(); - for(; it != itEnd; ++it ) - { + for(; it != itEnd; ++it ) { // !TBD: consider listAs() std::cout << "\t" << it->first << "\n\t\t'" << it->second->getDescription() << "'\n"; } std::cout << std::endl; } - if( config.listWhat() & Config::List::Tests ) - { + + if( config.listWhat() & Config::List::Tests ) { std::cout << "Available tests:\n"; std::vector::const_iterator it = Context::getTestCaseRegistry().getAllTests().begin(); std::vector::const_iterator itEnd = Context::getTestCaseRegistry().getAllTests().end(); - for(; it != itEnd; ++it ) - { + for(; it != itEnd; ++it ) { // !TBD: consider listAs() std::cout << "\t" << it->getName() << "\n\t\t '" << it->getDescription() << "'\n"; } std::cout << std::endl; } - if( ( config.listWhat() & Config::List::All ) == 0 ) - { + + if( ( config.listWhat() & Config::List::All ) == 0 ) { std::cerr << "Unknown list type" << std::endl; return (std::numeric_limits::max)(); } if( config.getReporter().get() ) - { std::cerr << "Reporters ignored when listing" << std::endl; - } if( !config.testsSpecified() ) - { std::cerr << "Test specs ignored when listing" << std::endl; - } return 0; - } } // end namespace Catch diff --git a/include/internal/catch_running_test.hpp b/include/internal/catch_running_test.hpp index df12e9b1..80cd6e12 100644 --- a/include/internal/catch_running_test.hpp +++ b/include/internal/catch_running_test.hpp @@ -11,12 +11,11 @@ #include "catch_test_case_info.hpp" #include "catch_section_info.hpp" -namespace Catch -{ - class RunningTest - { - enum RunStatus - { +namespace Catch { + + class RunningTest { + + enum RunStatus { NothingRun, EncounteredASection, RanAtLeastOneSection, @@ -25,74 +24,49 @@ namespace Catch }; public: - /////////////////////////////////////////////////////////////////////// - explicit RunningTest - ( - const TestCaseInfo* info = NULL - ) + explicit RunningTest( const TestCaseInfo* info = NULL ) : m_info( info ), m_runStatus( RanAtLeastOneSection ), m_currentSection( &m_rootSection ), m_changed( false ) - { - } + {} - /////////////////////////////////////////////////////////////////////// - bool wasSectionSeen - () - const - { + bool wasSectionSeen() const { return m_runStatus == RanAtLeastOneSection || m_runStatus == RanToCompletionWithSections; } - /////////////////////////////////////////////////////////////////////// - void reset - () - { + void reset() { m_runStatus = NothingRun; m_changed = false; m_lastSectionToRun = NULL; } - /////////////////////////////////////////////////////////////////////// - void ranToCompletion - () - { + void ranToCompletion() { if( m_runStatus == RanAtLeastOneSection || - m_runStatus == EncounteredASection ) - { + m_runStatus == EncounteredASection ) { m_runStatus = RanToCompletionWithSections; - if( m_lastSectionToRun ) - { + if( m_lastSectionToRun ) { m_lastSectionToRun->ranToCompletion(); m_changed = true; } } - else - { + else { m_runStatus = RanToCompletionWithNoSections; } } - /////////////////////////////////////////////////////////////////////// - bool addSection - ( - const std::string& name - ) - { + bool addSection( const std::string& name ) { if( m_runStatus == NothingRun ) m_runStatus = EncounteredASection; SectionInfo* thisSection = m_currentSection->findSubSection( name ); - if( !thisSection ) - { + if( !thisSection ) { thisSection = m_currentSection->addSubSection( name ); m_changed = true; } - if( !wasSectionSeen() && thisSection->shouldRun() ) - { + if( !wasSectionSeen() && thisSection->shouldRun() ) { m_currentSection = thisSection; m_lastSectionToRun = NULL; return true; @@ -100,38 +74,23 @@ namespace Catch return false; } - /////////////////////////////////////////////////////////////////////// - void endSection - ( - const std::string& - ) - { - if( m_currentSection->ran() ) - { + void endSection( const std::string& ) { + if( m_currentSection->ran() ) { m_runStatus = RanAtLeastOneSection; m_changed = true; } - else if( m_runStatus == EncounteredASection ) - { + else if( m_runStatus == EncounteredASection ) { m_runStatus = RanAtLeastOneSection; m_lastSectionToRun = m_currentSection; } m_currentSection = m_currentSection->getParent(); } - /////////////////////////////////////////////////////////////////////// - const TestCaseInfo& getTestCaseInfo - () - const - { + const TestCaseInfo& getTestCaseInfo() const { return *m_info; } - /////////////////////////////////////////////////////////////////////// - bool hasUntestedSections - () - const - { + bool hasUntestedSections() const { return m_runStatus == RanAtLeastOneSection || ( m_rootSection.hasUntestedSections() && m_changed ); } diff --git a/include/internal/catch_section_info.hpp b/include/internal/catch_section_info.hpp index 1f5fd491..0906c7c0 100644 --- a/include/internal/catch_section_info.hpp +++ b/include/internal/catch_section_info.hpp @@ -13,15 +13,12 @@ #include #include -namespace Catch -{ - /////////////////////////////////////////////////////////////////////////// - /////////////////////////////////////////////////////////////////////////// - class SectionInfo - { +namespace Catch { + + class SectionInfo { public: - enum Status - { + + enum Status { Root, Unknown, Branch, @@ -29,103 +26,62 @@ namespace Catch TestedLeaf }; - /////////////////////////////////////////////////////////////////////// - SectionInfo - ( - SectionInfo* parent - ) + SectionInfo( SectionInfo* parent ) : m_status( Unknown ), m_parent( parent ) - { - } + {} - /////////////////////////////////////////////////////////////////////// - SectionInfo - () + SectionInfo() : m_status( Root ), m_parent( NULL ) - { - } + {} - /////////////////////////////////////////////////////////////////////// - ~SectionInfo - () - { + ~SectionInfo() { deleteAllValues( m_subSections ); } - /////////////////////////////////////////////////////////////////////// - bool shouldRun - () - const - { + bool shouldRun() const { return m_status < TestedBranch; } - /////////////////////////////////////////////////////////////////////// - bool ran - () - { - if( m_status < Branch ) - { + bool ran() { + if( m_status < Branch ) { m_status = TestedLeaf; return true; } return false; } - /////////////////////////////////////////////////////////////////////// - void ranToCompletion - () - { + + void ranToCompletion() { if( m_status == Branch && !hasUntestedSections() ) - { m_status = TestedBranch; - } } - /////////////////////////////////////////////////////////////////////// - SectionInfo* findSubSection - ( - const std::string& name - ) - { + SectionInfo* findSubSection( const std::string& name ) { std::map::const_iterator it = m_subSections.find( name ); return it != m_subSections.end() ? it->second : NULL; } - /////////////////////////////////////////////////////////////////////// - SectionInfo* addSubSection - ( - const std::string& name - ) - { + SectionInfo* addSubSection( const std::string& name ) { SectionInfo* subSection = new SectionInfo( this ); m_subSections.insert( std::make_pair( name, subSection ) ); m_status = Branch; return subSection; } - /////////////////////////////////////////////////////////////////////// - SectionInfo* getParent - () - { + SectionInfo* getParent() { return m_parent; } - /////////////////////////////////////////////////////////////////////// - bool hasUntestedSections - () - const - { + bool hasUntestedSections() const { if( m_status == Unknown ) return true; std::map::const_iterator it = m_subSections.begin(); std::map::const_iterator itEnd = m_subSections.end(); - for(; it != itEnd; ++it ) - { + for(; it != itEnd; ++it ) { if( it->second->hasUntestedSections() ) return true; } diff --git a/include/internal/catch_test_case_info.hpp b/include/internal/catch_test_case_info.hpp index 3c8557a3..77043420 100644 --- a/include/internal/catch_test_case_info.hpp +++ b/include/internal/catch_test_case_info.hpp @@ -1,15 +1,10 @@ /* - * catch_test_case_info.hpp - * Catch - * * Created by Phil on 29/10/2010. * Copyright 2010 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_TESTCASEINFO_HPP_INCLUDED #define TWOBLUECUBES_CATCH_TESTCASEINFO_HPP_INCLUDED @@ -17,147 +12,82 @@ #include #include -namespace Catch -{ - class TestCaseInfo - { +namespace Catch { + + class TestCaseInfo { public: - /////////////////////////////////////////////////////////////////////// - TestCaseInfo - ( - ITestCase* testCase, - const char* name, - const char* description, - const SourceLineInfo& lineInfo - ) + TestCaseInfo( ITestCase* testCase, + const char* name, + const char* description, + const SourceLineInfo& lineInfo ) : m_test( testCase ), m_name( name ), m_description( description ), m_lineInfo( lineInfo ) - { - } + {} - /////////////////////////////////////////////////////////////////////// - TestCaseInfo - () + TestCaseInfo() : m_test( NULL ), m_name(), m_description() - { - } + {} - /////////////////////////////////////////////////////////////////////// - TestCaseInfo - ( - const TestCaseInfo& other - ) + TestCaseInfo( const TestCaseInfo& other ) : m_test( other.m_test->clone() ), m_name( other.m_name ), m_description( other.m_description ), m_lineInfo( other.m_lineInfo ) - { - } + {} - /////////////////////////////////////////////////////////////////////// - TestCaseInfo - ( - const TestCaseInfo& other, - const std::string& name - ) + TestCaseInfo( const TestCaseInfo& other, const std::string& name ) : m_test( other.m_test->clone() ), m_name( name ), m_description( other.m_description ), m_lineInfo( other.m_lineInfo ) - { - } + {} - /////////////////////////////////////////////////////////////////////// - TestCaseInfo& operator = - ( - const TestCaseInfo& other - ) - { + TestCaseInfo& operator = ( const TestCaseInfo& other ) { TestCaseInfo temp( other ); swap( temp ); return *this; } - /////////////////////////////////////////////////////////////////////// - ~TestCaseInfo - () - { + ~TestCaseInfo() { delete m_test; } - /////////////////////////////////////////////////////////////////////// - void invoke - () - const - { + void invoke() const { m_test->invoke(); } - /////////////////////////////////////////////////////////////////////// - const std::string& getName - () - const - { + const std::string& getName() const { return m_name; } - /////////////////////////////////////////////////////////////////////// - const std::string& getDescription - () - const - { + const std::string& getDescription() const { return m_description; } - /////////////////////////////////////////////////////////////////////// - const SourceLineInfo& getLineInfo - () - const - { + const SourceLineInfo& getLineInfo() const { return m_lineInfo; } - /////////////////////////////////////////////////////////////////////// - bool isHidden - () - const - { + bool isHidden() const { return m_name.size() >= 2 && m_name[0] == '.' && m_name[1] == '/'; } - /////////////////////////////////////////////////////////////////////// - void swap - ( - TestCaseInfo& other - ) - { + void swap( TestCaseInfo& other ) { std::swap( m_test, other.m_test ); m_name.swap( other.m_name ); m_description.swap( other.m_description ); m_lineInfo.swap( other.m_lineInfo ); } - /////////////////////////////////////////////////////////////////////// - bool operator == - ( - const TestCaseInfo& other - ) - const - { + bool operator == ( const TestCaseInfo& other ) const { return *m_test == *other.m_test && m_name == other.m_name; } - /////////////////////////////////////////////////////////////////////// - bool operator < - ( - const TestCaseInfo& other - ) - const - { + bool operator < ( const TestCaseInfo& other ) const { return m_name < other.m_name; } @@ -168,34 +98,21 @@ namespace Catch SourceLineInfo m_lineInfo; }; - /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// - class TestSpec - { + class TestSpec { public: - /////////////////////////////////////////////////////////////////////// - TestSpec - ( - const std::string& rawSpec - ) + TestSpec( const std::string& rawSpec ) : m_rawSpec( rawSpec ), - m_isWildcarded( false ) - { - if( m_rawSpec[m_rawSpec.size()-1] == '*' ) - { + m_isWildcarded( false ) { + + if( m_rawSpec[m_rawSpec.size()-1] == '*' ) { m_rawSpec = m_rawSpec.substr( 0, m_rawSpec.size()-1 ); m_isWildcarded = true; } } - /////////////////////////////////////////////////////////////////////// - bool matches - ( - const std::string& testName - ) - const - { + bool matches ( const std::string& testName ) const { if( !m_isWildcarded ) return m_rawSpec == testName; else diff --git a/include/internal/catch_totals.hpp b/include/internal/catch_totals.hpp index 4a692880..8c89f73e 100644 --- a/include/internal/catch_totals.hpp +++ b/include/internal/catch_totals.hpp @@ -8,10 +8,9 @@ #ifndef TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED #define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED -namespace Catch -{ - struct Counts - { +namespace Catch { + + struct Counts { Counts() : passed( 0 ), failed( 0 ) {} Counts operator - ( const Counts& other ) const { @@ -29,8 +28,8 @@ namespace Catch std::size_t failed; }; - struct Totals - { + struct Totals { + Totals operator - ( const Totals& other ) const { Totals diff; diff.assertions = assertions - other.assertions;