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

More reformatting

Commit
d0be9ed5d9b0416803ae2f22b2e1334354694e80
Author
Phil Nash ·
Parents
2efc1146bfd9

Files · Download .tar.gz

Changes

 include/internal/catch_common.h               |   8 +-
 include/internal/catch_console_colour.hpp     |  14 +-
 include/internal/catch_debugger.hpp           |  27 ++--
 include/internal/catch_interfaces_capture.h   |  69 +++------
 include/internal/catch_interfaces_exception.h |  54 ++-----
 include/internal/catch_interfaces_reporter.h  |   3 +-
 include/internal/catch_interfaces_runner.h    |  29 +---
 include/internal/catch_interfaces_testcase.h  |  56 ++------
 include/internal/catch_ptr.hpp                |  11 +-
 include/internal/catch_stream.hpp             |  51 ++-----
 include/internal/catch_xmlwriter.hpp          | 198 +++++---------------------
 11 files changed, 124 insertions(+), 396 deletions(-)

diff --git a/include/internal/catch_common.h b/include/internal/catch_common.h
index a5aed1b9..88230720 100644
--- a/include/internal/catch_common.h
+++ b/include/internal/catch_common.h
@@ -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 ),
diff --git a/include/internal/catch_console_colour.hpp b/include/internal/catch_console_colour.hpp
index e3454ef9..6cb0b828 100644
--- a/include/internal/catch_console_colour.hpp
+++ b/include/internal/catch_console_colour.hpp
@@ -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,
diff --git a/include/internal/catch_debugger.hpp b/include/internal/catch_debugger.hpp
index 25eeafe6..4b0c8337 100644
--- a/include/internal/catch_debugger.hpp
+++ b/include/internal/catch_debugger.hpp
@@ -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;
 }
diff --git a/include/internal/catch_interfaces_capture.h b/include/internal/catch_interfaces_capture.h
index 2383bf06..4cb74a06 100644
--- a/include/internal/catch_interfaces_capture.h
+++ b/include/internal/catch_interfaces_capture.h
@@ -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
-        ()
-        {}
-        
-        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;
+    struct IResultCapture {
+    
+        virtual ~IResultCapture(){}
         
-        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 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 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;        
     };
 }
 
diff --git a/include/internal/catch_interfaces_exception.h b/include/internal/catch_interfaces_exception.h
index fff7b653..9c699583 100644
--- a/include/internal/catch_interfaces_exception.h
+++ b/include/internal/catch_interfaces_exception.h
@@ -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 ) );
         }
diff --git a/include/internal/catch_interfaces_reporter.h b/include/internal/catch_interfaces_reporter.h
index 03f2439a..ddcbf28e 100644
--- a/include/internal/catch_interfaces_reporter.h
+++ b/include/internal/catch_interfaces_reporter.h
@@ -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 " );
         
diff --git a/include/internal/catch_interfaces_runner.h b/include/internal/catch_interfaces_runner.h
index c23a0394..ee7b3486 100644
--- a/include/internal/catch_interfaces_runner.h
+++ b/include/internal/catch_interfaces_runner.h
@@ -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;
     };
 }
 
diff --git a/include/internal/catch_interfaces_testcase.h b/include/internal/catch_interfaces_testcase.h
index 87bc537f..666aec05 100644
--- a/include/internal/catch_interfaces_testcase.h
+++ b/include/internal/catch_interfaces_testcase.h
@@ -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
diff --git a/include/internal/catch_ptr.hpp b/include/internal/catch_ptr.hpp
index 97cc5074..3ebe9f74 100644
--- a/include/internal/catch_ptr.hpp
+++ b/include/internal/catch_ptr.hpp
@@ -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 ){
diff --git a/include/internal/catch_stream.hpp b/include/internal/catch_stream.hpp
index e26b2f33..653713a3 100644
--- a/include/internal/catch_stream.hpp
+++ b/include/internal/catch_stream.hpp
@@ -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 );
         }
     };
diff --git a/include/internal/catch_xmlwriter.hpp b/include/internal/catch_xmlwriter.hpp
index 593c069b..57494d2e 100644
--- a/include/internal/catch_xmlwriter.hpp
+++ b/include/internal/catch_xmlwriter.hpp
@@ -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;