Add support for Managed tests in VS2010 & VS2012. Add support for Native tests in VS2012

include/internal/catch_capture.hpp

@@ -16,7 +16,7 @@
 #include "catch_context.h"
 #include "catch_common.h"
 #include "catch_tostring.hpp"
-#include "catch_interfaces_registry_hub.h"
+#include "catch_interfaces_reporter.h"
 #include "internal/catch_compiler_capabilities.h"
 
 #include <ostream>
@@ -56,19 +56,70 @@ namespace Catch {
             .setResultType( matcher.match( arg ) );
     }
 
+#if defined(INTERNAL_CATCH_VS_MANAGED)
+    // TestFailureException not defined for CLR
+#else // detect CLR
 struct TestFailureException{};
+#endif
 
 } // end namespace Catch
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_ASSERTIONINFO_NAME INTERNAL_CATCH_UNIQUE_NAME( __assertionInfo )
 
+#if !defined(INTERNAL_CATCH_VS_MANAGED) && !defined(INTERNAL_CATCH_VS_NATIVE)
+
+    // normal Catch
+    #define INTERNAL_CATCH_TEST_FAILURE_EXCEPTION const Catch::TestFailureException&
+    #define INTERNAL_CATCH_TEST_THROW_FAILURE throw Catch::TestFailureException();
+
+#else   // VS integration
+
+#if defined(INTERNAL_CATCH_VS_MANAGED)
+
+    #define INTERNAL_CATCH_TEST_THROW_FAILURE \
+    { \
+        Catch::IResultCapture& cap = Catch::getResultCapture(); \
+        const Catch::AssertionResult* r = cap.getLastResult(); \
+        std::stringstream _sf; \
+        _sf << r->getExpressionInMacro().c_str() << ", " << r->getMessage().c_str(); \
+        std::string fail = _sf.str(); \
+        Assert::Fail(Catch::convert_string_to_managed(fail)); \
+    }
+
+    #define INTERNAL_CATCH_TEST_FAILURE_EXCEPTION AssertFailedException^
+#else
+
+#if defined(INTERNAL_CATCH_VS_NATIVE)
+    #define INTERNAL_CATCH_TEST_THROW_FAILURE \
+    { \
+        Catch::IResultCapture& cap = Catch::getResultCapture(); \
+        const Catch::AssertionResult* r = cap.getLastResult(); \
+        std::wstringstream _s; \
+        _s << r->getSourceInfo().file.c_str(); \
+        std::wstring ws = _s.str(); \
+        std::string testName = cap.getCurrentTestName(); \
+        __LineInfo li(ws.c_str(), testName.c_str(), r->getSourceInfo().line); \
+        std::wstringstream _sf; \
+        _sf << r->getExpandedExpression().c_str() << ", " << r->getMessage().c_str(); \
+        std::wstring ws2 = _sf.str(); \
+        Assert::Fail(ws2.c_str(), &li); \
+    }
+
+    #define INTERNAL_CATCH_TEST_FAILURE_EXCEPTION const Catch::TestFailureException&
+
+#endif // INTERNAL_CATCH_VS_MANAGED
+
+#endif // detect CLR
+
+#endif   // VS integration
+
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_ACCEPT_EXPR( evaluatedExpr, resultDisposition, originalExpr ) \
     if( Catch::ResultAction::Value internal_catch_action = Catch::getResultCapture().acceptExpression( evaluatedExpr, INTERNAL_CATCH_ASSERTIONINFO_NAME )  ) { \
         if( internal_catch_action & Catch::ResultAction::Debug ) BreakIntoDebugger(); \
-        if( internal_catch_action & Catch::ResultAction::Abort ) throw Catch::TestFailureException(); \
-        if( !Catch::shouldContinueOnFailure( resultDisposition ) ) throw Catch::TestFailureException(); \
+        if( internal_catch_action & Catch::ResultAction::Abort ) { INTERNAL_CATCH_TEST_THROW_FAILURE } \
+        if( !Catch::shouldContinueOnFailure( resultDisposition ) ) { INTERNAL_CATCH_TEST_THROW_FAILURE } \
         Catch::isTrue( false && originalExpr ); \
     }
 
@@ -82,7 +133,7 @@ struct TestFailureException{};
         INTERNAL_CATCH_ACCEPT_INFO( #expr, macroName, resultDisposition ); \
         try { \
             INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionDecomposer()->*expr ).endExpression( resultDisposition ), resultDisposition, expr ); \
-        } catch( Catch::TestFailureException& ) { \
+        } catch( INTERNAL_CATCH_TEST_FAILURE_EXCEPTION ) { \
             throw; \
         } catch( ... ) { \
             INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException(), \
@@ -121,7 +172,7 @@ struct TestFailureException{};
             INTERNAL_CATCH_ACCEPT_EXPR( Catch::ExpressionResultBuilder( Catch::ResultWas::DidntThrowException ), resultDisposition, false ); \
         } \
     } \
-    catch( Catch::TestFailureException& ) { \
+    catch( INTERNAL_CATCH_TEST_FAILURE_EXCEPTION ) { \
         throw; \
     } \
     catch( exceptionType ) { \
@@ -165,7 +216,7 @@ struct TestFailureException{};
         INTERNAL_CATCH_ACCEPT_INFO( #arg " " #matcher, macroName, resultDisposition ); \
         try { \
             INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::expressionResultBuilderFromMatcher( ::Catch::Matchers::matcher, arg, #matcher ) ), resultDisposition, false ); \
-        } catch( Catch::TestFailureException& ) { \
+        } catch( INTERNAL_CATCH_TEST_FAILURE_EXCEPTION ) { \
             throw; \
         } catch( ... ) { \
             INTERNAL_CATCH_ACCEPT_EXPR( ( Catch::ExpressionResultBuilder( Catch::ResultWas::ThrewException ) << Catch::translateActiveException() ), \

include/internal/catch_runner_impl.hpp

@@ -277,9 +277,15 @@ namespace Catch {
                 }
                 duration = timer.getElapsedSeconds();
             }
-            catch( TestFailureException& ) {
+#ifdef INTERNAL_CATCH_VS_MANAGED // detect CLR
+            catch(AssertFailedException^) {
+                throw;  // CLR always rethrows - stop on first assert
+            }
+#else
+            catch( INTERNAL_CATCH_TEST_FAILURE_EXCEPTION ) {
                 // This just means the test was aborted due to failure
             }
+#endif
             catch(...) {
                 ExpressionResultBuilder exResult( ResultWas::ThrewException );
                 exResult << translateActiveException();

include/internal/catch_vs_managed_impl.hpp

@@ -11,6 +11,84 @@
 
 #ifdef INTERNAL_CATCH_VS_MANAGED
 
+#include <windows.h>
+using namespace System;
+using namespace System::Text;
+using namespace System::Collections::Generic;
+using namespace Microsoft::VisualStudio::TestTools::UnitTesting;
+
+namespace Catch {
+    inline String^ convert_string_to_managed(const std::string& s)
+    {
+        String^ result = gcnew String(s.c_str());
+        return result;
+    }
+
+}
+
+#include "internal/catch_timer.hpp"
+#include "internal/catch_vs_test_registry.hpp"
+#include "reporters/catch_vs_reporter.hpp"
+
+#include "internal/catch_exception_translator_registry.hpp"
+
+namespace Catch {
+
+    class ExceptionRegistryHub : public IRegistryHub, public IMutableRegistryHub {
+
+        ExceptionRegistryHub( ExceptionRegistryHub const& );
+        void operator=( ExceptionRegistryHub const& );
+
+    public: // IRegistryHub
+        ExceptionRegistryHub() {
+        }
+        virtual IReporterRegistry const& getReporterRegistry() const {
+            throw std::runtime_error("can't do this for Visual Studio tests!");
+        }
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const {
+            throw std::runtime_error("can't do this for Visual Studio tests!");
+        }
+        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() {
+            return m_exceptionTranslatorRegistry;
+        }
+
+    public: // IMutableRegistryHub
+        virtual void registerReporter( std::string const&, IReporterFactory* ) {
+            throw std::runtime_error("can't do this for Visual Studio tests!");
+        }
+        virtual void registerTest( TestCase const& ) {
+            throw std::runtime_error("can't do this for Visual Studio tests!");
+        }
+        virtual void registerTranslator( const IExceptionTranslator* translator ) {
+            m_exceptionTranslatorRegistry.registerTranslator( translator );
+        }
+
+    private:
+        ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+    };
+
+    template <typename T>
+    struct GlobalRegistryHub
+    {
+        static T& instance()
+        {
+            if( !theRegistryHub )
+                theRegistryHub = new T();
+            return *theRegistryHub;
+        }
+        static T* theRegistryHub;
+    };
+    template <typename T>
+    T* GlobalRegistryHub<T>::theRegistryHub = NULL;
+
+    INTERNAL_CATCH_INLINE IMutableRegistryHub& getMutableRegistryHub() {
+        return GlobalRegistryHub<ExceptionRegistryHub>::instance();
+    }
+    INTERNAL_CATCH_INLINE std::string translateActiveException() {
+        return GlobalRegistryHub<ExceptionRegistryHub>::instance().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+}
 #endif
 
-#endif // TWOBLUECUBES_CATCH_HPP_INCLUDED
+#endif // TWOBLUECUBES_CATCH_VS_MANAGED_HPP_INCLUDED

include/internal/catch_vs_native_impl.hpp

@@ -11,6 +11,80 @@
 
 #ifdef INTERNAL_CATCH_VS_NATIVE
 
-#endif
+#include "CppUnitTest.h"
+using Microsoft::VisualStudio::CppUnitTestFramework::Logger;
+using Microsoft::VisualStudio::CppUnitTestFramework::Assert;
+using Microsoft::VisualStudio::CppUnitTestFramework::__LineInfo;
+
+#define INTERNAL_CATCH_INLINE inline
+
+#include <cvt/wstring>
+#include <codecvt>
+
+#include "internal/catch_timer.hpp"
+#include "internal/catch_vs_test_registry.hpp"
+#include "reporters/catch_vs_reporter.hpp"
+
+#include "internal/catch_exception_translator_registry.hpp"
+
+namespace Catch {
+
+    class ExceptionRegistryHub : public IRegistryHub, public IMutableRegistryHub {
+
+        ExceptionRegistryHub( ExceptionRegistryHub const& );
+        void operator=( ExceptionRegistryHub const& );
+
+    public: // IRegistryHub
+        ExceptionRegistryHub() {
+        }
+        virtual IReporterRegistry const& getReporterRegistry() const {
+            throw std::runtime_error("can't do this for Visual Studio tests!");
+        }
+        virtual ITestCaseRegistry const& getTestCaseRegistry() const {
+            throw std::runtime_error("can't do this for Visual Studio tests!");
+        }
+        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() {
+            return m_exceptionTranslatorRegistry;
+        }
+
+    public: // IMutableRegistryHub
+        virtual void registerReporter( std::string const&, IReporterFactory* ) {
+            throw std::runtime_error("can't do this for Visual Studio tests!");
+        }
+        virtual void registerTest( TestCase const& ) {
+            throw std::runtime_error("can't do this for Visual Studio tests!");
+        }
+        virtual void registerTranslator( const IExceptionTranslator* translator ) {
+            m_exceptionTranslatorRegistry.registerTranslator( translator );
+        }
+
+    private:
+        ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+    };
+
+    template <typename T>
+    struct GlobalRegistryHub
+    {
+        static T& instance()
+        {
+            if( !theRegistryHub )
+                theRegistryHub = new T();
+            return *theRegistryHub;
+        }
+        static T* theRegistryHub;
+    };
+    template <typename T>
+    T* GlobalRegistryHub<T>::theRegistryHub = NULL;
+
+    INTERNAL_CATCH_INLINE IMutableRegistryHub& getMutableRegistryHub() {
+        return GlobalRegistryHub<ExceptionRegistryHub>::instance();
+    }
+    INTERNAL_CATCH_INLINE std::string translateActiveException() {
+        return GlobalRegistryHub<ExceptionRegistryHub>::instance().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+}
+
+#endif // INTERNAL_CATCH_VS_NATIVE
 
 #endif // TWOBLUECUBES_CATCH_VS_NATIVE_HPP_INCLUDED

include/internal/catch_vs_test_registry.hpp

@@ -0,0 +1,405 @@
+/*
+ *  Created by Malcolm on 6/11/2013.
+ *  Copyright 2013 Malcolm Noyes. 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_MSTEST_REGISTRY_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_MSTEST_REGISTRY_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+#include "catch_common.h"
+#include "catch_interfaces_testcase.h"
+#include "internal/catch_compiler_capabilities.h"
+//#include "catch_config.hpp"
+#include <tchar.h>
+
+namespace Catch {
+
+    typedef void(*TestFunction)();
+
+    class FreeFunctionTestCase : public SharedImpl<ITestCase> {
+    public:
+
+        FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {}
+
+        virtual void invoke() const {
+            m_fun();
+        }
+
+    private:
+        virtual ~FreeFunctionTestCase();
+
+        TestFunction m_fun;
+    };
+
+    /*inline std::string translateActiveException() {
+        try {
+#ifdef __OBJC__
+            // In Objective-C try objective-c exceptions first
+            @try {
+                throw;
+            }
+            @catch (NSException *exception) {
+                return toString( [exception description] );
+            }
+#else
+            throw;
+#endif
+        }
+        catch( std::exception& ex ) {
+            return ex.what();
+        }
+        catch( std::string& msg ) {
+            return msg;
+        }
+        catch( const char* msg ) {
+            return msg;
+        }
+        catch(...) {
+            return "Unknown exception";
+        }
+    }*/
+
+class MethodTestCase : public SharedImpl<ITestCase> {
+
+    struct placeholder
+    {
+        virtual ~placeholder() {}
+        virtual placeholder* clone() const = 0;
+        virtual void invoke() const = 0;
+    };
+
+    template <typename C>
+    struct holder : public placeholder
+    {
+        holder( void (C::*method)() ) : m_method( method ) {}
+        virtual placeholder* clone() const {return new holder(*this);}
+        void invoke() const {
+            C obj;
+            (obj.*m_method)();
+        }
+        void (C::*m_method)();
+    };
+
+    virtual void invoke() const
+    {
+        if( held ) held->invoke();
+    }
+public:
+    template<typename C>
+    MethodTestCase( void (C::*method)() ) : held(new holder<C>(method) ) {}
+    ~MethodTestCase() { delete held;}
+
+
+private:
+    MethodTestCase();                       // not implemented
+    MethodTestCase(const MethodTestCase&);  // not implemented
+    MethodTestCase& operator=(const MethodTestCase&);  // not implemented
+
+    placeholder* held;
+};
+
+typedef void(*TestFunction)();
+
+struct NameAndDesc {
+#if (_MANAGED == 1) || (_M_CEE == 1) // detect CLR
+    NameAndDesc( const char* _name = "", const char* _description= "" )
+    : name( _name ), description( _description )
+    {}
+    NameAndDesc( const char* _name, int )
+    : name( _name ), description( "" )
+    {}
+#else
+    NameAndDesc( const wchar_t* _name, const char* _description= ""  )
+    : name(), description( _description )
+    {
+        stdext::cvt::wstring_convert<std::codecvt_utf8<wchar_t> > conv1;
+        name = conv1.to_bytes(_name);
+    }
+    NameAndDesc( const wchar_t* _name, int  )
+    : name(), description( "" )
+    {
+        stdext::cvt::wstring_convert<std::codecvt_utf8<wchar_t> > conv1;
+        name = conv1.to_bytes(_name);
+    }
+#endif
+
+    std::string name;
+    std::string description;
+};
+
+} // end namespace Catch
+
+#if (_MANAGED == 1) || (_M_CEE == 1) // detect CLR
+
+#define CATCH_INTERNAL_HANDLE_EMPTY_PARAM2( name ) name##""
+#define CATCH_INTERNAL_HANDLE_EMPTY_PARAM(...) CATCH_INTERNAL_HANDLE_EMPTY_PARAM2( INTERNAL_CATCH_SPLIT_ARGS_2(__VA_ARGS__) )
+
+#define INTERNAL_CATCH_CLASS_DEFINITION( cls ) \
+            [TestClass] \
+            public ref class cls
+
+#define INTERNAL_CATCH_CLASS_CONTEXT \
+        private: \
+	        TestContext^ testContextInstance; \
+        public: \
+	        property Microsoft::VisualStudio::TestTools::UnitTesting::TestContext^ TestContext \
+	        { \
+		        Microsoft::VisualStudio::TestTools::UnitTesting::TestContext^ get() \
+		        { \
+			        return testContextInstance; \
+		        } \
+		        System::Void set(Microsoft::VisualStudio::TestTools::UnitTesting::TestContext^ value) \
+		        { \
+			        testContextInstance = value; \
+		        } \
+	        };
+
+#define CATCH_INTERNAL_NAMESPACE( Ext )
+
+#define INTERNAL_CATCH_TEST_METHOD( Method, UniqueExt, Name, Desc ) \
+        public: \
+            [TestMethod] \
+            [Description( CATCH_INTERNAL_HANDLE_EMPTY_PARAM(Name) )] \
+            [TestProperty( "Description", CATCH_INTERNAL_HANDLE_EMPTY_PARAM(Name) )] \
+            void INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H___M_E_T_H_O_D___, UniqueExt) () \
+            { \
+                Catch::NameAndDesc name_desc( CATCH_INTERNAL_HANDLE_EMPTY_PARAM(Name), Desc ); \
+                CATCH_INTERNAL_RUN_SINGLE_TEST( Method ); \
+            }
+
+#define INTERNAL_CATCH_TEST_CLASS_METHOD( Method, UniqueExt, Name, Desc ) \
+        public: \
+            [TestMethod] \
+            [Description( CATCH_INTERNAL_HANDLE_EMPTY_PARAM(Name) )] \
+            [TestProperty( "Description", CATCH_INTERNAL_HANDLE_EMPTY_PARAM(Name) )] \
+            void INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H___M_E_T_H_O_D___, UniqueExt) () \
+            { \
+                Catch::NameAndDesc name_desc( CATCH_INTERNAL_HANDLE_EMPTY_PARAM(Name), Desc ); \
+                CATCH_INTERNAL_RUN_SINGLE_CLASS_TEST( Method ); \
+            }
+
+#define CHECK_FOR_TEST_CASE_CLASH 
+
+#else // detect CLR
+
+// Native tests
+
+#define INTERNAL_CATCH_CLASS_DEFINITION( cls ) \
+            TEST_CLASS( cls )
+
+#define INTERNAL_CATCH_CLASS_CONTEXT
+
+#define CATCH_INTERNAL_NAMESPACE( Ext ) INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H___N_S_, Ext )
+
+#define TEST2( ... ) TEST_IMPL_2( (__VA_ARGS__, 2, 1) )
+#define TEST_IMPL_2(tuple) TEST_IMPL2 tuple
+#define TEST_IMPL2( INTERNAL_CATCH_SPLIT_ARG_1,INTERNAL_CATCH_SPLIT_ARG_2,N,...) L#INTERNAL_CATCH_SPLIT_ARG_1
+
+#define CATCH_INTERNAL_HANDLE_EMPTY_PARAM(...) CATCH_INTERNAL_HANDLE_EMPTY_PARAM_IMPL( (__VA_ARGS__, 2, 1) )
+#define CATCH_INTERNAL_HANDLE_EMPTY_PARAM_IMPL(tuple) CATCH_INTERNAL_HANDLE_EMPTY_PARAM_IMPL2 tuple
+#define CATCH_INTERNAL_HANDLE_EMPTY_PARAM_IMPL2( INTERNAL_CATCH_SPLIT_ARG_1,INTERNAL_CATCH_SPLIT_ARG_2,N,...) #INTERNAL_CATCH_SPLIT_ARG_1
+#define CATCH_INTERNAL_HANDLE_EMPTY_PARAMW(...) CATCH_INTERNAL_HANDLE_EMPTY_PARAM_IMPLW( (__VA_ARGS__, 2, 1) )
+#define CATCH_INTERNAL_HANDLE_EMPTY_PARAM_IMPLW(tuple) CATCH_INTERNAL_HANDLE_EMPTY_PARAM_IMPL2W tuple
+#define CATCH_INTERNAL_HANDLE_EMPTY_PARAM_IMPL2W( INTERNAL_CATCH_SPLIT_ARG_1,INTERNAL_CATCH_SPLIT_ARG_2,N,...) L#INTERNAL_CATCH_SPLIT_ARG_1
+
+#define INTERNAL_CATCH_TEST_METHOD( Method, UniqueExt, Name, Desc ) \
+        public: \
+	    BEGIN_TEST_METHOD_ATTRIBUTE( INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H___M_E_T_H_O_D___, UniqueExt) ) \
+            TEST_OWNER( CATCH_INTERNAL_HANDLE_EMPTY_PARAMW(Name) ) \
+            TEST_DESCRIPTION( CATCH_INTERNAL_HANDLE_EMPTY_PARAMW(Name) ) \
+	    END_TEST_METHOD_ATTRIBUTE() \
+    	TEST_METHOD( INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H___M_E_T_H_O_D___, UniqueExt) ) \
+        { \
+            Catch::NameAndDesc name_desc(CATCH_INTERNAL_HANDLE_EMPTY_PARAMW(Name), Desc ); \
+            CATCH_INTERNAL_RUN_SINGLE_TEST( Method ); \
+        }
+
+#define INTERNAL_CATCH_TEST_CLASS_METHOD( Method, UniqueExt, Name, Desc ) \
+        public: \
+	    BEGIN_TEST_METHOD_ATTRIBUTE( INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H___M_E_T_H_O_D___, UniqueExt) ) \
+            TEST_OWNER( CATCH_INTERNAL_HANDLE_EMPTY_PARAMW(Name) ) \
+            TEST_DESCRIPTION( CATCH_INTERNAL_HANDLE_EMPTY_PARAMW(Name) ) \
+	    END_TEST_METHOD_ATTRIBUTE() \
+    	TEST_METHOD( INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H___M_E_T_H_O_D___, UniqueExt) ) \
+        { \
+            Catch::NameAndDesc name_desc( CATCH_INTERNAL_HANDLE_EMPTY_PARAMW(Name), Desc ); \
+            CATCH_INTERNAL_RUN_SINGLE_CLASS_TEST( Method ); \
+        }
+
+#define CHECK_FOR_TEST_CASE_CLASH void INTERNAL_CATCH_UNIQUE_NAME_LINE( if_you_get_this_error_you_have_a_test_case_name_clash_please_put_a_namespace_around_the_test_case_at_line_, __LINE__ )() {}
+
+#endif // detect CLR
+
+#define INTERNAL_CATCH_CONCAT_LINE_COUNTER INTERNAL_CATCH_UNIQUE_NAME_LINE( INTERNAL_CATCH_UNIQUE_NAME_LINE( __LINE__, _ ), __COUNTER__ )
+
+#define CATCH_INTERNAL_RUN_SINGLE_TEST( Method ) \
+        {   Catch::ConfigData cd; \
+            cd.name = name_desc.name; \
+            Catch::Ptr<Catch::Config> config(new Catch::Config(cd)); \
+            Catch::MSTestReporter* rep = new Catch::MSTestReporter(config.get()); \
+            Catch::RunContext tr(config.get(), rep); \
+            Catch::TestCase tc = Catch::makeTestCase( new Catch::FreeFunctionTestCase( & Method ), "", name_desc.name, name_desc.description, CATCH_INTERNAL_LINEINFO ); \
+            tr.runTest(tc); \
+        }
+
+#define CATCH_INTERNAL_RUN_SINGLE_CLASS_TEST( ClassMethod ) \
+        {   Catch::ConfigData cd; \
+            cd.name = name_desc.name; \
+            Catch::Ptr<Catch::Config> config(new Catch::Config(cd)); \
+            Catch::MSTestReporter* rep = new Catch::MSTestReporter(config.get()); \
+            Catch::RunContext tr(config.get(), rep); \
+            Catch::TestCase tc = Catch::makeTestCase( new Catch::MethodTestCase( & ClassMethod ), # ClassMethod, name_desc.name, name_desc.description, CATCH_INTERNAL_LINEINFO ); \
+            tr.runTest(tc); \
+        }
+
+#define INTERNAL_CATCH_TESTCASE2( UniqueExt, Name, Desc ) \
+    CHECK_FOR_TEST_CASE_CLASH \
+    static void INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H____T_E_S_T____, UniqueExt )(); \
+    namespace CATCH_INTERNAL_NAMESPACE( UniqueExt ) { \
+        INTERNAL_CATCH_CLASS_DEFINITION( INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H____T_E_S_T____C_L_A_S_S___, UniqueExt ) ) \
+        { \
+            INTERNAL_CATCH_CLASS_CONTEXT \
+            INTERNAL_CATCH_TEST_METHOD( INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H____T_E_S_T____, UniqueExt ), UniqueExt, Name, Desc ) \
+        }; \
+    } \
+    void INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H____T_E_S_T____, UniqueExt )()
+
+#define INTERNAL_CATCH_METHOD_AS_TEST_CASE2( QualifiedMethod, UniqueExt, Name, Desc ) \
+    CHECK_FOR_TEST_CASE_CLASH \
+    namespace CATCH_INTERNAL_NAMESPACE( UniqueExt ) { \
+        INTERNAL_CATCH_CLASS_DEFINITION( INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H____T_E_S_T____C_L_A_S_S___, UniqueExt ) ) \
+        { \
+            INTERNAL_CATCH_CLASS_CONTEXT \
+            INTERNAL_CATCH_TEST_CLASS_METHOD( QualifiedMethod, UniqueExt, Name, Desc ) \
+        }; \
+    };
+
+#define INTERNAL_CATCH_TEST_CASE_METHOD2( ClassName, UniqueExt, TestName, Desc ) \
+    CHECK_FOR_TEST_CASE_CLASH \
+    struct INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H____T_E_S_T____, UniqueExt ) : ClassName { \
+        void test(); \
+        static void invoke() { INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H____T_E_S_T____, UniqueExt ) tmp; tmp.test(); } \
+    }; \
+    namespace CATCH_INTERNAL_NAMESPACE( UniqueExt ) { \
+        INTERNAL_CATCH_CLASS_DEFINITION( INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H____T_E_S_T____C_L_A_S_S___, UniqueExt ) ) \
+        { \
+            INTERNAL_CATCH_CLASS_CONTEXT \
+            INTERNAL_CATCH_TEST_METHOD( INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H____T_E_S_T____, UniqueExt )::invoke, UniqueExt, TestName, Desc ) \
+        }; \
+    } \
+    void INTERNAL_CATCH_UNIQUE_NAME_LINE( C_A_T_C_H____T_E_S_T____, UniqueExt )::test()
+
+//#undef CATCH_CONFIG_VARIADIC_MACROS
+
+#ifdef CATCH_CONFIG_VARIADIC_MACROS
+
+    #define INTERNAL_CATCH_SPLIT_ARGS_2( ... ) INTERNAL_CATCH_SPLIT_ARGS_IMPL_2((__VA_ARGS__, 2,1))
+    #define INTERNAL_CATCH_SPLIT_ARGS_IMPL_2(tuple) INTERNAL_CATCH_SPLIT_ARGS_IMPL2 tuple
+    #define INTERNAL_CATCH_SPLIT_ARGS_IMPL2(INTERNAL_CATCH_SPLIT_ARG_1,INTERNAL_CATCH_SPLIT_ARG_2,N,...) INTERNAL_CATCH_SPLIT_ARG_1
+    #define INTERNAL_CATCH_SPLIT_TAGS( ... ) INTERNAL_CATCH_SPLIT_TAGS_IMPL((__VA_ARGS__, 2,1))
+    #define INTERNAL_CATCH_SPLIT_TAGS_IMPL(tuple) INTERNAL_CATCH_SPLIT_TAGS_IMPL_ tuple
+    #define INTERNAL_CATCH_SPLIT_TAGS_IMPL_(INTERNAL_CATCH_SPLIT_ARG_1,INTERNAL_CATCH_SPLIT_ARG_2,N,...) INTERNAL_CATCH_SPLIT_ARG_2
+
+    #define INTERNAL_CATCH_TESTCASE( ... ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_CONCAT_LINE_COUNTER, INTERNAL_CATCH_SPLIT_ARGS_2(__VA_ARGS__), INTERNAL_CATCH_SPLIT_TAGS(__VA_ARGS__) )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        INTERNAL_CATCH_METHOD_AS_TEST_CASE2( QualifiedMethod, INTERNAL_CATCH_CONCAT_LINE_COUNTER, INTERNAL_CATCH_SPLIT_ARGS_2(__VA_ARGS__), INTERNAL_CATCH_SPLIT_TAGS(__VA_ARGS__) )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... )\
+        INTERNAL_CATCH_TEST_CASE_METHOD2(ClassName, INTERNAL_CATCH_CONCAT_LINE_COUNTER, INTERNAL_CATCH_SPLIT_ARGS_2(__VA_ARGS__), INTERNAL_CATCH_SPLIT_TAGS(__VA_ARGS__) )
+
+#else
+    ///////////////////////////////////////////////////////////////////////////////
+
+    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_CONCAT_LINE_COUNTER, Name, Desc )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
+        INTERNAL_CATCH_METHOD_AS_TEST_CASE2( QualifiedMethod, INTERNAL_CATCH_CONCAT_LINE_COUNTER, Name, Desc )
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
+        INTERNAL_CATCH_TEST_CASE_METHOD2(ClassName, INTERNAL_CATCH_CONCAT_LINE_COUNTER, TestName, Desc )
+
+#endif
+
+#include "catch_test_case_info.hpp"
+#include "catch_assertionresult.hpp"
+#include "catch_expressionresult_builder.hpp"
+#include "catch_version.hpp"
+#include "catch_text.h"
+#include "catch_text.hpp"
+#include "catch_runner_impl.hpp"
+#include "catch_message.hpp"
+#include "catch_context_impl.hpp"
+#include "catch_generators_impl.hpp"
+#include "catch_test_case_info.hpp"
+#include "catch_notimplemented_exception.hpp"
+
+#include "catch_exception_translator_registry.hpp"
+
+namespace Catch {
+    inline NonCopyable::~NonCopyable() {}
+    inline IShared::~IShared() {}
+    inline StreamBufBase::~StreamBufBase() throw() {}
+    inline IContext::~IContext() {}
+    inline IResultCapture::~IResultCapture() {}
+    inline ITestCase::~ITestCase() {}
+    inline ITestCaseRegistry::~ITestCaseRegistry() {}
+    inline IRegistryHub::~IRegistryHub() {}
+    inline IMutableRegistryHub::~IMutableRegistryHub() {}
+    inline IExceptionTranslator::~IExceptionTranslator() {}
+    inline IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
+    inline IReporter::~IReporter() {}
+    inline IReporterFactory::~IReporterFactory() {}
+    inline IReporterRegistry::~IReporterRegistry() {}
+    inline IStreamingReporter::~IStreamingReporter() {}
+    inline AssertionStats::~AssertionStats() {}
+    inline SectionStats::~SectionStats() {}
+    inline TestCaseStats::~TestCaseStats() {}
+    inline TestGroupStats::~TestGroupStats() {}
+    inline TestRunStats::~TestRunStats() {}
+    //CumulativeReporterBase::SectionNode::~SectionNode() {}
+    //CumulativeReporterBase::~CumulativeReporterBase() {}
+
+    //StreamingReporterBase::~StreamingReporterBase() {}
+    //ConsoleReporter::~ConsoleReporter() {}
+    inline IRunner::~IRunner() {}
+    inline IMutableContext::~IMutableContext() {}
+    inline IConfig::~IConfig() {}
+    //XmlReporter::~XmlReporter() {}
+    //JunitReporter::~JunitReporter() {}
+    //TestRegistry::~TestRegistry() {}
+    inline FreeFunctionTestCase::~FreeFunctionTestCase() {}
+    inline IGeneratorInfo::~IGeneratorInfo() {}
+    inline IGeneratorsForTest::~IGeneratorsForTest() {}
+    inline TagParser::~TagParser() {}
+    inline TagExtracter::~TagExtracter() {}
+    inline TagExpressionParser::~TagExpressionParser() {}
+
+    inline Matchers::Impl::StdString::Equals::~Equals() {}
+    inline Matchers::Impl::StdString::Contains::~Contains() {}
+    inline Matchers::Impl::StdString::StartsWith::~StartsWith() {}
+    inline Matchers::Impl::StdString::EndsWith::~EndsWith() {}
+
+    inline void Config::dummy() {}
+
+    //INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( "xml", XmlReporter )
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif // TWOBLUECUBES_CATCH_MSTEST_REGISTRY_HPP_INCLUDED

include/reporters/catch_vs_reporter.hpp

@@ -0,0 +1,458 @@
+/*
+ *  Created by Malcolm on 4/11/2013.
+ *  Copyright 2013 Malcolm Noyes. 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_MSTEST_HPP_INCLUDED
+#define TWOBLUECUBES_CATCH_REPORTER_MSTEST_HPP_INCLUDED
+
+#include "../internal/catch_interfaces_reporter.h"
+//#include "../internal/catch_reporter_registrars.hpp"
+#include "../internal/catch_text.h"
+//#include "../internal/catch_console_colour.hpp"
+#include "../internal/catch_version.h"
+//#include <sstream>
+
+namespace Catch {
+
+#if (_MANAGED == 1) || (_M_CEE == 1) // detect CLR
+
+    inline void write_output_message(const std::string& msg)
+    {
+        String^ tmp = gcnew String(msg.c_str());
+        Console::WriteLine(tmp);
+    }
+
+#else // detect CLR
+
+#ifdef _WINDLL
+
+#ifdef _UNICODE
+    inline void write_output_message(const std::string& msg)
+    {
+        std::wstringstream _s;
+        _s << msg.c_str();
+        std::wstring ws = _s.str();
+        Logger::WriteMessage(ws.c_str());
+    }
+#else
+    inline void write_output_message(const std::string& msg)
+    {
+        Logger::WriteMessage(msg.c_str());
+    }
+#endif
+
+#endif // _WINDLL
+
+#endif  // detect CLR
+
+    struct MSTestReporter : SharedImpl<IStreamingReporter> {
+        MSTestReporter( Ptr<IConfig> const& _fullConfig )
+        :   m_config( _fullConfig ),
+            m_headerPrinted( false ),
+            m_atLeastOneTestCasePrinted( false )
+        {}
+
+        virtual ~MSTestReporter() {
+            if( m_atLeastOneTestCasePrinted ) {
+                write_output_message(stream.str());
+            }
+        }
+    
+        static std::string getDescription() {
+            return "Reports test results to MSTest";
+        }
+        virtual ReporterPreferences getPreferences() const {
+            ReporterPreferences prefs;
+            prefs.shouldRedirectStdOut = true;
+            return prefs;
+        }
+
+        //base
+        virtual void noMatchingTestCases( std::string const& ) {}
+
+        virtual void testRunStarting( TestRunInfo const& _testRunInfo ) {
+            currentTestRunInfo = _testRunInfo;
+        }
+        virtual void testGroupStarting( GroupInfo const& _groupInfo ) {
+            currentGroupInfo = _groupInfo;
+        }
+
+        virtual void testCaseStarting( TestCaseInfo const& _testInfo ) {
+            currentTestCaseInfo = _testInfo;
+        }
+        virtual void sectionStarting( SectionInfo const& _sectionInfo ) {
+            m_headerPrinted = false;
+            m_sectionStack.push_back( _sectionInfo );
+        }
+
+        virtual void sectionEnded( SectionStats const& _sectionStats ) {
+            if( _sectionStats.missingAssertions ) {
+                lazyPrint();
+                if( m_sectionStack.size() > 1 )
+                    stream << "\r\n" << "No assertions in section";
+                else
+                    stream << "\r\n" << "No assertions in test case";
+                stream << " '" << _sectionStats.sectionInfo.name << "'" << "\r\n" << "\r\n";
+            }
+            if( m_headerPrinted ) {
+                if( m_config->showDurations() == ShowDurations::Always )
+                    stream << "Completed in " << _sectionStats.durationInSeconds << "s" << "\r\n";
+                m_headerPrinted = false;
+            }
+            else {
+                if( m_config->showDurations() == ShowDurations::Always )
+                    stream << _sectionStats.sectionInfo.name << " completed in " << _sectionStats.durationInSeconds << "s" << "\r\n";
+            }
+            m_sectionStack.pop_back();
+        }
+        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) {
+            if( !_testCaseStats.stdOut.empty() ) {
+                write_output_message(getDoubleDashes());
+                write_output_message("Output to std::cout :");
+                write_output_message(getDashes());
+                write_output_message(_testCaseStats.stdOut);
+                write_output_message(getDoubleDashes());
+            }
+            if( !_testCaseStats.stdErr.empty() ) {
+                write_output_message(getDoubleDashes());
+                write_output_message("Output to std::cerr :");
+                write_output_message(getDashes());
+                write_output_message(_testCaseStats.stdErr);
+                write_output_message(getDoubleDashes());
+            }
+            if( _testCaseStats.totals.assertions.failed ) {
+                Assert::IsTrue(false, L"At least one test failed - examine output for CHECK failures.");
+            }
+            m_headerPrinted = false;
+            currentTestCaseInfo.reset();
+            assert( m_sectionStack.empty() );
+        }
+        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) {
+            if( currentGroupInfo.used ) {
+                printSummaryDivider();
+                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':" << "\r\n";
+                printTotals( _testGroupStats.totals );
+                stream << "\r\n" << "\r\n";
+            }
+            currentGroupInfo.reset();
+        }
+        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
+            if( m_atLeastOneTestCasePrinted )
+                printTotalsDivider();
+            printTotals( _testRunStats.totals );
+            stream << "\r\n" << "\r\n";
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+        // base end
+
+        virtual void assertionStarting( AssertionInfo const& ) {
+        }
+
+        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
+            AssertionResult const& result = _assertionStats.assertionResult;
+
+            // Drop out if result was successful and we're not printing those
+            if( !m_config->includeSuccessfulResults() && result.isOk() )
+                return false;
+
+            lazyPrint();
+
+            AssertionPrinter printer( stream, _assertionStats );
+            printer.print();
+            stream << "\r\n";
+            return true;
+        }
+
+    private:
+
+        class AssertionPrinter {
+            void operator= ( AssertionPrinter const& );
+        public:
+            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats )
+            :   stream( _stream ),
+                stats( _stats ),
+                result( _stats.assertionResult ),
+                message( result.getMessage() ),
+                messages( _stats.infoMessages )
+            {
+                switch( result.getResultType() ) {
+                    case ResultWas::Ok:
+                        passOrFail = "PASSED";
+                        //if( result.hasMessage() )
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ExpressionFailed:
+                        if( result.isOk() ) {
+                            passOrFail = "FAILED - but was ok";
+                        }
+                        else {
+                            passOrFail = "FAILED";
+                        }
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "with messages";
+                        break;
+                    case ResultWas::ThrewException:
+                        passOrFail = "FAILED";
+                        messageLabel = "due to unexpected exception with message";
+                        break;
+                    case ResultWas::DidntThrowException:
+                        passOrFail = "FAILED";
+                        messageLabel = "because no exception was thrown where one was expected";
+                        break;
+                    case ResultWas::Info:
+                        messageLabel = "info";
+                        break;
+                    case ResultWas::Warning:
+                        messageLabel = "warning";
+                        break;
+                    case ResultWas::ExplicitFailure:
+                        passOrFail = "FAILED";
+                        if( _stats.infoMessages.size() == 1 )
+                            messageLabel = "explicitly with message";
+                        if( _stats.infoMessages.size() > 1 )
+                            messageLabel = "explicitly with messages";
+                        break;
+                    // These cases are here to prevent compiler warnings
+                    case ResultWas::Unknown:
+                    case ResultWas::FailureBit:
+                    case ResultWas::Exception:
+                        passOrFail = "** internal error **";
+                        break;
+                }
+            }
+
+            void print() const {
+                printSourceInfo();
+                if( stats.totals.assertions.total() > 0 ) {
+                    if( result.isOk() )
+                        stream << "\r\n";
+                    printResultType();
+                    printOriginalExpression();
+                    printReconstructedExpression();
+                }
+                else {
+                    stream << "\r\n";
+                }
+                printMessage();
+            }
+
+        private:
+            void printResultType() const {
+                if( !passOrFail.empty() ) {
+                    stream << passOrFail << ":" << "\r\n";
+                }
+            }
+            void printOriginalExpression() const {
+                if( result.hasExpression() ) {
+                    stream  << "  ";
+                    stream << result.getExpressionInMacro();
+                    stream << "\r\n";
+                }
+            }
+            void printReconstructedExpression() const {
+                if( result.hasExpandedExpression() ) {
+                    stream << "with expansion:" << "\r\n";
+                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << "\r\n";
+                }
+            }
+            void printMessage() const {
+                if( !messageLabel.empty() )
+                    stream << messageLabel << ":" << "\r\n";
+                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
+                        it != itEnd;
+                        ++it ) {
+                    stream << Text( it->message, TextAttributes().setIndent(2) ) << "\r\n";
+                }
+            }
+            void printSourceInfo() const {
+                stream << result.getSourceInfo() << ": ";
+            }
+
+            std::ostream& stream;
+            AssertionStats const& stats;
+            AssertionResult const& result;
+            std::string passOrFail;
+            std::string messageLabel;
+            std::string message;
+            std::vector<MessageInfo> messages;
+        };
+
+        void lazyPrint() {
+
+            if( !currentTestRunInfo.used )
+                lazyPrintRunInfo();
+            if( !currentGroupInfo.used )
+                lazyPrintGroupInfo();
+
+            if( !m_headerPrinted ) {
+                printTestCaseAndSectionHeader();
+                m_headerPrinted = true;
+            }
+            m_atLeastOneTestCasePrinted = true;
+        }
+        void lazyPrintRunInfo() {
+            stream  << getTildes() << "\r\n";
+            stream  << "Using Catch v"  << libraryVersion::value.majorVersion << "."
+                    << libraryVersion::value.minorVersion << " b"
+                    << libraryVersion::value.buildNumber;
+            if( libraryVersion::value.branchName != "master" )
+                stream << " (" << libraryVersion::value.branchName << ")";
+#if (_MANAGED == 1) || (_M_CEE == 1) // detect CLR
+            stream  << " for a managed MSTest project." << "\r\n";
+#else
+#ifdef _WINDLL
+            stream  << " for a native MSTest project." << "\r\n";
+#endif
+#endif
+
+            currentTestRunInfo.used = true;
+        }
+        void lazyPrintGroupInfo() {
+            if( currentGroupInfo.some() )
+            {
+                if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
+                    printClosedHeader( "Group: " + currentGroupInfo->name );
+                    currentGroupInfo.used = true;
+                }
+            }
+        }
+        void printTestCaseAndSectionHeader() {
+            assert( !m_sectionStack.empty() );
+            printOpenHeader( currentTestCaseInfo->name );
+
+            if( m_sectionStack.size() > 1 ) {
+
+                std::vector<SectionInfo>::const_iterator
+                    it = m_sectionStack.begin()+1, // Skip first section (test case)
+                    itEnd = m_sectionStack.end();
+                for( ; it != itEnd; ++it )
+                    printHeaderString( it->name, 2 );
+            }
+
+            SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+            if( !lineInfo.empty() ){
+                stream << getDashes() << "\r\n";
+                stream << lineInfo << "\r\n";
+            }
+            stream << getDots() << "\r\n" << "\r\n";
+        }
+
+        void printClosedHeader( std::string const& _name ) {
+            printOpenHeader( _name );
+            stream << getDots() << "\r\n";
+        }
+        void printOpenHeader( std::string const& _name ) {
+            stream  << getDashes() << "\r\n";
+            {
+                printHeaderString( _name );
+            }
+        }
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
+            std::size_t i = _string.find( ": " );
+            if( i != std::string::npos )
+                i+=2;
+            else
+                i = 0;
+            stream << Text( _string, TextAttributes()
+                                        .setIndent( indent+i)
+                                        .setInitialIndent( indent ) ) << "\r\n";
+        }
+
+        void printTotals( const Totals& totals ) {
+            if( totals.assertions.total() == 0 ) {
+                stream << "No tests ran";
+            }
+            else if( totals.assertions.failed ) {
+                printCounts( "test case", totals.testCases );
+                if( totals.testCases.failed > 0 ) {
+                    stream << " (";
+                    printCounts( "assertion", totals.assertions );
+                    stream << ")";
+                }
+            }
+            else {
+                stream << "All tests passed ("
+                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
+                        << pluralise( totals.testCases.passed, "test case" ) << ")";
+            }
+        }
+        void printCounts( std::string const& label, Counts const& counts ) {
+            if( counts.total() == 1 ) {
+                stream << "1 " << label << " - ";
+                if( counts.failed )
+                    stream << "failed";
+                else
+                    stream << "passed";
+            }
+            else {
+                stream << counts.total() << " " << label << "s ";
+                if( counts.passed ) {
+                    if( counts.failed )
+                        stream << "- " << counts.failed << " failed";
+                    else if( counts.passed == 2 )
+                        stream << "- both passed";
+                    else
+                        stream << "- all passed";
+                }
+                else {
+                    if( counts.failed == 2 )
+                        stream << "- both failed";
+                    else
+                        stream << "- all failed";
+                }
+            }
+        }
+
+        void printTotalsDivider() {
+            stream << getDoubleDashes() << "\r\n";
+        }
+        void printSummaryDivider() {
+            stream << getDashes() << "\r\n";
+        }
+        static std::string getDashes() {
+            std::string dashes( CATCH_CONFIG_CONSOLE_WIDTH-1, '-' );
+            return dashes;
+        }
+        static std::string getDots() {
+            std::string dots( CATCH_CONFIG_CONSOLE_WIDTH-1, '.' );
+            return dots;
+        }
+        static std::string getDoubleDashes() {
+            std::string doubleDashes( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
+            return doubleDashes;
+        }
+        static std::string getTildes() {
+            std::string dots( CATCH_CONFIG_CONSOLE_WIDTH-1, '~' );
+            return dots;
+        }
+
+    private:
+        Ptr<IConfig> m_config;
+        std::ostringstream stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+        bool m_headerPrinted;
+        bool m_atLeastOneTestCasePrinted;
+    };
+
+} // end namespace Catch
+
+#endif // TWOBLUECUBES_CATCH_REPORTER_MSTEST_HPP_INCLUDED