merge

internal/catch_capture.hpp

@@ -18,13 +18,66 @@
 
 namespace Catch
 {
+namespace Detail
+{
+    // The following code, contributed by Sam Partington, allows us to choose an implementation
+    // of toString() depending on whether a << overload is available
+    
+    struct NonStreamable
+    {
+        // allow construction from anything...
+        template<typename Anything> 
+        NonStreamable(Anything)
+        {}
+    };
+    
+    // a local operator<<  which may be called if there isn't a better one elsewhere...
+    inline NonStreamable operator << ( std::ostream&, const NonStreamable& ns )
+    {
+        return ns;
+    }
+
+    template<typename T>
+    struct IsStreamable
+    {
+        static NoType Deduce( const NonStreamable& );
+        static YesType Deduce( std::ostream& );
+
+        enum
+        {
+            value = sizeof( Deduce( Synth<std::ostream&>() << Synth<const T&>() ) ) 
+                        == sizeof( YesType )
+        };
+    };
+    
+    // << is available, so use it with ostringstream to make the string
+    template<typename T, bool streamable>
+    struct StringMaker
+    {
+        static std::string apply( const T& value )
+        {
+            std::ostringstream oss;
+            oss << value;
+            return oss.str();
+        }
+    };
+      
+    // << not available - use a default string
+    template<typename T>
+    struct StringMaker<T, false>
+    {
+        static std::string apply( const T& value )
+        {
+            return "{?}";
+        }
+    };
+
+}// end namespace Detail
 
 template<typename T>
 std::string toString( const T& value )
 {
-    std::ostringstream oss;
-    oss << value;
-    return oss.str();
+    return Detail::StringMaker<T, Detail::IsStreamable<T>::value>::apply( value );
 }
 
 class TestFailureException

internal/catch_common.h

@@ -26,6 +26,12 @@ namespace Catch
 	protected:
 		NonCopyable(){}
 	};
+    
+    typedef char NoType;
+    typedef int YesType;
+
+    // create a T for use in sizeof expressions
+    template<typename T> T Synth();    
 }
 
 #endif // TWOBLUECUBES_CATCH_COMMON_H_INCLUDED

internal/catch_registry.hpp

@@ -16,8 +16,11 @@
 #include "catch_common.h"
 
 #include <vector>
+#include <set>
 #include <stdexcept>
 
+#include <iostream>
+
 namespace Catch
 {
 class TestRegistry
@@ -32,17 +35,22 @@ public:
     
     void registerTest( const TestCaseInfo& testInfo )
     {
-        m_functions.push_back( testInfo );
+        if( m_functions.find( testInfo ) == m_functions.end() )
+        {
+            m_functions.insert( testInfo );
+            m_functionsInOrder.push_back( testInfo );
+        }
     }
         
     std::vector<TestCaseInfo> getAllTests() const
     {
-        return m_functions;
+        return m_functionsInOrder;
     }
         
 private:
         
-    std::vector<TestCaseInfo> m_functions;
+    std::set<TestCaseInfo> m_functions;
+    std::vector<TestCaseInfo> m_functionsInOrder;
 };
 
 typedef void(*TestFunction)();
@@ -63,6 +71,18 @@ struct FreeFunctionTestCase : TestCase
         return new FreeFunctionTestCase( fun );
     }
 
+    virtual bool operator == ( const TestCase& other ) const
+    {
+        const FreeFunctionTestCase* ffOther = dynamic_cast<const FreeFunctionTestCase*> ( &other );
+        return ffOther && fun == ffOther->fun;
+    }
+    
+    virtual bool operator < ( const TestCase& other ) const
+    {
+        const FreeFunctionTestCase* ffOther = dynamic_cast<const FreeFunctionTestCase*> ( &other );
+        return ffOther && fun < ffOther->fun;
+    }
+    
 private:
     TestFunction fun;
 };
@@ -84,6 +104,18 @@ struct MethodTestCase : TestCase
     {
         return new MethodTestCase<C>( method );
     }
+
+    virtual bool operator == ( const TestCase& other ) const
+    {
+        const MethodTestCase* mtOther = dynamic_cast<const MethodTestCase*>( &other );
+        return mtOther && method == mtOther->method;
+    }
+    
+    virtual bool operator < ( const TestCase& other ) const
+    {
+        const MethodTestCase* mtOther = dynamic_cast<const MethodTestCase*>( &other );
+        return mtOther && &method < &mtOther->method;
+    }
     
 private:
     void (C::*method)();

internal/catch_testcaseinfo.hpp

@@ -23,6 +23,8 @@ namespace Catch
         virtual ~TestCase(){}
         virtual void invoke() const = 0;
         virtual TestCase* clone() const = 0;
+        virtual bool operator == ( const TestCase& other ) const = 0;
+        virtual bool operator < ( const TestCase& other ) const = 0;
     };
     
     class TestCaseInfo
@@ -79,6 +81,21 @@ namespace Catch
             description.swap( other.description );
         }
         
+        bool operator == ( const TestCaseInfo& other ) const
+        {
+            return *test == *other.test && name == other.name && description == other.description;            
+        }
+        
+        bool operator < ( const TestCaseInfo& other ) const
+        {
+            if( name < other.name )
+                return true;
+            if( name > other.name )
+                return false;
+
+            return *test < *other.test;
+        }
+        
     private:
         TestCase* test;
         std::string name;