Progmasoft Git

catch3

Progmasoft Catch3: an independently maintained C++17 test framework with a parallel runner, property checks, snapshots and structured results.

Clonegit clone https://git.progmasoft.com/catch3

Reformatting

Commit
0afa09f7c1261bad88661275a10211f524d8deb1
Author
Phil Nash ·
Parents
6cd2ac7544f8

Files · Download .tar.gz

Changes

 include/internal/catch_interfaces_reporter.h |   2 +-
 include/reporters/catch_reporter_basic.hpp   | 229 +++++++--------------------
 include/reporters/catch_reporter_junit.hpp   | 118 ++++----------
 include/reporters/catch_reporter_xml.hpp     |  83 ++--------
 projects/SelfTest/catch_self_test.hpp        |   2 +-
 5 files changed, 110 insertions(+), 324 deletions(-)

diff --git a/include/internal/catch_interfaces_reporter.h b/include/internal/catch_interfaces_reporter.h
index ddcbf28e..0be38773 100644
--- a/include/internal/catch_interfaces_reporter.h
+++ b/include/internal/catch_interfaces_reporter.h
@@ -35,7 +35,7 @@ namespace Catch
         virtual void EndTesting( const Totals& totals ) = 0;        
         virtual void StartGroup( const std::string& groupName ) = 0;        
         virtual void EndGroup( const std::string& groupName, const Totals& totals ) = 0;        
-        virtual void StartSection( const std::string& sectionName, const std::string description ) = 0;        
+        virtual void StartSection( const std::string& sectionName, const std::string& description ) = 0;        
         virtual void EndSection( const std::string& sectionName, const Counts& assertions ) = 0;        
         virtual void StartTestCase( const TestCaseInfo& testInfo ) = 0;        
         virtual void EndTestCase( const TestCaseInfo& testInfo, const Totals& totals, const std::string& stdOut, const std::string& stdErr ) = 0;        
diff --git a/include/reporters/catch_reporter_basic.hpp b/include/reporters/catch_reporter_basic.hpp
index be631f13..b9992ec6 100644
--- a/include/reporters/catch_reporter_basic.hpp
+++ b/include/reporters/catch_reporter_basic.hpp
@@ -1,13 +1,9 @@
 /*
- *  catch_reporter_basic.hpp
- *  Catch
- *
  *  Created by Phil on 28/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_REPORTER_BASIC_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_REPORTER_BASIC_HPP_INCLUDED
@@ -17,17 +13,15 @@
 #include "../internal/catch_reporter_registrars.hpp"
 #include "../internal/catch_console_colour.hpp"
 
-namespace Catch
-{
-    struct pluralise
-    {
+namespace Catch {
+
+    struct pluralise {
         pluralise( std::size_t count, const std::string& label )
         :   m_count( count ),
             m_label( label )
         {}
 
-        friend std::ostream& operator << ( std::ostream& os, const pluralise& pluraliser )
-        {
+        friend std::ostream& operator << ( std::ostream& os, const pluralise& pluraliser ) {
             os << pluraliser.m_count << " " << pluraliser.m_label;
             if( pluraliser.m_count != 1 )
                 os << "s";
@@ -38,10 +32,10 @@ namespace Catch
         std::string m_label;
     };
 
-    class BasicReporter : public SharedImpl<IReporter>
-    {
-        struct SpanInfo
-        {
+    class BasicReporter : public SharedImpl<IReporter> {
+    
+        struct SpanInfo {
+        
             SpanInfo() 
             :   emitted( false )
             {}
@@ -61,61 +55,38 @@ namespace Catch
         };
 
     public:
-        ///////////////////////////////////////////////////////////////////////////
-        BasicReporter
-        (
-            const IReporterConfig& config
-        )
+        BasicReporter( const IReporterConfig& config )
         :   m_config( config ),
             m_firstSectionInTestCase( true )
-        {
-        }
+        {}
         
-        ///////////////////////////////////////////////////////////////////////////
-        static std::string getDescription
-        ()
-        {
+        static std::string getDescription() {
             return "Reports test results as lines of text";
         }
 
     private:
 
-        ///////////////////////////////////////////////////////////////////////////
-        void ReportCounts
-        (
-            const std::string& label,
-            const Counts& counts
-        )
-        {
+        void ReportCounts( const std::string& label, const Counts& counts ) {
             if( counts.passed )
                 m_config.stream() << counts.failed << " of " << counts.total() << " " << label << "s failed";
             else
                 m_config.stream() << ( counts.failed > 1 ? "All " : "" ) << pluralise( counts.failed, label ) << " failed";
         }
 
-        ///////////////////////////////////////////////////////////////////////////
-        void ReportCounts
-        (
-            const Totals& totals
-        )
-        {
-            if( totals.assertions.total() == 0 )
-            {
+        void ReportCounts( const Totals& totals ) {
+            if( totals.assertions.total() == 0 ) {
                 m_config.stream() << "No tests ran";
             }
-            else if( totals.assertions.failed )
-            {
+            else if( totals.assertions.failed ) {
                 TextColour colour( TextColour::ResultError );
                 ReportCounts( "test case", totals.testCases );
-                if( totals.testCases.failed > 0 )
-                {
+                if( totals.testCases.failed > 0 ) {
                     m_config.stream() << " (";
                     ReportCounts( "assertion", totals.assertions );
                     m_config.stream() << ")";
                 }
             }
-            else
-            {
+            else {
                 TextColour colour( TextColour::ResultSuccess );
                 m_config.stream()   << "All tests passed (" 
                                     << pluralise( totals.assertions.passed, "assertion" ) << " in " 
@@ -125,51 +96,27 @@ namespace Catch
 
     private: // IReporter
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual bool shouldRedirectStdout
-        ()
-        const
-        {
+        virtual bool shouldRedirectStdout() const {
             return false;
         }        
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartTesting
-        ()
-        {
+        virtual void StartTesting() {
             m_testingSpan = SpanInfo();
         }
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndTesting
-        (
-            const Totals& totals
-        )
-        {
+        virtual void EndTesting( const Totals& totals ) {
             // Output the overall test results even if "Started Testing" was not emitted
             m_config.stream() << "\n[Testing completed. ";
             ReportCounts( totals);
             m_config.stream() << "]\n" << std::endl;
         }
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartGroup
-        (
-            const std::string& groupName
-        )
-        {
+        virtual void StartGroup( const std::string& groupName ) {
             m_groupSpan = groupName;
         }
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndGroup
-        (
-            const std::string& groupName, 
-            const Totals& totals
-        )
-        {
-            if( m_groupSpan.emitted && !groupName.empty() )
-            {
+        virtual void EndGroup( const std::string& groupName, const Totals& totals ) {
+            if( m_groupSpan.emitted && !groupName.empty() ) {
                 m_config.stream() << "[End of group: '" << groupName << "'. ";
                 ReportCounts( totals );
                 m_config.stream() << "]\n" << std::endl;
@@ -177,44 +124,24 @@ namespace Catch
             }
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartTestCase
-        (
-            const TestCaseInfo& testInfo
-        )
-        {
+        virtual void StartTestCase( const TestCaseInfo& testInfo ) {
             m_testSpan = testInfo.getName();
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartSection
-        (
-            const std::string& sectionName, 
-            const std::string /*description*/ 
-        )
-        {
+        virtual void StartSection( const std::string& sectionName, const std::string& ) {
             m_sectionSpans.push_back( SpanInfo( sectionName ) );
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndSection
-        (
-            const std::string& sectionName, 
-            const Counts& assertions
-        )
-        {
+        virtual void EndSection( const std::string& sectionName, const Counts& assertions ) {
             SpanInfo& sectionSpan = m_sectionSpans.back();
-            if( sectionSpan.emitted && !sectionSpan.name.empty() )
-            {
+            if( sectionSpan.emitted && !sectionSpan.name.empty() ) {
                 m_config.stream() << "[End of section: '" << sectionName << "' ";
                 
-                if( assertions.failed )
-                {
+                if( assertions.failed ) {
                     TextColour colour( TextColour::ResultError );
                     ReportCounts( "assertion", assertions);
                 }
-                else
-                {
+                else {
                     TextColour colour( TextColour::ResultSuccess );
                     m_config.stream()   << ( assertions.passed > 1 ? "All " : "" ) 
                                         << pluralise( assertions.passed, "assertion" ) << "passed" ;
@@ -224,40 +151,30 @@ namespace Catch
             m_sectionSpans.pop_back();
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void Result
-        (
-            const ResultInfo& resultInfo
-        )
-        {
+        virtual void Result( const ResultInfo& resultInfo ) {
             if( !m_config.includeSuccessfulResults() && resultInfo.getResultType() == ResultWas::Ok )
                 return;
             
             StartSpansLazily();
             
-            if( !resultInfo.getFilename().empty() )
-            {
+            if( !resultInfo.getFilename().empty() ) {
                 TextColour colour( TextColour::FileName );
                 m_config.stream() << SourceLineInfo( resultInfo.getFilename(), resultInfo.getLine() );
             }
             
-            if( resultInfo.hasExpression() )
-            {
+            if( resultInfo.hasExpression() ) {
                 TextColour colour( TextColour::OriginalExpression );
                 m_config.stream() << resultInfo.getExpression();
-                if( resultInfo.ok() )
-                {
+                if( resultInfo.ok() ) {
                     TextColour successColour( TextColour::Success );
                     m_config.stream() << " succeeded";
                 }
-                else
-                {
+                else {
                     TextColour errorColour( TextColour::Error );
                     m_config.stream() << " failed";
                 }
             }
-            switch( resultInfo.getResultType() )
-            {
+            switch( resultInfo.getResultType() ) {
                 case ResultWas::ThrewException:
                 {
                     TextColour colour( TextColour::Error );
@@ -295,15 +212,12 @@ namespace Catch
                 case ResultWas::ExpressionFailed:
                 case ResultWas::Exception:
                 default:
-                    if( !resultInfo.hasExpression() )
-                    {
-                        if( resultInfo.ok() )
-                        {
+                    if( !resultInfo.hasExpression() ) {
+                        if( resultInfo.ok() ) {
                             TextColour colour( TextColour::Success );
                             m_config.stream() << " succeeded";
                         }
-                        else
-                        {
+                        else {
                             TextColour colour( TextColour::Error );
                             m_config.stream() << " failed";
                         }
@@ -311,8 +225,7 @@ namespace Catch
                     break;
             }
             
-            if( resultInfo.hasExpandedExpression() )
-            {
+            if( resultInfo.hasExpandedExpression() ) {
                 m_config.stream() << " for: ";
                 TextColour colour( TextColour::ReconstructedExpression );
                 m_config.stream() << resultInfo.getExpandedExpression();
@@ -320,29 +233,21 @@ namespace Catch
             m_config.stream() << std::endl;        
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndTestCase
-        (
-            const TestCaseInfo& testInfo, 
-            const Totals& totals,
-            const std::string& stdOut, 
-            const std::string& stdErr
-        )
-        {
-            if( !stdOut.empty() )
-            {
+        virtual void EndTestCase(   const TestCaseInfo& testInfo, 
+                                    const Totals& totals,
+                                    const std::string& stdOut, 
+                                    const std::string& stdErr ) {
+            if( !stdOut.empty() ) {
                 StartSpansLazily();
                 streamVariableLengthText( "stdout", stdOut );
             }
             
-            if( !stdErr.empty() )
-            {
+            if( !stdErr.empty() ) {
                 StartSpansLazily();
                 streamVariableLengthText( "stderr", stdErr );
             }
             
-            if( m_testSpan.emitted )
-            {
+            if( m_testSpan.emitted ) {
                 m_config.stream() << "[Finished: '" << testInfo.getName() << "' ";
                 ReportCounts( totals );
                 m_config.stream() << "]" << std::endl;
@@ -351,11 +256,8 @@ namespace Catch
         
     private: // helpers
         
-        ///////////////////////////////////////////////////////////////////////////
-        void StartSpansLazily()
-        {
-            if( !m_testingSpan.emitted )
-            {
+        void StartSpansLazily() {
+            if( !m_testingSpan.emitted ) {
                 if( m_config.getName().empty() )
                     m_config.stream() << "[Started testing]" << std::endl;
                 else
@@ -363,35 +265,28 @@ namespace Catch
                 m_testingSpan.emitted = true;
             }
             
-            if( !m_groupSpan.emitted && !m_groupSpan.name.empty() )
-            {
+            if( !m_groupSpan.emitted && !m_groupSpan.name.empty() ) {
                 m_config.stream() << "[Started group: '" << m_groupSpan.name << "']" << std::endl;
                 m_groupSpan.emitted = true;
             }
             
-            if( !m_testSpan.emitted )
-            {
+            if( !m_testSpan.emitted ) {
                 m_config.stream() << std::endl << "[Running: " << m_testSpan.name << "]" << std::endl;
                 m_testSpan.emitted = true;
             }
             
-            if( !m_sectionSpans.empty() )
-            {
+            if( !m_sectionSpans.empty() ) {
                 SpanInfo& sectionSpan = m_sectionSpans.back();
-                if( !sectionSpan.emitted && !sectionSpan.name.empty() )
-                {
-                    if( m_firstSectionInTestCase )
-                    {
+                if( !sectionSpan.emitted && !sectionSpan.name.empty() ) {
+                    if( m_firstSectionInTestCase ) {
                         m_config.stream() << "\n";
                         m_firstSectionInTestCase = false;
                     }
                     std::vector<SpanInfo>::iterator it = m_sectionSpans.begin();
                     std::vector<SpanInfo>::iterator itEnd = m_sectionSpans.end();
-                    for(; it != itEnd; ++it )
-                    {
+                    for(; it != itEnd; ++it ) {
                         SpanInfo& prevSpan = *it;
-                        if( !prevSpan.emitted && !prevSpan.name.empty() )
-                        {
+                        if( !prevSpan.emitted && !prevSpan.name.empty() ) {
                             m_config.stream() << "[Started section: '" << prevSpan.name << "']" << std::endl;
                             prevSpan.emitted = true;
                         }                        
@@ -400,20 +295,12 @@ namespace Catch
             }
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        void streamVariableLengthText
-        (
-            const std::string& prefix,
-            const std::string& text
-        )
-        {
+        void streamVariableLengthText( const std::string& prefix, const std::string& text ) {
             std::string trimmed = trim( text );
-            if( trimmed.find_first_of( "\r\n" ) == std::string::npos )
-            {
+            if( trimmed.find_first_of( "\r\n" ) == std::string::npos ) {
                 m_config.stream() << "[" << prefix << ": " << trimmed << "]\n";
             }
-            else 
-            {
+            else {
                 m_config.stream() << "\n[" << prefix << "] >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n" << trimmed 
                 << "\n[end of " << prefix << "] <<<<<<<<<<<<<<<<<<<<<<<<\n";
             }
diff --git a/include/reporters/catch_reporter_junit.hpp b/include/reporters/catch_reporter_junit.hpp
index 0314901c..6a9815de 100644
--- a/include/reporters/catch_reporter_junit.hpp
+++ b/include/reporters/catch_reporter_junit.hpp
@@ -1,13 +1,9 @@
 /*
- *  catch_reporter_junit.hpp
- *  Catch
- *
  *  Created by Phil on 26/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_REPORTER_JUNIT_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
@@ -17,24 +13,20 @@
 #include "../internal/catch_reporter_registrars.hpp"
 #include "../internal/catch_xmlwriter.hpp"
 
-namespace Catch
-{
-    class JunitReporter : public SharedImpl<IReporter>
-    {
-        struct TestStats
-        {
+namespace Catch {
+
+    class JunitReporter : public SharedImpl<IReporter> {
+    
+        struct TestStats {
             std::string m_element;
             std::string m_resultType;
             std::string m_message;
             std::string m_content;
         };
         
-        struct TestCaseStats
-        {
-            TestCaseStats( const std::string& name = std::string() )
-            :   m_name( name )
-            {
-            }
+        struct TestCaseStats {
+        
+            TestCaseStats( const std::string& name = std::string() ) :m_name( name ){}
             
             double      m_timeInSeconds;
             std::string m_status;
@@ -43,8 +35,8 @@ namespace Catch
             std::vector<TestStats> m_testStats;
         };
         
-        struct Stats
-        {
+        struct Stats {
+        
             Stats( const std::string& name = std::string() )
             :   m_testsCount( 0 ),
                 m_failuresCount( 0 ),
@@ -52,8 +44,7 @@ namespace Catch
                 m_errorsCount( 0 ),
                 m_timeInSeconds( 0 ),
                 m_name( name )
-            {
-            }
+            {}
             
             std::size_t m_testsCount;
             std::size_t m_failuresCount;
@@ -66,83 +57,55 @@ namespace Catch
         };
         
     public:
-        ///////////////////////////////////////////////////////////////////////////
         JunitReporter( const IReporterConfig& config )
         :   m_config( config ),
             m_testSuiteStats( "AllTests" ),
             m_currentStats( &m_testSuiteStats )
-        {
-        }        
+        {}        
         
-        ///////////////////////////////////////////////////////////////////////////
-        static std::string getDescription()
-        {
+        static std::string getDescription() {
             return "Reports test results in an XML format that looks like Ant's junitreport target";
         }
         
     private: // IReporter
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual bool shouldRedirectStdout
-        ()
-        const
-        {
+        virtual bool shouldRedirectStdout() const {
             return true;
         }        
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartTesting()
-        {
-        }
+        virtual void StartTesting(){}
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartGroup( const std::string& groupName )
-        {
-            
+        virtual void StartGroup( const std::string& groupName ) {            
             m_statsForSuites.push_back( Stats( groupName ) );
             m_currentStats = &m_statsForSuites.back();
         }
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndGroup( const std::string&, const Totals& totals )
-        {
+        virtual void EndGroup( const std::string&, const Totals& totals ) {
             m_currentStats->m_testsCount = totals.assertions.total();
             m_currentStats = &m_testSuiteStats;
         }
         
-        virtual void StartSection( const std::string& /*sectionName*/, const std::string /*description*/ )
-        {
-        }
+        virtual void StartSection( const std::string&, const std::string& ){}
 
-        virtual void EndSection( const std::string& /*sectionName*/, const Counts& /* assertions */ )
-        {
-        }
+        virtual void EndSection( const std::string&, const Counts& ){}
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartTestCase( const Catch::TestCaseInfo& testInfo )
-        {
-            m_currentStats->m_testCaseStats.push_back( TestCaseStats( testInfo.getName() ) );
-            
+        virtual void StartTestCase( const Catch::TestCaseInfo& testInfo ) {
+            m_currentStats->m_testCaseStats.push_back( TestCaseStats( testInfo.getName() ) );            
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void Result( const Catch::ResultInfo& resultInfo )
-        {
-            if( resultInfo.getResultType() != ResultWas::Ok || m_config.includeSuccessfulResults() )
-            {
+        virtual void Result( const Catch::ResultInfo& resultInfo ) {
+            if( resultInfo.getResultType() != ResultWas::Ok || m_config.includeSuccessfulResults() ) {
                 TestCaseStats& testCaseStats = m_currentStats->m_testCaseStats.back();
                 TestStats stats;
                 std::ostringstream oss;
                 if( !resultInfo.getMessage().empty() )
-                {
                     oss << resultInfo.getMessage() << " at ";
-                }
                 oss << SourceLineInfo( resultInfo.getFilename(), resultInfo.getLine() );
                 stats.m_content = oss.str();
                 stats.m_message = resultInfo.getExpandedExpression();
                 stats.m_resultType = resultInfo.getTestMacroName();
-                switch( resultInfo.getResultType() )
-                {
+
+                switch( resultInfo.getResultType() ) {
                     case ResultWas::ThrewException:
                         stats.m_element = "error";
                         m_currentStats->m_errorsCount++;
@@ -172,23 +135,18 @@ namespace Catch
                         stats.m_element = "unknown";
                         break;
                 }
-                testCaseStats.m_testStats.push_back( stats );
-                
+                testCaseStats.m_testStats.push_back( stats );                
             }
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndTestCase( const Catch::TestCaseInfo&, const Totals& /* totals */, const std::string& stdOut, const std::string& stdErr )
-        {
+        virtual void EndTestCase( const Catch::TestCaseInfo&, const Totals&, const std::string& stdOut, const std::string& stdErr ) {
             if( !stdOut.empty() )
                 m_stdOut << stdOut << "\n";
             if( !stdErr.empty() )
                 m_stdErr << stdErr << "\n";
         }    
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndTesting( const Totals& /* totals */ )
-        {
+        virtual void EndTesting( const Totals& ) {
             std::ostream& str = m_config.stream();
             {
                 XmlWriter xml( str );
@@ -199,8 +157,7 @@ namespace Catch
                 std::vector<Stats>::const_iterator it = m_statsForSuites.begin();
                 std::vector<Stats>::const_iterator itEnd = m_statsForSuites.end();
                 
-                for(; it != itEnd; ++it )
-                {
+                for(; it != itEnd; ++it ) {
                     XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
                     xml.writeAttribute( "name", it->m_name );
                     xml.writeAttribute( "errors", it->m_errorsCount );
@@ -218,13 +175,10 @@ namespace Catch
             }
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        void OutputTestCases( XmlWriter& xml, const Stats& stats )
-        {
+        void OutputTestCases( XmlWriter& xml, const Stats& stats ) {
             std::vector<TestCaseStats>::const_iterator it = stats.m_testCaseStats.begin();
             std::vector<TestCaseStats>::const_iterator itEnd = stats.m_testCaseStats.end();
-            for(; it != itEnd; ++it )
-            {
+            for(; it != itEnd; ++it ) {
                 xml.writeBlankLine();
                 xml.writeComment( "Test case" );
                 
@@ -238,15 +192,11 @@ namespace Catch
         }
 
         
-        ///////////////////////////////////////////////////////////////////////////
-        void OutputTestResult( XmlWriter& xml, const TestCaseStats& stats )
-        {
+        void OutputTestResult( XmlWriter& xml, const TestCaseStats& stats ) {
             std::vector<TestStats>::const_iterator it = stats.m_testStats.begin();
             std::vector<TestStats>::const_iterator itEnd = stats.m_testStats.end();
-            for(; it != itEnd; ++it )
-            {
-                if( it->m_element != "success" )
-                {
+            for(; it != itEnd; ++it ) {
+                if( it->m_element != "success" ) {
                     XmlWriter::ScopedElement e = xml.scopedElement( it->m_element );
                     
                     xml.writeAttribute( "message", it->m_message );
diff --git a/include/reporters/catch_reporter_xml.hpp b/include/reporters/catch_reporter_xml.hpp
index 44141019..2e0a5442 100644
--- a/include/reporters/catch_reporter_xml.hpp
+++ b/include/reporters/catch_reporter_xml.hpp
@@ -1,13 +1,9 @@
 /*
- *  catch_reporter_xml.hpp
- *  Catch
- *
  *  Created by Phil on 28/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_REPORTER_XML_HPP_INCLUDED
 #define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
@@ -17,114 +13,70 @@
 #include "../internal/catch_reporter_registrars.hpp"
 #include "../internal/catch_xmlwriter.hpp"
 
-namespace Catch
-{
-    class XmlReporter : public SharedImpl<IReporter>
-    {
+namespace Catch {
+    class XmlReporter : public SharedImpl<IReporter> {
     public:
-        ///////////////////////////////////////////////////////////////////////////
-        XmlReporter
-        (
-            const IReporterConfig& config
-        )
-        : m_config( config )
-        {
-        }
+        XmlReporter( const IReporterConfig& config ) : m_config( config ) {}
 
-        ///////////////////////////////////////////////////////////////////////////
-        static std::string getDescription
-        ()
-        {
+        static std::string getDescription() {
             return "Reports test results as an XML document";
         }
         
     private: // IReporter
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual bool shouldRedirectStdout
-        ()
-        const
-        {
+        virtual bool shouldRedirectStdout() const {
             return true;
         }        
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartTesting
-        ()
-        {
+        virtual void StartTesting() {
             m_xml = XmlWriter( m_config.stream() );
             m_xml.startElement( "Catch" );
             if( !m_config.getName().empty() )
                 m_xml.writeAttribute( "name", m_config.getName() );
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndTesting
-        (
-            const Totals& totals
-        )
-        {
+        virtual void EndTesting( const Totals& totals ) {
             m_xml.scopedElement( "OverallResults" )
                 .writeAttribute( "successes", totals.assertions.passed )
                 .writeAttribute( "failures", totals.assertions.failed );
             m_xml.endElement();
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartGroup
-        (
-            const std::string& groupName
-        )
-        {
+        virtual void StartGroup( const std::string& groupName ) {
             m_xml.startElement( "Group" )
                 .writeAttribute( "name", groupName );
         }
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndGroup
-        (
-            const std::string& /*groupName*/, 
-            const Totals& totals
-        )
-        {
+        virtual void EndGroup( const std::string&, const Totals& totals ) {
             m_xml.scopedElement( "OverallResults" )
                 .writeAttribute( "successes", totals.assertions.passed )
                 .writeAttribute( "failures", totals.assertions.failed );
             m_xml.endElement();
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartSection( const std::string& sectionName, const std::string description )
-        {
+        virtual void StartSection( const std::string& sectionName, const std::string& description ) {
             m_xml.startElement( "Section" )
                 .writeAttribute( "name", sectionName )
                 .writeAttribute( "description", description );
         }
 
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndSection( const std::string& /*sectionName*/, const Counts& assertions )
-        {
+        virtual void EndSection( const std::string& /*sectionName*/, const Counts& assertions ) {
             m_xml.scopedElement( "OverallResults" )
                 .writeAttribute( "successes", assertions.passed )
                 .writeAttribute( "failures", assertions.failed );
             m_xml.endElement();
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void StartTestCase( const Catch::TestCaseInfo& testInfo )
-        {
+        virtual void StartTestCase( const Catch::TestCaseInfo& testInfo ) {
             m_xml.startElement( "TestCase" ).writeAttribute( "name", testInfo.getName() );
             m_currentTestSuccess = true;
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void Result( const Catch::ResultInfo& resultInfo )
-        {
+        virtual void Result( const Catch::ResultInfo& resultInfo ) {
             if( !m_config.includeSuccessfulResults() && resultInfo.getResultType() == ResultWas::Ok )
                 return;
 
-            if( resultInfo.hasExpression() )
-            {
+            if( resultInfo.hasExpression() ) {
                 m_xml.startElement( "Expression" )
                     .writeAttribute( "success", resultInfo.ok() )
                     .writeAttribute( "filename", resultInfo.getFilename() )
@@ -137,8 +89,7 @@ namespace Catch
                 m_currentTestSuccess &= resultInfo.ok();
             }
             
-            switch( resultInfo.getResultType() )
-            {
+            switch( resultInfo.getResultType() ) {
                 case ResultWas::ThrewException:
                     m_xml.scopedElement( "Exception" )
                         .writeAttribute( "filename", resultInfo.getFilename() )
@@ -172,9 +123,7 @@ namespace Catch
                 m_xml.endElement();
         }
         
-        ///////////////////////////////////////////////////////////////////////////
-        virtual void EndTestCase( const Catch::TestCaseInfo&, const Totals& /* totals */, const std::string& /*stdOut*/, const std::string& /*stdErr*/ )
-        {
+        virtual void EndTestCase( const Catch::TestCaseInfo&, const Totals&, const std::string&, const std::string& ) {
             m_xml.scopedElement( "OverallResult" ).writeAttribute( "success", m_currentTestSuccess );
             m_xml.endElement();
         }    
diff --git a/projects/SelfTest/catch_self_test.hpp b/projects/SelfTest/catch_self_test.hpp
index 41b9aed6..0a5325eb 100644
--- a/projects/SelfTest/catch_self_test.hpp
+++ b/projects/SelfTest/catch_self_test.hpp
@@ -69,7 +69,7 @@ namespace Catch
             closeLabel( recordGroups, groupName );
         }
         
-        virtual void StartSection( const std::string& sectionName, const std::string description ) {
+        virtual void StartSection( const std::string& sectionName, const std::string& description ) {
             openLabel( recordSections, sectionName );
         }