initial commit

35 files changed, 5493 insertions, 0 deletions

diff --git a/cxxtest/Descriptions.cpp b/cxxtest/Descriptions.cpp
new file mode 100644
index 0000000..143f8f8
--- /dev/null
+++ b/cxxtest/Descriptions.cpp
@@ -0,0 +1,58 @@
+#ifndef __cxxtest__Descriptions_cpp__
+#define __cxxtest__Descriptions_cpp__
+
+#include <cxxtest/Descriptions.h>
+
+namespace CxxTest
+{
+    TestDescription::~TestDescription() {}
+    SuiteDescription::~SuiteDescription() {}
+    WorldDescription::~WorldDescription() {}
+    
+    //
+    // Convert total tests to string
+    //
+#ifndef _CXXTEST_FACTOR
+    char *WorldDescription::strTotalTests( char *s ) const
+    {
+        numberToString( numTotalTests(), s );
+        return s;
+    }
+#else // _CXXTEST_FACTOR
+    char *WorldDescription::strTotalTests( char *s ) const
+    {
+        char *p = numberToString( numTotalTests(), s );
+
+        if ( numTotalTests() <= 1 )
+            return s;
+
+        unsigned n = numTotalTests();
+        unsigned numFactors = 0;
+
+        for ( unsigned factor = 2; (factor * factor) <= n; factor += (factor == 2) ? 1 : 2 ) {
+            unsigned power;
+
+            for ( power = 0; (n % factor) == 0; n /= factor )
+                ++ power;
+
+            if ( !power )
+                continue;
+
+            p = numberToString( factor, copyString( p, (numFactors == 0) ? " = " : " * " ) );
+            if ( power > 1 )
+                p = numberToString( power, copyString( p, "^" ) );
+            ++ numFactors;
+        }
+
+        if ( n > 1 ) {
+            if ( !numFactors )
+                copyString( p, tracker().failedTests() ? " :(" : tracker().warnings() ? " :|" : " :)" );
+            else
+                numberToString( n, copyString( p, " * " ) );
+        }
+        return s;
+    }
+#endif // _CXXTEST_FACTOR
+};
+
+#endif // __cxxtest__Descriptions_cpp__
diff --git a/cxxtest/Descriptions.h b/cxxtest/Descriptions.h
new file mode 100644
index 0000000..bd373ec
--- /dev/null
+++ b/cxxtest/Descriptions.h
@@ -0,0 +1,74 @@
+#ifndef __cxxtest__Descriptions_h__
+#define __cxxtest__Descriptions_h__
+
+//
+// TestDescription, SuiteDescription and WorldDescription
+// hold information about tests so they can be run and reported.
+//
+
+#include <cxxtest/LinkedList.h>
+
+namespace CxxTest 
+{
+    class TestSuite;
+
+    class TestDescription : public Link
+    {
+    public:
+        virtual ~TestDescription();
+        
+        virtual const char *file() const = 0;
+        virtual unsigned line() const = 0;
+        virtual const char *testName() const = 0;
+        virtual const char *suiteName() const = 0;
+        
+        virtual void run() = 0;
+
+        virtual const TestDescription *next() const = 0;
+        virtual TestDescription *next() = 0;        
+    };
+
+    class SuiteDescription : public Link
+    {
+    public:
+        virtual ~SuiteDescription();
+        
+        virtual const char *file() const = 0;
+        virtual unsigned line() const = 0;
+        virtual const char *suiteName() const = 0;
+        virtual TestSuite *suite() const = 0;
+        
+        virtual unsigned numTests() const = 0;
+        virtual const TestDescription &testDescription( unsigned /*i*/ ) const = 0;
+
+        virtual TestDescription *firstTest() = 0;
+        virtual const TestDescription *firstTest() const = 0;
+        virtual SuiteDescription *next() = 0;
+        virtual const SuiteDescription *next() const = 0;
+
+        virtual void activateAllTests() = 0;
+        virtual bool leaveOnly( const char * /*testName*/ ) = 0;
+    };
+
+    class WorldDescription : public Link
+    {
+    public:
+        virtual ~WorldDescription();
+        
+        virtual unsigned numSuites( void ) const = 0;
+        virtual unsigned numTotalTests( void ) const = 0;
+        virtual const SuiteDescription &suiteDescription( unsigned /*i*/ ) const = 0;
+
+        enum { MAX_STRLEN_TOTAL_TESTS = 32 };
+        char *strTotalTests( char * /*buffer*/ ) const;
+
+        virtual SuiteDescription *firstSuite() = 0;
+        virtual const SuiteDescription *firstSuite() const = 0;
+
+        virtual void activateAllTests() = 0;
+        virtual bool leaveOnly( const char * /*suiteName*/, const char * /*testName*/ = 0 ) = 0;
+    };
+}
+
+#endif // __cxxtest__Descriptions_h__
+
diff --git a/cxxtest/DummyDescriptions.cpp b/cxxtest/DummyDescriptions.cpp
new file mode 100644
index 0000000..c862e43
--- /dev/null
+++ b/cxxtest/DummyDescriptions.cpp
@@ -0,0 +1,49 @@
+#include <cxxtest/DummyDescriptions.h>
+
+namespace CxxTest 
+{
+    DummyTestDescription::DummyTestDescription() {}
+        
+    const char *DummyTestDescription::file() const { return "<no file>"; }
+    unsigned DummyTestDescription::line() const { return 0; }
+    const char *DummyTestDescription::testName() const { return "<no test>"; }
+    const char *DummyTestDescription::suiteName() const { return "<no suite>"; }
+    bool DummyTestDescription::setUp() { return true;}
+    void DummyTestDescription::run() {}
+    bool DummyTestDescription::tearDown() { return true;}
+
+    TestDescription *DummyTestDescription::next() { return 0; }
+    const TestDescription *DummyTestDescription::next() const { return 0; }
+    
+    DummySuiteDescription::DummySuiteDescription() : _test() {}
+        
+    const char *DummySuiteDescription::file() const { return "<no file>"; }
+    unsigned DummySuiteDescription::line() const { return 0; }
+    const char *DummySuiteDescription::suiteName() const { return "<no suite>"; }
+    TestSuite *DummySuiteDescription::suite() const { return 0; }
+    unsigned DummySuiteDescription::numTests() const { return 0; }
+    const TestDescription &DummySuiteDescription::testDescription( unsigned ) const { return _test; }
+    SuiteDescription *DummySuiteDescription::next() { return 0; }
+    TestDescription *DummySuiteDescription::firstTest() { return 0; }
+    const SuiteDescription *DummySuiteDescription::next() const { return 0; }
+    const TestDescription *DummySuiteDescription::firstTest() const { return 0; }
+    void DummySuiteDescription::activateAllTests() {}
+    bool DummySuiteDescription::leaveOnly( const char * /*testName*/ ) { return false; }
+        
+    bool DummySuiteDescription::setUp() { return true;}
+    bool DummySuiteDescription::tearDown() { return true;}
+
+    DummyWorldDescription::DummyWorldDescription() : _suite() {}
+        
+    unsigned DummyWorldDescription::numSuites( void ) const { return 0; }
+    unsigned DummyWorldDescription::numTotalTests( void ) const { return 0; }
+    const SuiteDescription &DummyWorldDescription::suiteDescription( unsigned ) const { return _suite; }
+    SuiteDescription *DummyWorldDescription::firstSuite() { return 0; }
+    const SuiteDescription *DummyWorldDescription::firstSuite() const { return 0; }
+    void DummyWorldDescription::activateAllTests() {}
+    bool DummyWorldDescription::leaveOnly( const char * /*suiteName*/, const char * /*testName*/ ) { return false; }
+            
+    bool DummyWorldDescription::setUp() { return true;}
+    bool DummyWorldDescription::tearDown() { return true;}
+}
+
diff --git a/cxxtest/DummyDescriptions.h b/cxxtest/DummyDescriptions.h
new file mode 100644
index 0000000..c9215d1
--- /dev/null
+++ b/cxxtest/DummyDescriptions.h
@@ -0,0 +1,76 @@
+#ifndef __cxxtest__DummyDescriptions_h__
+#define __cxxtest__DummyDescriptions_h__
+
+//
+// DummyTestDescription, DummySuiteDescription and DummyWorldDescription
+//
+
+#include <cxxtest/Descriptions.h>
+
+namespace CxxTest 
+{
+    class DummyTestDescription : public TestDescription
+    {
+    public:
+        DummyTestDescription();
+        
+        const char *file() const;
+        unsigned line() const;
+        const char *testName() const;
+        const char *suiteName() const;
+        bool setUp();
+        void run();
+        bool tearDown();
+
+        TestDescription *next();
+        const TestDescription *next() const;
+    };
+
+    class DummySuiteDescription : public SuiteDescription
+    {      
+    public:
+        DummySuiteDescription();
+        
+        const char *file() const;
+        unsigned line() const;
+        const char *suiteName() const;
+        TestSuite *suite() const;
+        unsigned numTests() const;
+        const TestDescription &testDescription( unsigned ) const;
+        SuiteDescription *next();
+        TestDescription *firstTest();
+        const SuiteDescription *next() const;
+        const TestDescription *firstTest() const;
+        void activateAllTests();
+        bool leaveOnly( const char * /*testName*/ );
+        
+        bool setUp();
+        bool tearDown();
+
+    private:
+        DummyTestDescription _test;
+    };
+
+    class DummyWorldDescription : public WorldDescription
+    {
+    public:
+        DummyWorldDescription();
+        
+        unsigned numSuites( void ) const;
+        unsigned numTotalTests( void ) const;
+        const SuiteDescription &suiteDescription( unsigned ) const;
+        SuiteDescription *firstSuite();
+        const SuiteDescription *firstSuite() const;
+        void activateAllTests();
+        bool leaveOnly( const char * /*suiteName*/, const char * /*testName*/ = 0 );
+            
+        bool setUp();
+        bool tearDown();
+
+    private:
+        DummySuiteDescription _suite;
+    };
+}
+
+#endif // __cxxtest__DummyDescriptions_h__
+
diff --git a/cxxtest/ErrorFormatter.h b/cxxtest/ErrorFormatter.h
new file mode 100644
index 0000000..968c310
--- /dev/null
+++ b/cxxtest/ErrorFormatter.h
@@ -0,0 +1,281 @@
+#ifndef __cxxtest__ErrorFormatter_h__
+#define __cxxtest__ErrorFormatter_h__
+
+//
+// The ErrorFormatter is a TestListener that
+// prints reports of the errors to an output
+// stream.  Since we cannot rely ou the standard
+// iostreams, this header defines a base class
+// analogout to std::ostream.
+//
+
+#include <cxxtest/TestRunner.h>
+#include <cxxtest/TestListener.h>
+#include <cxxtest/TestTracker.h>
+#include <cxxtest/ValueTraits.h>
+
+namespace CxxTest
+{
+    class OutputStream
+    {
+    public:
+        virtual ~OutputStream() {}
+        virtual void flush() {};
+        virtual OutputStream &operator<<( unsigned /*number*/ ) { return *this; }
+        virtual OutputStream &operator<<( const char * /*string*/ ) { return *this; }
+
+        typedef void (*Manipulator)( OutputStream & );
+        
+        virtual OutputStream &operator<<( Manipulator m ) { m( *this ); return *this; }
+        static void endl( OutputStream &o ) { (o << "\n").flush(); }
+    };
+
+    class ErrorFormatter : public TestListener
+    {
+    public:
+        ErrorFormatter( OutputStream *o, const char *preLine = ":", const char *postLine = "" ) :
+            _dotting( true ),
+            _reported( false ),
+            _o(o),
+            _preLine(preLine),
+            _postLine(postLine)
+        {
+        }
+
+        int run()
+        {
+            TestRunner::runAllTests( *this );
+            return tracker().failedTests();
+        }
+
+        void enterWorld( const WorldDescription & /*desc*/ )
+        {
+            (*_o) << "Running " << totalTests;
+            _o->flush();
+            _dotting = true;
+            _reported = false;
+        }
+
+        static void totalTests( OutputStream &o )
+        {
+            char s[WorldDescription::MAX_STRLEN_TOTAL_TESTS];
+            const WorldDescription &wd = tracker().world();
+            o << wd.strTotalTests( s ) << (wd.numTotalTests() == 1 ? " test" : " tests");
+        }
+
+        void enterSuite( const SuiteDescription & )
+        {
+            _reported = false;
+        }
+
+        void enterTest( const TestDescription & )
+        {
+            _reported = false;
+        }
+
+        void leaveTest( const TestDescription & )
+        {
+            if ( !tracker().testFailed() ) {
+                ((*_o) << ".").flush();
+                _dotting = true;
+            }
+        }
+
+        void leaveWorld( const WorldDescription &desc )
+        {
+            if ( !tracker().failedTests() ) {
+                (*_o) << "OK!" << endl;
+                return;
+            }
+            newLine();
+            (*_o) << "Failed " << tracker().failedTests() << " of " << totalTests << endl;
+            unsigned numPassed = desc.numTotalTests() - tracker().failedTests();
+            (*_o) << "Success rate: " << (numPassed * 100 / desc.numTotalTests()) << "%" << endl;
+        }
+
+        void trace( const char *file, unsigned line, const char *expression )
+        {
+            stop( file, line ) << "Trace: " <<
+                expression << endl;
+        }
+
+        void warning( const char *file, unsigned line, const char *expression )
+        {
+            stop( file, line ) << "Warning: " <<
+                expression << endl;
+        }
+
+        void failedTest( const char *file, unsigned line, const char *expression )
+        {
+            stop( file, line ) << "Error: Test failed: " <<
+                expression << endl;
+        }
+
+        void failedAssert( const char *file, unsigned line, const char *expression )
+        {
+            stop( file, line ) << "Error: Assertion failed: " <<
+                expression << endl;
+        }
+
+        void failedAssertEquals( const char *file, unsigned line,
+                                 const char *xStr, const char *yStr,
+                                 const char *x, const char *y )
+        {
+            stop( file, line ) << "Error: Expected (" <<
+                xStr << " == " << yStr << "), found (" <<
+                x << " != " << y << ")" << endl;
+        }
+
+        void failedAssertSameData( const char *file, unsigned line,
+                                   const char *xStr, const char *yStr,
+                                   const char *sizeStr, const void *x,
+                                   const void *y, unsigned size )
+        {
+            stop( file, line ) << "Error: Expected " << sizeStr << " (" << size << ") bytes to be equal at (" <<
+                xStr << ") and (" << yStr << "), found:" << endl;
+            dump( x, size );
+            (*_o) << "     differs from" << endl;
+            dump( y, size );
+        }
+
+        void failedAssertDelta( const char *file, unsigned line,
+                                const char *xStr, const char *yStr, const char *dStr,
+                                const char *x, const char *y, const char *d )
+        {
+            stop( file, line ) << "Error: Expected (" <<
+                xStr << " == " << yStr << ") up to " << dStr << " (" << d << "), found (" <<
+                x << " != " << y << ")" << endl;
+        }
+
+        void failedAssertDiffers( const char *file, unsigned line,
+                                  const char *xStr, const char *yStr,
+                                  const char *value )
+        {
+            stop( file, line ) << "Error: Expected (" <<
+                xStr << " != " << yStr << "), found (" <<
+                value << ")" << endl;
+        }
+
+        void failedAssertLessThan( const char *file, unsigned line,
+                                   const char *xStr, const char *yStr,
+                                   const char *x, const char *y )
+        {
+            stop( file, line ) << "Error: Expected (" <<
+                xStr << " < " << yStr << "), found (" <<
+                x << " >= " << y << ")" << endl;
+        }
+
+        void failedAssertLessThanEquals( const char *file, unsigned line,
+                                         const char *xStr, const char *yStr,
+                                         const char *x, const char *y )
+        {
+            stop( file, line ) << "Error: Expected (" <<
+                xStr << " <= " << yStr << "), found (" <<
+                x << " > " << y << ")" << endl;
+        }
+
+        void failedAssertRelation( const char *file, unsigned line,
+                                   const char *relation, const char *xStr, const char *yStr,
+                                   const char *x, const char *y )
+        {
+            stop( file, line ) << "Error: Expected " << relation << "( " <<
+                xStr << ", " << yStr << " ), found !" << relation << "( " << x << ", " << y << " )" << endl;
+        }
+
+        void failedAssertPredicate( const char *file, unsigned line,
+                                    const char *predicate, const char *xStr, const char *x )
+        {
+            stop( file, line ) << "Error: Expected " << predicate << "( " <<
+                xStr << " ), found !" << predicate << "( " << x << " )" << endl;
+        }
+
+        void failedAssertThrows( const char *file, unsigned line,
+                                 const char *expression, const char *type,
+                                 bool otherThrown )
+        {
+            stop( file, line ) << "Error: Expected (" << expression << ") to throw (" <<
+                type << ") but it " << (otherThrown ? "threw something else" : "didn't throw") <<
+                endl;
+        }
+
+        void failedAssertThrowsNot( const char *file, unsigned line, const char *expression )
+        {
+            stop( file, line ) << "Error: Expected (" << expression << ") not to throw, but it did" <<
+                endl;
+        }
+
+    protected:
+        OutputStream *outputStream() const
+        {
+            return _o;
+        }
+
+    private:
+        ErrorFormatter( const ErrorFormatter & );
+        ErrorFormatter &operator=( const ErrorFormatter & );
+        
+        OutputStream &stop( const char *file, unsigned line )
+        {
+            newLine();
+            reportTest();
+            return (*_o) << file << _preLine << line << _postLine << ": ";
+        }
+
+        void newLine( void )
+        {
+            if ( _dotting ) {
+                (*_o) << endl;
+                _dotting = false;
+            }
+        }
+
+        void reportTest( void )
+        {
+            if( _reported )
+                return;
+            (*_o) << "In " << tracker().suite().suiteName() << "::" << tracker().test().testName() << ":" << endl;
+            _reported = true;
+        }
+
+        void dump( const void *buffer, unsigned size )
+        {
+            if ( !buffer )
+                dumpNull();
+            else
+                dumpBuffer( buffer, size );
+        }
+
+        void dumpNull()
+        {
+            (*_o) << "   (null)" << endl;
+        }
+        
+        void dumpBuffer( const void *buffer, unsigned size )
+        {
+            unsigned dumpSize = size;
+            if ( maxDumpSize() && dumpSize > maxDumpSize() )
+                dumpSize = maxDumpSize();
+
+            const unsigned char *p = (const unsigned char *)buffer;
+            (*_o) << "   { ";
+            for ( unsigned i = 0; i < dumpSize; ++ i )
+                (*_o) << byteToHex( *p++ ) << " ";
+            if ( dumpSize < size )
+                (*_o) << "... ";
+            (*_o) << "}" << endl;
+        }
+
+        static void endl( OutputStream &o )
+        {
+            OutputStream::endl( o );
+        }
+
+        bool _dotting;
+        bool _reported;
+        OutputStream *_o;
+        const char *_preLine;
+        const char *_postLine;
+    };
+};
+
+#endif // __cxxtest__ErrorFormatter_h__
diff --git a/cxxtest/ErrorPrinter.h b/cxxtest/ErrorPrinter.h
new file mode 100644
index 0000000..53d9425
--- /dev/null
+++ b/cxxtest/ErrorPrinter.h
@@ -0,0 +1,55 @@
+#ifndef __cxxtest__ErrorPrinter_h__
+#define __cxxtest__ErrorPrinter_h__
+
+//
+// The ErrorPrinter is a simple TestListener that
+// just prints "OK" if everything goes well, otherwise
+// reports the error in the format of compiler messages.
+// The ErrorPrinter uses std::cout
+//
+
+#include <cxxtest/Flags.h>
+
+#ifndef _CXXTEST_HAVE_STD
+#   define _CXXTEST_HAVE_STD
+#endif // _CXXTEST_HAVE_STD
+
+#include <cxxtest/ErrorFormatter.h>
+#include <cxxtest/StdValueTraits.h>
+
+#ifdef _CXXTEST_OLD_STD
+#   include <iostream.h>
+#else // !_CXXTEST_OLD_STD
+#   include <iostream>
+#endif // _CXXTEST_OLD_STD
+
+namespace CxxTest 
+{
+    class ErrorPrinter : public ErrorFormatter
+    {
+    public:
+        ErrorPrinter( CXXTEST_STD(ostream) &o = CXXTEST_STD(cout), const char *preLine = ":", const char *postLine = "" ) :
+            ErrorFormatter( new Adapter(o), preLine, postLine ) {}
+        virtual ~ErrorPrinter() { delete outputStream(); }
+
+    private:
+        class Adapter : public OutputStream
+        {
+            CXXTEST_STD(ostream) &_o;
+        public:
+            Adapter( CXXTEST_STD(ostream) &o ) : _o(o) {}
+            void flush() { _o.flush(); }
+            OutputStream &operator<<( const char *s ) { _o << s; return *this; }
+            OutputStream &operator<<( Manipulator m ) { return OutputStream::operator<<( m ); }
+            OutputStream &operator<<( unsigned i )
+            {
+                char s[1 + 3 * sizeof(unsigned)];
+                numberToString( i, s );
+                _o << s;
+                return *this;
+            }
+        };
+    };
+}
+
+#endif // __cxxtest__ErrorPrinter_h__
diff --git a/cxxtest/Flags.h b/cxxtest/Flags.h
new file mode 100644
index 0000000..be2f9f2
--- /dev/null
+++ b/cxxtest/Flags.h
@@ -0,0 +1,121 @@
+#ifndef __cxxtest__Flags_h__
+#define __cxxtest__Flags_h__
+
+//
+// These are the flags that control CxxTest
+//
+
+#if !defined(CXXTEST_FLAGS)
+#   define CXXTEST_FLAGS
+#endif // !CXXTEST_FLAGS
+
+#if defined(CXXTEST_HAVE_EH) && !defined(_CXXTEST_HAVE_EH)
+#   define _CXXTEST_HAVE_EH
+#endif // CXXTEST_HAVE_EH
+
+#if defined(CXXTEST_HAVE_STD) && !defined(_CXXTEST_HAVE_STD)
+#   define _CXXTEST_HAVE_STD
+#endif // CXXTEST_HAVE_STD
+
+#if defined(CXXTEST_OLD_TEMPLATE_SYNTAX) && !defined(_CXXTEST_OLD_TEMPLATE_SYNTAX)
+#   define _CXXTEST_OLD_TEMPLATE_SYNTAX
+#endif // CXXTEST_OLD_TEMPLATE_SYNTAX
+
+#if defined(CXXTEST_OLD_STD) && !defined(_CXXTEST_OLD_STD)
+#   define _CXXTEST_OLD_STD
+#endif // CXXTEST_OLD_STD
+
+#if defined(CXXTEST_ABORT_TEST_ON_FAIL) && !defined(_CXXTEST_ABORT_TEST_ON_FAIL)
+#   define _CXXTEST_ABORT_TEST_ON_FAIL
+#endif // CXXTEST_ABORT_TEST_ON_FAIL
+
+#if defined(CXXTEST_NO_COPY_CONST) && !defined(_CXXTEST_NO_COPY_CONST)
+#   define _CXXTEST_NO_COPY_CONST
+#endif // CXXTEST_NO_COPY_CONST
+
+#if defined(CXXTEST_FACTOR) && !defined(_CXXTEST_FACTOR)
+#   define _CXXTEST_FACTOR
+#endif // CXXTEST_FACTOR
+
+#if defined(CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION) && !defined(_CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION)
+#   define _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION
+#endif // CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION
+
+#if defined(CXXTEST_LONGLONG)
+#   if defined(_CXXTEST_LONGLONG)
+#       undef _CXXTEST_LONGLONG
+#   endif
+#   define _CXXTEST_LONGLONG CXXTEST_LONGLONG
+#endif // CXXTEST_LONGLONG
+
+#ifndef CXXTEST_MAX_DUMP_SIZE
+#   define CXXTEST_MAX_DUMP_SIZE 0
+#endif // CXXTEST_MAX_DUMP_SIZE
+
+#if defined(_CXXTEST_ABORT_TEST_ON_FAIL) && !defined(CXXTEST_DEFAULT_ABORT)
+#   define CXXTEST_DEFAULT_ABORT true
+#endif // _CXXTEST_ABORT_TEST_ON_FAIL && !CXXTEST_DEFAULT_ABORT
+
+#if !defined(CXXTEST_DEFAULT_ABORT)
+#   define CXXTEST_DEFAULT_ABORT false
+#endif // !CXXTEST_DEFAULT_ABORT
+
+#if defined(_CXXTEST_ABORT_TEST_ON_FAIL) && !defined(_CXXTEST_HAVE_EH)
+#   warning "CXXTEST_ABORT_TEST_ON_FAIL is meaningless without CXXTEST_HAVE_EH"
+#   undef _CXXTEST_ABORT_TEST_ON_FAIL
+#endif // _CXXTEST_ABORT_TEST_ON_FAIL && !_CXXTEST_HAVE_EH
+
+//
+// Some minimal per-compiler configuration to allow us to compile
+//
+
+#ifdef __BORLANDC__
+#   if __BORLANDC__ <= 0x520 // Borland C++ 5.2 or earlier
+#       ifndef _CXXTEST_OLD_STD
+#           define _CXXTEST_OLD_STD
+#       endif
+#       ifndef _CXXTEST_OLD_TEMPLATE_SYNTAX
+#           define _CXXTEST_OLD_TEMPLATE_SYNTAX
+#       endif
+#   endif
+#   if __BORLANDC__ >= 0x540 // C++ Builder 4.0 or later
+#       ifndef _CXXTEST_NO_COPY_CONST
+#           define _CXXTEST_NO_COPY_CONST
+#       endif
+#       ifndef _CXXTEST_LONGLONG
+#           define _CXXTEST_LONGLONG __int64
+#       endif
+#   endif
+#endif // __BORLANDC__
+
+#ifdef _MSC_VER // Visual C++
+#   ifndef _CXXTEST_LONGLONG
+#       define _CXXTEST_LONGLONG __int64
+#   endif
+#   if (_MSC_VER >= 0x51E)
+#       ifndef _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION
+#           define _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION
+#       endif
+#   endif
+#   pragma warning( disable : 4127 )
+#   pragma warning( disable : 4290 )
+#   pragma warning( disable : 4511 )
+#   pragma warning( disable : 4512 )
+#   pragma warning( disable : 4514 )
+#endif // _MSC_VER
+
+#ifdef __GNUC__
+#   if (__GNUC__ > 2) || (__GNUC__ == 2 && __GNUC_MINOR__ >= 9)
+#       ifndef _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION
+#           define _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION
+#       endif
+#   endif
+#endif // __GNUC__
+
+#ifdef __DMC__ // Digital Mars
+#   ifndef _CXXTEST_OLD_STD
+#       define _CXXTEST_OLD_STD
+#   endif
+#endif
+
+#endif // __cxxtest__Flags_h__
diff --git a/cxxtest/GlobalFixture.cpp b/cxxtest/GlobalFixture.cpp
new file mode 100644
index 0000000..29c6ab8
--- /dev/null
+++ b/cxxtest/GlobalFixture.cpp
@@ -0,0 +1,23 @@
+#ifndef __cxxtest__GlobalFixture_cpp__
+#define __cxxtest__GlobalFixture_cpp__
+
+#include <cxxtest/GlobalFixture.h>
+
+namespace CxxTest 
+{
+    bool GlobalFixture::setUpWorld() { return true; }
+    bool GlobalFixture::tearDownWorld() { return true; }
+    bool GlobalFixture::setUp() { return true; }
+    bool GlobalFixture::tearDown() { return true; }
+        
+    GlobalFixture::GlobalFixture() { attach( _list ); }
+    GlobalFixture::~GlobalFixture() { detach( _list ); }
+        
+    GlobalFixture *GlobalFixture::firstGlobalFixture() { return (GlobalFixture *)_list.head(); }
+    GlobalFixture *GlobalFixture::lastGlobalFixture() { return (GlobalFixture *)_list.tail(); }
+    GlobalFixture *GlobalFixture::nextGlobalFixture() { return (GlobalFixture *)next(); }
+    GlobalFixture *GlobalFixture::prevGlobalFixture() { return (GlobalFixture *)prev(); }
+}
+
+#endif // __cxxtest__GlobalFixture_cpp__
+
diff --git a/cxxtest/GlobalFixture.h b/cxxtest/GlobalFixture.h
new file mode 100644
index 0000000..c817363
--- /dev/null
+++ b/cxxtest/GlobalFixture.h
@@ -0,0 +1,30 @@
+#ifndef __cxxtest__GlobalFixture_h__
+#define __cxxtest__GlobalFixture_h__
+
+#include <cxxtest/LinkedList.h>
+
+namespace CxxTest 
+{
+    class GlobalFixture : public Link
+    {
+    public:
+        virtual bool setUpWorld();
+        virtual bool tearDownWorld();
+        virtual bool setUp();
+        virtual bool tearDown();
+        
+        GlobalFixture();
+        ~GlobalFixture();
+        
+        static GlobalFixture *firstGlobalFixture();
+        static GlobalFixture *lastGlobalFixture();
+        GlobalFixture *nextGlobalFixture();
+        GlobalFixture *prevGlobalFixture();
+
+    private:
+        static List _list;
+    };
+}
+
+#endif // __cxxtest__GlobalFixture_h__
+
diff --git a/cxxtest/Gui.h b/cxxtest/Gui.h
new file mode 100644
index 0000000..ac53b29
--- /dev/null
+++ b/cxxtest/Gui.h
@@ -0,0 +1,178 @@
+#ifndef __CXXTEST__GUI_H
+#define __CXXTEST__GUI_H
+
+//
+// GuiListener is a simple base class for the differes GUIs
+// GuiTuiRunner<GuiT, TuiT> combines a GUI with a text-mode error formatter
+//
+
+#include <cxxtest/TeeListener.h>
+
+namespace CxxTest
+{
+    class GuiListener : public TestListener
+    {
+    public:
+        GuiListener() : _state( GREEN_BAR ) {}
+        virtual ~GuiListener() {}
+
+        virtual void runGui( int &argc, char **argv, TestListener &listener )
+        {
+            enterGui( argc, argv );
+            TestRunner::runAllTests( listener );
+            leaveGui();            
+        }
+
+        virtual void enterGui( int & /*argc*/, char ** /*argv*/ ) {}
+        virtual void leaveGui() {}
+        
+        //
+        // The easy way is to implement these functions:
+        //      
+        virtual void guiEnterWorld( unsigned /*numTotalTests*/ ) {}
+        virtual void guiEnterSuite( const char * /*suiteName*/ ) {}
+        virtual void guiEnterTest( const char * /*suiteName*/, const char * /*testName*/ ) {}
+        virtual void yellowBar() {}
+        virtual void redBar() {}
+
+        //
+        // The hard way is this:
+        //
+        void enterWorld( const WorldDescription &d ) { guiEnterWorld( d.numTotalTests() ); }
+        void enterSuite( const SuiteDescription &d ) { guiEnterSuite( d.suiteName() ); }
+        void enterTest( const TestDescription &d ) { guiEnterTest( d.suiteName(), d.testName() ); }
+        void leaveTest( const TestDescription & ) {}
+        void leaveSuite( const SuiteDescription & ) {}
+        void leaveWorld( const WorldDescription & ) {}
+        
+        void warning( const char * /*file*/, unsigned /*line*/, const char * /*expression*/ )
+        {
+            yellowBarSafe();
+        }
+        
+        void failedTest( const char * /*file*/, unsigned /*line*/, const char * /*expression*/ )
+        {
+            redBarSafe();
+        }
+        
+        void failedAssert( const char * /*file*/, unsigned /*line*/, const char * /*expression*/ )
+        {
+            redBarSafe();
+        }
+        
+        void failedAssertEquals( const char * /*file*/, unsigned /*line*/,
+                                 const char * /*xStr*/, const char * /*yStr*/,
+                                 const char * /*x*/, const char * /*y*/ )
+        {
+            redBarSafe();
+        }
+
+        void failedAssertSameData( const char * /*file*/, unsigned /*line*/,
+                                   const char * /*xStr*/, const char * /*yStr*/,
+                                   const char * /*sizeStr*/, const void * /*x*/,
+                                   const void * /*y*/, unsigned /*size*/ )
+        {
+            redBarSafe();
+        }
+        
+        void failedAssertDelta( const char * /*file*/, unsigned /*line*/,
+                                const char * /*xStr*/, const char * /*yStr*/, const char * /*dStr*/,
+                                const char * /*x*/, const char * /*y*/, const char * /*d*/ )
+        {
+            redBarSafe();
+        }
+        
+        void failedAssertDiffers( const char * /*file*/, unsigned /*line*/,
+                                  const char * /*xStr*/, const char * /*yStr*/,
+                                  const char * /*value*/ )
+        {
+            redBarSafe();
+        }
+        
+        void failedAssertLessThan( const char * /*file*/, unsigned /*line*/,
+                                   const char * /*xStr*/, const char * /*yStr*/,
+                                   const char * /*x*/, const char * /*y*/ )
+        {
+            redBarSafe();
+        }
+        
+        void failedAssertLessThanEquals( const char * /*file*/, unsigned /*line*/,
+                                         const char * /*xStr*/, const char * /*yStr*/,
+                                         const char * /*x*/, const char * /*y*/ )
+        {
+            redBarSafe();
+        }
+        
+        void failedAssertPredicate( const char * /*file*/, unsigned /*line*/,
+                                    const char * /*predicate*/, const char * /*xStr*/, const char * /*x*/ )
+        {
+            redBarSafe();
+        }
+        
+        void failedAssertRelation( const char * /*file*/, unsigned /*line*/,
+                                   const char * /*relation*/, const char * /*xStr*/, const char * /*yStr*/,
+                                   const char * /*x*/, const char * /*y*/ )
+        {
+            redBarSafe();
+        }
+        
+        void failedAssertThrows( const char * /*file*/, unsigned /*line*/,
+                                 const char * /*expression*/, const char * /*type*/,
+                                 bool /*otherThrown*/ )
+        {
+            redBarSafe();
+        }
+        
+        void failedAssertThrowsNot( const char * /*file*/, unsigned /*line*/,
+                                    const char * /*expression*/ )
+        {
+            redBarSafe();
+        }
+
+    protected:
+        void yellowBarSafe()
+        {
+            if ( _state < YELLOW_BAR ) {
+                yellowBar();
+                _state = YELLOW_BAR;
+            }
+        }
+
+        void redBarSafe()
+        {
+            if ( _state < RED_BAR ) {
+                redBar();
+                _state = RED_BAR;
+            }
+        }
+        
+    private:
+        enum { GREEN_BAR, YELLOW_BAR, RED_BAR } _state;
+    };
+
+    template<class GuiT, class TuiT>
+    class GuiTuiRunner : public TeeListener
+    {
+        int &_argc;
+        char **_argv;
+        GuiT _gui;
+        TuiT _tui;
+        
+    public:
+        GuiTuiRunner( int &argc, char **argv ) :
+            _argc( argc ),
+            _argv( argv )
+        {  
+            setFirst( _gui );
+            setSecond( _tui );
+        }
+
+        int run()
+        {
+            _gui.runGui( _argc, _argv, *this );
+            return tracker().failedTests();
+        }
+    };
+};
+
+#endif //__CXXTEST__GUI_H
diff --git a/cxxtest/LinkedList.cpp b/cxxtest/LinkedList.cpp
new file mode 100644
index 0000000..fb81d64
--- /dev/null
+++ b/cxxtest/LinkedList.cpp
@@ -0,0 +1,172 @@
+#ifndef __cxxtest__LinkedList_cpp__
+#define __cxxtest__LinkedList_cpp__
+
+#include <cxxtest/LinkedList.h>
+
+namespace CxxTest
+{
+    List GlobalFixture::_list = { 0, 0 };
+    List RealSuiteDescription::_suites = { 0, 0 };
+
+    void List::initialize()
+    {
+        _head = _tail = 0;
+    }
+    
+    Link *List::head()
+    {
+        Link *l = _head;
+        while ( l && !l->active() )
+            l = l->next();
+        return l;
+    }
+
+    const Link *List::head() const
+    {
+        Link *l = _head;
+        while ( l && !l->active() )
+            l = l->next();
+        return l;
+    }
+
+    Link *List::tail()
+    {
+        Link *l = _tail;
+        while ( l && !l->active() )
+            l = l->prev();
+        return l;
+    }
+
+    const Link *List::tail() const
+    {
+        Link *l = _tail;
+        while ( l && !l->active() )
+            l = l->prev();
+        return l;
+    }
+
+    bool List::empty() const
+    {
+        return (_head == 0);
+    }
+
+    unsigned List::size() const
+    {
+        unsigned count = 0;
+        for ( const Link *l = head(); l != 0; l = l->next() )
+            ++ count;
+        return count;
+    }
+
+    Link *List::nth( unsigned n )
+    {
+        Link *l = head();
+        while ( n -- )
+            l = l->next();
+        return l;
+    }
+
+    void List::activateAll()
+    {
+        for ( Link *l = _head; l != 0; l = l->justNext() )
+            l->setActive( true );
+    }
+
+    void List::leaveOnly( const Link &link )
+    {
+        for ( Link *l = head(); l != 0; l = l->next() )
+            if ( l != &link )
+                l->setActive( false );
+    }
+
+    Link::Link() :
+        _next( 0 ),
+        _prev( 0 ),
+        _active( true )
+    {
+    }
+
+    Link::~Link()
+    {
+    }
+    
+    bool Link::active() const
+    {
+        return _active;
+    }
+    
+    void Link::setActive( bool value )
+    {
+        _active = value;
+    }
+
+    Link * Link::justNext()
+    {
+        return _next;
+    }
+    
+    Link * Link::justPrev()
+    {
+        return _prev;
+    }
+        
+    Link * Link::next()
+    {
+        Link *l = _next;
+        while ( l && !l->_active )
+            l = l->_next;
+        return l;
+    }
+    
+    Link * Link::prev()
+    {
+        Link *l = _prev;
+        while ( l && !l->_active )
+            l = l->_prev;
+        return l;
+    }
+    
+    const Link * Link::next() const
+    {
+        Link *l = _next;
+        while ( l && !l->_active )
+            l = l->_next;
+        return l;
+    }
+    
+    const Link * Link::prev() const
+    {
+        Link *l = _prev;
+        while ( l && !l->_active )
+            l = l->_prev;
+        return l;
+    }
+    
+    void Link::attach( List &l )
+    {
+        if ( l._tail )
+            l._tail->_next = this;
+
+        _prev = l._tail;
+        _next = 0;
+            
+        if ( l._head == 0 )
+            l._head = this;
+        l._tail = this;
+    }
+
+    void Link::detach( List &l )
+    {
+        if ( _prev )
+            _prev->_next = _next;
+        else
+            l._head = _next;
+            
+        if ( _next )
+            _next->_prev = _prev;
+        else
+            l._tail = _prev;
+    }
+};
+
+#endif // __cxxtest__LinkedList_cpp__
diff --git a/cxxtest/LinkedList.h b/cxxtest/LinkedList.h
new file mode 100644
index 0000000..983a6e2
--- /dev/null
+++ b/cxxtest/LinkedList.h
@@ -0,0 +1,65 @@
+#ifndef __cxxtest__LinkedList_h__
+#define __cxxtest__LinkedList_h__
+
+#include <cxxtest/Flags.h>
+
+namespace CxxTest 
+{
+    struct List;
+    class Link;
+
+    struct List
+    {
+        Link *_head;
+        Link *_tail;
+
+        void initialize();
+
+        Link *head();
+        const Link *head() const;
+        Link *tail();
+        const Link *tail() const;
+
+        bool empty() const;
+        unsigned size() const;
+        Link *nth( unsigned n );
+
+        void activateAll();
+        void leaveOnly( const Link &link );
+    };
+
+    class Link
+    {       
+    public:
+        Link();
+        virtual ~Link();
+
+        bool active() const;
+        void setActive( bool value = true );
+
+        Link *justNext();
+        Link *justPrev();
+        
+        Link *next();
+        Link *prev();
+        const Link *next() const;
+        const Link *prev() const;
+
+        virtual bool setUp() = 0;
+        virtual bool tearDown() = 0;
+
+        void attach( List &l );
+        void detach( List &l );
+
+    private:
+        Link *_next;
+        Link *_prev;
+        bool _active;
+
+        Link( const Link & );
+        Link &operator=( const Link & );
+    };
+}
+
+#endif // __cxxtest__LinkedList_h__
+
diff --git a/cxxtest/Mock.h b/cxxtest/Mock.h
new file mode 100644
index 0000000..647088e
--- /dev/null
+++ b/cxxtest/Mock.h
@@ -0,0 +1,350 @@
+#ifndef __cxxtest__Mock_h__
+#define __cxxtest__Mock_h__
+
+//
+// The default namespace is T::
+//
+#ifndef CXXTEST_MOCK_NAMESPACE
+#   define CXXTEST_MOCK_NAMESPACE T
+#endif // CXXTEST_MOCK_NAMESPACE
+
+//
+// MockTraits: What to return when no mock object has been created
+//
+#define __CXXTEST_MOCK__TRAITS \
+    namespace CXXTEST_MOCK_NAMESPACE \
+    { \
+        template<class T> \
+        class MockTraits \
+        { \
+        public: \
+            static T defaultValue() { return 0; } \
+        }; \
+    };
+
+//
+// extern "C" when needed
+//
+#ifdef __cplusplus
+#   define CXXTEST_EXTERN_C extern "C"
+#else
+#   define CXXTEST_EXTERN_C
+#endif // __cplusplus
+
+//
+// Prototypes: For "normal" headers
+//
+#define __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    namespace CXXTEST_MOCK_NAMESPACE { TYPE NAME ARGS; }
+
+#define __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__PROTOTYPE( MOCK, void, NAME, ARGS, REAL, CALL )
+
+#define __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    TYPE REAL ARGS;
+
+#define __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY__PROTOTYPE( MOCK, void, NAME, ARGS, REAL, CALL )
+
+//
+// Class declarations: For test files
+//
+#define __CXXTEST_MOCK__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    namespace CXXTEST_MOCK_NAMESPACE { \
+        class Base_##MOCK : public CxxTest::Link \
+        { \
+        public: \
+            Base_##MOCK(); \
+            ~Base_##MOCK(); \
+            bool setUp(); \
+            bool tearDown(); \
+         \
+            static Base_##MOCK &current(); \
+         \
+            virtual TYPE NAME ARGS = 0; \
+         \
+        private: \
+            static CxxTest::List _list; \
+        }; \
+         \
+        class Real_##MOCK  : public Base_##MOCK \
+        { \
+        public: \
+            TYPE NAME ARGS; \
+        }; \
+         \
+        class _Unimplemented_##MOCK  : public Base_##MOCK \
+        { \
+        public: \
+            TYPE NAME ARGS; \
+        }; \
+    }
+
+#define __CXXTEST_MOCK_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__CLASS_DECLARATION( MOCK, void, NAME, ARGS, REAL, CALL )
+
+#define __CXXTEST_SUPPLY__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    namespace CXXTEST_MOCK_NAMESPACE { \
+        class Base_##MOCK : public CxxTest::Link \
+        { \
+        public: \
+            Base_##MOCK(); \
+            ~Base_##MOCK(); \
+            bool setUp(); \
+            bool tearDown(); \
+         \
+            static Base_##MOCK &current(); \
+         \
+            virtual TYPE NAME ARGS = 0; \
+         \
+        private: \
+            static CxxTest::List _list; \
+        }; \
+         \
+        class _Unimplemented_##MOCK  : public Base_##MOCK \
+        { \
+        public: \
+            TYPE NAME ARGS; \
+        }; \
+    }
+
+#define __CXXTEST_SUPPLY_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY__CLASS_DECLARATION( MOCK, void, NAME, ARGS, REAL, CALL )
+
+//
+// Class implementation: For test source files
+//
+#define __CXXTEST_MOCK__COMMON_CLASS_IMPLEMENTATION( MOCK, NAME ) \
+    namespace CXXTEST_MOCK_NAMESPACE { \
+         \
+        CxxTest::List Base_##MOCK::_list = { 0, 0 }; \
+         \
+        Base_##MOCK::Base_##MOCK() { attach( _list ); } \
+        Base_##MOCK::~Base_##MOCK() { detach( _list ); } \
+        bool Base_##MOCK::setUp() { return true; } \
+        bool Base_##MOCK::tearDown() { return true; } \
+         \
+        Base_##MOCK &Base_##MOCK::current() \
+        { \
+            if ( _list.empty() ) \
+                static _Unimplemented_##MOCK unimplemented; \
+            return *(Base_##MOCK *)_list.tail(); \
+        } \
+    }
+
+#define __CXXTEST_MOCK__CLASS_IMPLEMENTATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__COMMON_CLASS_IMPLEMENTATION( MOCK, NAME ) \
+    namespace CXXTEST_MOCK_NAMESPACE { \
+        TYPE Real_##MOCK::NAME ARGS \
+        { \
+            return REAL CALL; \
+        } \
+         \
+        TYPE _Unimplemented_##MOCK::NAME ARGS \
+        { \
+            while ( false ) \
+                return NAME CALL; \
+            __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS ); \
+            return MockTraits<TYPE>::defaultValue(); \
+        } \
+         \
+        TYPE NAME ARGS \
+        { \
+            return Base_##MOCK::current().NAME CALL; \
+        } \
+    }
+
+#define __CXXTEST_MOCK_VOID__CLASS_IMPLEMENTATION( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__COMMON_CLASS_IMPLEMENTATION( MOCK, NAME ) \
+    namespace CXXTEST_MOCK_NAMESPACE { \
+        void Real_##MOCK::NAME ARGS \
+        { \
+            REAL CALL; \
+        } \
+         \
+        void _Unimplemented_##MOCK::NAME ARGS \
+        { \
+            while ( false ) \
+                NAME CALL; \
+            __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS ); \
+        } \
+         \
+        void NAME ARGS \
+        { \
+            Base_##MOCK::current().NAME CALL; \
+        } \
+    }
+
+#define __CXXTEST_SUPPLY__CLASS_IMPLEMENTATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__COMMON_CLASS_IMPLEMENTATION( MOCK, NAME ) \
+    namespace CXXTEST_MOCK_NAMESPACE { \
+        TYPE _Unimplemented_##MOCK::NAME ARGS \
+        { \
+            while ( false ) \
+                return NAME CALL; \
+            __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS ); \
+            return MockTraits<TYPE>::defaultValue(); \
+        } \
+    } \
+     \
+    TYPE REAL ARGS \
+    { \
+        return CXXTEST_MOCK_NAMESPACE::Base_##MOCK::current().NAME CALL; \
+    }
+
+#define __CXXTEST_SUPPLY_VOID__CLASS_IMPLEMENTATION( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__COMMON_CLASS_IMPLEMENTATION( MOCK, NAME ) \
+    namespace CXXTEST_MOCK_NAMESPACE { \
+        void _Unimplemented_##MOCK::NAME ARGS \
+        { \
+            while ( false ) \
+                NAME CALL; \
+            __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS ); \
+        } \
+    } \
+     \
+    void REAL ARGS \
+    { \
+        CXXTEST_MOCK_NAMESPACE::Base_##MOCK::current().NAME CALL; \
+    } \
+
+//
+// Error for calling mock function w/o object
+//
+#define __CXXTEST_MOCK_UNIMPLEMENTED( NAME, ARGS ) \
+    TS_FAIL( CXXTEST_MOCK_NAMESPACE_STR #NAME #ARGS " called with no " \
+             CXXTEST_MOCK_NAMESPACE_STR "Base_" #NAME " object" ); \
+
+#define CXXTEST_MOCK_NAMESPACE_STR __CXXTEST_STR(CXXTEST_MOCK_NAMESPACE) "::"
+#define __CXXTEST_STR(X) __CXXTEST_XSTR(X)
+#define __CXXTEST_XSTR(X) #X
+
+#if defined(CXXTEST_MOCK_TEST_SOURCE_FILE)
+//
+// Test source file: Prototypes, class declarations and implementation
+//
+#include <cxxtest/TestSuite.h>
+
+__CXXTEST_MOCK__TRAITS;
+
+#define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__CLASS_IMPLEMENTATION( MOCK, TYPE, NAME, ARGS, REAL, CALL )
+
+#define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK_VOID__CLASS_IMPLEMENTATION( MOCK, NAME, ARGS, REAL, CALL )
+
+#define CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY__CLASS_IMPLEMENTATION( MOCK, TYPE, NAME, ARGS, REAL, CALL )
+
+#define CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY_VOID__CLASS_IMPLEMENTATION( MOCK, NAME, ARGS, REAL, CALL )
+
+#elif defined(CXXTEST_FLAGS) || defined(CXXTEST_RUNNING)
+//
+// Test file other than source: Prototypes and class declarations
+//
+#include <cxxtest/TestSuite.h>
+
+__CXXTEST_MOCK__TRAITS;
+
+#define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL )
+
+#define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL )
+
+#define CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY__CLASS_DECLARATION( MOCK, TYPE, NAME, ARGS, REAL, CALL )
+
+#define CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY_VOID__CLASS_DECLARATION( MOCK, NAME, ARGS, REAL, CALL )
+
+#elif defined(CXXTEST_MOCK_REAL_SOURCE_FILE)
+//
+// Real source file: "Real" implementations
+//
+#define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    namespace CXXTEST_MOCK_NAMESPACE { TYPE NAME ARGS { return REAL CALL; } }
+
+#define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL ) \
+    namespace CXXTEST_MOCK_NAMESPACE { void NAME ARGS { REAL CALL; } }
+
+#else
+//
+// Ordinary header file: Just prototypes
+//
+
+#define CXXTEST_MOCK( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL )
+
+#define CXXTEST_MOCK_VOID( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_MOCK_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL )
+
+#define CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL )
+
+#define CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL ) \
+    __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL )
+
+#endif // Ordinary header file
+
+//
+// How to supply extern "C" functions
+//
+#define CXXTEST_SUPPLY_C( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    CXXTEST_EXTERN_C __CXXTEST_SUPPLY__PROTOTYPE( MOCK, TYPE, NAME, ARGS, REAL, CALL ) \
+    CXXTEST_SUPPLY( MOCK, TYPE, NAME, ARGS, REAL, CALL )
+
+#define CXXTEST_SUPPLY_VOID_C( MOCK, NAME, ARGS, REAL, CALL ) \
+    CXXTEST_EXTERN_C __CXXTEST_SUPPLY_VOID__PROTOTYPE( MOCK, NAME, ARGS, REAL, CALL ) \
+    CXXTEST_SUPPLY_VOID( MOCK, NAME, ARGS, REAL, CALL )
+
+//
+// Usually we mean the global namespace
+//
+#define CXXTEST_MOCK_GLOBAL( TYPE, NAME, ARGS, CALL ) \
+    CXXTEST_MOCK( NAME, TYPE, NAME, ARGS, ::NAME, CALL )
+
+#define CXXTEST_MOCK_VOID_GLOBAL( NAME, ARGS, CALL ) \
+    CXXTEST_MOCK_VOID( NAME, NAME, ARGS, ::NAME, CALL )
+
+#define CXXTEST_SUPPLY_GLOBAL( TYPE, NAME, ARGS, CALL ) \
+    CXXTEST_SUPPLY( NAME, TYPE, NAME, ARGS, NAME, CALL )
+
+#define CXXTEST_SUPPLY_VOID_GLOBAL( NAME, ARGS, CALL ) \
+    CXXTEST_SUPPLY_VOID( NAME, NAME, ARGS, NAME, CALL )
+
+#define CXXTEST_SUPPLY_GLOBAL_C( TYPE, NAME, ARGS, CALL ) \
+    CXXTEST_SUPPLY_C( NAME, TYPE, NAME, ARGS, NAME, CALL )
+
+#define CXXTEST_SUPPLY_VOID_GLOBAL_C( NAME, ARGS, CALL ) \
+    CXXTEST_SUPPLY_VOID_C( NAME, NAME, ARGS, NAME, CALL )
+
+//
+// What to return when no mock object has been created.
+// The default value of 0 usually works, but some cases may need this.
+//
+#define CXXTEST_MOCK_DEFAULT_VALUE( TYPE, VALUE ) \
+    namespace CXXTEST_MOCK_NAMESPACE \
+    { \
+        template<> \
+        class MockTraits<TYPE> \
+        { \
+        public: \
+            static TYPE defaultValue() { return VALUE; } \
+        }; \
+    }
+
+#endif // __cxxtest__Mock_h__
diff --git a/cxxtest/ParenPrinter.h b/cxxtest/ParenPrinter.h
new file mode 100644
index 0000000..9ecf310
--- /dev/null
+++ b/cxxtest/ParenPrinter.h
@@ -0,0 +1,21 @@
+#ifndef __cxxtest__ParenPrinter_h__
+#define __cxxtest__ParenPrinter_h__
+
+//
+// The ParenPrinter is identical to the ErrorPrinter, except it
+// prints the line number in a format expected by some compilers
+// (notably, MSVC).
+//
+
+#include <cxxtest/ErrorPrinter.h>
+
+namespace CxxTest 
+{
+    class ParenPrinter : public ErrorPrinter
+    {
+    public:
+        ParenPrinter( CXXTEST_STD(ostream) &o = CXXTEST_STD(cout) ) : ErrorPrinter( o, "(", ")" ) {}
+    };
+}
+
+#endif // __cxxtest__ParenPrinter_h__
diff --git a/cxxtest/QtGui.h b/cxxtest/QtGui.h
new file mode 100644
index 0000000..8898251
--- /dev/null
+++ b/cxxtest/QtGui.h
@@ -0,0 +1,271 @@
+#ifndef __cxxtest__QtGui_h__
+#define __cxxtest__QtGui_h__
+
+//
+// The QtGui displays a simple progress bar using the Qt Toolkit.  It
+// has been tested with versions 2.x and 3.x.
+// 
+// Apart from normal Qt command-line arguments, it accepts the following options:
+//   -minimized    Start minimized, pop up on error
+//   -keep         Don't close the window at the end
+//   -title TITLE  Set the window caption
+//
+// If both are -minimized and -keep specified, GUI will only keep the
+// window if it's in focus.
+//
+
+#include <cxxtest/Gui.h>
+
+#include <qapplication.h>
+#include <qglobal.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qmessagebox.h>
+#include <qpixmap.h>
+#include <qprogressbar.h>
+#include <qstatusbar.h>
+
+namespace CxxTest
+{
+    class QtGui : public GuiListener
+    {
+    public:
+        void enterGui( int &argc, char **argv )
+        {
+            parseCommandLine( argc, argv );
+            createApplication( argc, argv );
+        }
+
+        void enterWorld( const WorldDescription &wd )
+        {
+            createWindow( wd );
+            processEvents();
+        }
+
+        void guiEnterSuite( const char *suiteName )
+        {
+            showSuiteName( suiteName );
+        }
+
+        void guiEnterTest( const char *suiteName, const char *testName )
+        {
+            setCaption( suiteName, testName );
+            advanceProgressBar();
+            showTestName( testName );
+            showTestsDone( _progressBar->progress() );
+            processEvents();
+        }
+
+        void yellowBar()
+        {
+            setColor( 255, 255, 0 );
+            setIcon( QMessageBox::Warning );
+            getTotalTests();
+            processEvents();
+        }
+        
+        void redBar()
+        {
+            if ( _startMinimized && _mainWindow->isMinimized() )
+                showNormal();
+            setColor( 255, 0, 0 );
+            setIcon( QMessageBox::Critical );
+            getTotalTests();
+            processEvents();
+        }
+
+        void leaveGui()
+        {
+            if ( keep() ) {
+                showSummary();
+                _application->exec();
+            }
+            else
+                _mainWindow->close( true );
+        }
+
+    private:
+        QString _title;
+        bool _startMinimized, _keep;
+        unsigned _numTotalTests;
+        QString _strTotalTests;
+        QApplication *_application;
+        QWidget *_mainWindow;
+        QVBoxLayout *_layout;
+        QProgressBar *_progressBar;
+        QStatusBar *_statusBar;
+        QLabel *_suiteName, *_testName, *_testsDone;
+
+        void parseCommandLine( int argc, char **argv )
+        {
+            _startMinimized = _keep = false;
+            _title = argv[0];
+            
+            for ( int i = 1; i < argc; ++ i ) {
+                QString arg( argv[i] );
+                if ( arg == "-minimized" )
+                    _startMinimized = true;
+                else if ( arg == "-keep" )
+                    _keep = true;
+                else if ( arg == "-title" && (i + 1 < argc) )
+                    _title = argv[++i];
+            }
+        }
+
+        void createApplication( int &argc, char **argv )
+        {
+            _application = new QApplication( argc, argv );
+        }       
+        
+        void createWindow( const WorldDescription &wd )
+        {
+            getTotalTests( wd );            
+            createMainWindow();
+            createProgressBar();
+            createStatusBar();
+            setMainWidget();
+            if ( _startMinimized )
+                showMinimized();
+            else
+                showNormal();
+        }
+
+        void getTotalTests()
+        {
+            getTotalTests( tracker().world() );
+        }
+
+        void getTotalTests( const WorldDescription &wd )
+        {
+            _numTotalTests = wd.numTotalTests();
+            char s[WorldDescription::MAX_STRLEN_TOTAL_TESTS];
+            _strTotalTests = wd.strTotalTests( s );
+        }
+
+        void createMainWindow()
+        {
+            _mainWindow = new QWidget();
+            _layout = new QVBoxLayout( _mainWindow );
+        }
+
+        void createProgressBar()
+        {
+            _layout->addWidget( _progressBar = new QProgressBar( _numTotalTests, _mainWindow ) );
+            _progressBar->setProgress( 0 );
+            setColor( 0, 255, 0 );
+            setIcon( QMessageBox::Information );
+        }
+
+        void createStatusBar()
+        {
+            _layout->addWidget( _statusBar = new QStatusBar( _mainWindow ) );
+            _statusBar->addWidget( _suiteName = new QLabel( _statusBar ), 2 );
+            _statusBar->addWidget( _testName = new QLabel( _statusBar ), 4 );
+            _statusBar->addWidget( _testsDone = new QLabel( _statusBar ), 1 );
+        }
+
+        void setMainWidget()
+        {
+            _application->setMainWidget( _mainWindow );
+        }
+
+        void showMinimized()
+        {
+            _mainWindow->showMinimized();
+        }
+
+        void showNormal()
+        {
+            _mainWindow->showNormal();
+            centerWindow();
+        }
+
+        void setCaption( const QString &suiteName, const QString &testName )
+        {
+            _mainWindow->setCaption( _title + " - " + suiteName + "::" + testName + "()" );
+        }
+
+        void showSuiteName( const QString &suiteName )
+        {
+            _suiteName->setText( "class " + suiteName );
+        }
+
+        void advanceProgressBar()
+        {
+            _progressBar->setProgress( _progressBar->progress() + 1 );
+        }
+
+        void showTestName( const QString &testName )
+        {
+            _testName->setText( testName + "()" );
+        }
+
+        void showTestsDone( unsigned testsDone )
+        {
+            _testsDone->setText( asString( testsDone ) + " of " + _strTotalTests );
+        }
+
+        static QString asString( unsigned n )
+        {
+            return QString::number( n );
+        }
+
+        void setColor( int r, int g, int b )
+        {
+            QPalette palette = _progressBar->palette();
+            palette.setColor( QColorGroup::Highlight, QColor( r, g, b ) );
+            _progressBar->setPalette( palette );
+        }
+
+        void setIcon( QMessageBox::Icon icon )
+        {
+#if QT_VERSION >= 0x030000
+            _mainWindow->setIcon( QMessageBox::standardIcon( icon ) );
+#else // Qt version < 3.0.0
+            _mainWindow->setIcon( QMessageBox::standardIcon( icon, QApplication::style().guiStyle() ) );
+#endif // QT_VERSION
+        }
+
+        void processEvents()
+        {
+            _application->processEvents();
+        }
+
+        void centerWindow()
+        {
+            QWidget *desktop = QApplication::desktop();
+            int xCenter = desktop->x() + (desktop->width() / 2);
+            int yCenter = desktop->y() + (desktop->height() / 2);
+            
+            int windowWidth = (desktop->width() * 4) / 5;
+            int windowHeight = _mainWindow->height();
+            _mainWindow->setGeometry( xCenter - (windowWidth / 2), yCenter - (windowHeight / 2), windowWidth, windowHeight );
+        }
+
+        bool keep()
+        {
+            if ( !_keep )
+                return false;
+            if ( !_startMinimized )
+                return true;
+            return (_mainWindow == _application->activeWindow());
+        }
+
+        void showSummary()
+        {
+            QString summary = _strTotalTests + (_numTotalTests == 1 ? " test" : " tests");
+            if ( tracker().failedTests() )
+                summary = "Failed " + asString( tracker().failedTests() ) + " of " + summary;
+            else
+                summary = summary + " passed";
+
+            _mainWindow->setCaption( _title + " - " + summary );
+
+            _statusBar->removeWidget( _suiteName );
+            _statusBar->removeWidget( _testName );
+            _testsDone->setText( summary );
+        }
+    };
+};
+
+#endif // __cxxtest__QtGui_h__
diff --git a/cxxtest/RealDescriptions.cpp b/cxxtest/RealDescriptions.cpp
new file mode 100644
index 0000000..1e21ca7
--- /dev/null
+++ b/cxxtest/RealDescriptions.cpp
@@ -0,0 +1,311 @@
+#ifndef __cxxtest__RealDescriptions_cpp__
+#define __cxxtest__RealDescriptions_cpp__
+
+//
+// NOTE: If an error occur during world construction/deletion, CxxTest cannot
+//       know where the error originated.
+//
+
+#include <cxxtest/RealDescriptions.h>
+
+namespace CxxTest 
+{
+    RealTestDescription::RealTestDescription()
+    {
+    }
+        
+    RealTestDescription::RealTestDescription( List &argList,
+                                              SuiteDescription &argSuite,
+                                              unsigned argLine,
+                                              const char *argTestName )
+    {
+        initialize( argList, argSuite, argLine, argTestName );
+    }
+
+    void RealTestDescription::initialize( List &argList,
+                                          SuiteDescription &argSuite,
+                                          unsigned argLine,
+                                          const char *argTestName )
+    {
+        _suite = &argSuite;
+        _line = argLine;
+        _testName = argTestName;
+        attach( argList );
+    }
+        
+    bool RealTestDescription::setUp()
+    {
+        if ( !suite() )
+            return false;
+
+        for ( GlobalFixture *gf = GlobalFixture::firstGlobalFixture(); gf != 0; gf = gf->nextGlobalFixture() ) {
+            bool ok;
+            _TS_TRY { ok = gf->setUp(); }
+            _TS_LAST_CATCH( { ok = false; } );
+
+            if ( !ok ) {
+                doFailTest( file(), line(), "Error in GlobalFixture::setUp()" );
+                return false;
+            }
+        }
+
+        _TS_TRY {
+            _TSM_ASSERT_THROWS_NOTHING( file(), line(), "Exception thrown from setUp()", suite()->setUp() );
+        }
+        _TS_CATCH_ABORT( { return false; } );
+
+        return true;
+    }
+
+    bool RealTestDescription::tearDown()
+    {
+        if ( !suite() )
+            return false;
+
+        _TS_TRY {
+            _TSM_ASSERT_THROWS_NOTHING( file(), line(), "Exception thrown from tearDown()", suite()->tearDown() );
+        }
+        _TS_CATCH_ABORT( { return false; } );
+
+        for ( GlobalFixture *gf = GlobalFixture::lastGlobalFixture(); gf != 0; gf = gf->prevGlobalFixture() ) {
+            bool ok;
+            _TS_TRY { ok = gf->tearDown(); }
+            _TS_LAST_CATCH( { ok = false; } );
+
+            if ( !ok ) {
+                doFailTest( file(), line(), "Error in GlobalFixture::tearDown()" );
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    const char *RealTestDescription::file() const { return _suite->file(); }
+    unsigned RealTestDescription::line() const { return _line; }
+    const char *RealTestDescription::testName() const { return _testName; }
+    const char *RealTestDescription::suiteName() const { return _suite->suiteName(); }
+
+    TestDescription *RealTestDescription::next() { return (RealTestDescription *)Link::next(); }
+    const TestDescription *RealTestDescription::next() const { return (const RealTestDescription *)Link::next(); }
+
+    TestSuite *RealTestDescription::suite() const { return _suite->suite(); }
+
+    void RealTestDescription::run()
+    {
+        _TS_TRY { runTest(); }
+        _TS_CATCH_ABORT( {} )
+            ___TSM_CATCH( file(), line(), "Exception thrown from test" );
+    }
+        
+    RealSuiteDescription::RealSuiteDescription() {}
+    RealSuiteDescription::RealSuiteDescription( const char *argFile,
+                                                unsigned argLine,
+                                                const char *argSuiteName,
+                                                List &argTests )
+    {
+        initialize( argFile, argLine, argSuiteName, argTests );
+    }
+
+    void RealSuiteDescription::initialize( const char *argFile,
+                                           unsigned argLine,
+                                           const char *argSuiteName,
+                                           List &argTests )
+    {
+        _file = argFile;
+        _line = argLine;
+        _suiteName = argSuiteName;
+        _tests = &argTests;
+            
+        attach( _suites );
+    }
+
+    const char *RealSuiteDescription::file() const { return _file; }
+    unsigned RealSuiteDescription::line() const { return _line; }
+    const char *RealSuiteDescription::suiteName() const { return _suiteName; }
+
+    TestDescription *RealSuiteDescription::firstTest() { return (RealTestDescription *)_tests->head(); }
+    const TestDescription *RealSuiteDescription::firstTest() const { return (const RealTestDescription *)_tests->head(); }
+    SuiteDescription *RealSuiteDescription::next() { return (RealSuiteDescription *)Link::next(); }
+    const SuiteDescription *RealSuiteDescription::next() const { return (const RealSuiteDescription *)Link::next(); }
+        
+    unsigned RealSuiteDescription::numTests() const { return _tests->size(); }
+    
+    const TestDescription &RealSuiteDescription::testDescription( unsigned i ) const
+    {
+        return *(RealTestDescription *)_tests->nth( i );
+    }
+
+    void RealSuiteDescription::activateAllTests()
+    {
+        _tests->activateAll();
+    }
+        
+    bool RealSuiteDescription::leaveOnly( const char *testName )
+    {
+        for ( TestDescription *td = firstTest(); td != 0; td = td->next() ) {
+            if ( stringsEqual( td->testName(), testName ) ) {
+                _tests->leaveOnly( *td );
+                return true;
+            }
+        }
+        return false;        
+    }
+        
+    StaticSuiteDescription::StaticSuiteDescription() {}
+    StaticSuiteDescription::StaticSuiteDescription( const char *argFile, unsigned argLine,
+                                                    const char *argSuiteName, TestSuite &argSuite,
+                                                    List &argTests ) :
+        RealSuiteDescription( argFile, argLine, argSuiteName, argTests )
+    {
+        doInitialize( argSuite );
+    }
+
+    void StaticSuiteDescription::initialize( const char *argFile, unsigned argLine,
+                                             const char *argSuiteName, TestSuite &argSuite,
+                                             List &argTests )
+    {
+        RealSuiteDescription::initialize( argFile, argLine, argSuiteName, argTests );
+        doInitialize( argSuite );
+    }
+        
+    void StaticSuiteDescription::doInitialize( TestSuite &argSuite )
+    {
+        _suite = &argSuite;
+    }
+
+    TestSuite *StaticSuiteDescription::suite() const
+    {
+        return _suite;
+    }
+
+    bool StaticSuiteDescription::setUp() { return true; }
+    bool StaticSuiteDescription::tearDown() { return true; }
+
+    CommonDynamicSuiteDescription::CommonDynamicSuiteDescription() {}
+    CommonDynamicSuiteDescription::CommonDynamicSuiteDescription( const char *argFile, unsigned argLine,
+                                                                  const char *argSuiteName, List &argTests,
+                                                                  unsigned argCreateLine, unsigned argDestroyLine ) :
+        RealSuiteDescription( argFile, argLine, argSuiteName, argTests )
+    {
+        doInitialize( argCreateLine, argDestroyLine );
+    }
+
+    void CommonDynamicSuiteDescription::initialize( const char *argFile, unsigned argLine,
+                                                    const char *argSuiteName, List &argTests,
+                                                    unsigned argCreateLine, unsigned argDestroyLine )
+    {
+        RealSuiteDescription::initialize( argFile, argLine, argSuiteName, argTests );
+        doInitialize( argCreateLine, argDestroyLine );
+    }
+
+    void CommonDynamicSuiteDescription::doInitialize( unsigned argCreateLine, unsigned argDestroyLine )
+    {
+        _createLine = argCreateLine;
+        _destroyLine = argDestroyLine;
+    }
+        
+    List &RealWorldDescription::suites()
+    {
+        return RealSuiteDescription::_suites;
+    }
+        
+    unsigned RealWorldDescription::numSuites( void ) const
+    {
+        return suites().size();
+    }
+        
+    unsigned RealWorldDescription::numTotalTests( void ) const
+    {
+        unsigned count = 0;
+        for ( const SuiteDescription *sd = firstSuite(); sd != 0; sd = sd->next() )
+            count += sd->numTests();
+        return count;
+    }
+        
+    SuiteDescription *RealWorldDescription::firstSuite()
+    {
+        return (RealSuiteDescription *)suites().head();
+    }
+
+    const SuiteDescription *RealWorldDescription::firstSuite() const
+    {
+        return (const RealSuiteDescription *)suites().head();
+    }
+
+    const SuiteDescription &RealWorldDescription::suiteDescription( unsigned i ) const
+    {
+        return *(const RealSuiteDescription *)suites().nth( i );
+    }
+
+    void RealWorldDescription::activateAllTests()
+    {
+        suites().activateAll();
+        for ( SuiteDescription *sd = firstSuite(); sd != 0; sd = sd->next() )
+            sd->activateAllTests();
+    }
+
+    bool RealWorldDescription::leaveOnly( const char *suiteName, const char *testName )
+    {
+        for ( SuiteDescription *sd = firstSuite(); sd != 0; sd = sd->next() ) {
+            if ( stringsEqual( sd->suiteName(), suiteName ) ) {
+                if ( testName )
+                    if ( !sd->leaveOnly( testName ) )
+                        return false;
+                suites().leaveOnly( *sd );
+                return true;
+            }
+        }
+        return false;
+    }
+        
+    bool RealWorldDescription::setUp()
+    {
+        for ( GlobalFixture *gf = GlobalFixture::firstGlobalFixture(); gf != 0; gf = gf->nextGlobalFixture() ) {
+            bool ok;
+            _TS_TRY { ok = gf->setUpWorld(); }
+            _TS_LAST_CATCH( { ok = false; } );
+
+            if ( !ok ) {
+                reportError( "Error setting up world" );
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    bool RealWorldDescription::tearDown()
+    {
+        for ( GlobalFixture *gf = GlobalFixture::lastGlobalFixture(); gf != 0; gf = gf->prevGlobalFixture() ) {
+            bool ok;
+            _TS_TRY { ok = gf->tearDownWorld(); }
+            _TS_LAST_CATCH( { ok = false; } );
+
+            if ( !ok ) {
+                reportError( "Error tearing down world" );
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    void RealWorldDescription::reportError( const char *message )
+    {
+        doWarn( __FILE__, 5, message );
+    }
+
+    void activateAllTests()
+    {
+        RealWorldDescription().activateAllTests();
+    }
+
+    bool leaveOnly( const char *suiteName, const char *testName )
+    {
+        return RealWorldDescription().leaveOnly( suiteName, testName );
+    }
+}
+
+#endif // __cxxtest__RealDescriptions_cpp__
+
diff --git a/cxxtest/RealDescriptions.h b/cxxtest/RealDescriptions.h
new file mode 100644
index 0000000..14c457d
--- /dev/null
+++ b/cxxtest/RealDescriptions.h
@@ -0,0 +1,223 @@
+#ifndef __cxxtest__RealDescriptions_h__
+#define __cxxtest__RealDescriptions_h__
+
+//
+// The "real" description classes
+//
+
+#include <cxxtest/Descriptions.h>
+#include <cxxtest/TestSuite.h>
+#include <cxxtest/GlobalFixture.h>
+
+namespace CxxTest 
+{
+    class RealTestDescription : public TestDescription
+    {
+    public:
+        RealTestDescription();
+        RealTestDescription( List &argList, SuiteDescription &argSuite, unsigned argLine, const char *argTestName );
+        void initialize( List &argList, SuiteDescription &argSuite, unsigned argLine, const char *argTestName );
+        
+        const char *file() const;
+        unsigned line() const;
+        const char *testName() const;
+        const char *suiteName() const;
+
+        TestDescription *next();
+        const TestDescription *next() const;
+
+        TestSuite *suite() const;
+
+        bool setUp();
+        void run();        
+        bool tearDown();
+        
+    private:
+        RealTestDescription( const RealTestDescription & );
+        RealTestDescription &operator=( const RealTestDescription & );
+
+        virtual void runTest() = 0;
+        
+        SuiteDescription *_suite;
+        unsigned _line;
+        const char *_testName;
+    };
+
+    class RealSuiteDescription : public SuiteDescription
+    {
+    public:
+        RealSuiteDescription();
+        RealSuiteDescription( const char *argFile, unsigned argLine, const char *argSuiteName, List &argTests );
+        
+        void initialize( const char *argFile, unsigned argLine, const char *argSuiteName, List &argTests );
+
+        const char *file() const;
+        unsigned line() const;
+        const char *suiteName() const;
+
+        TestDescription *firstTest();
+        const TestDescription *firstTest() const;
+        SuiteDescription *next();
+        const SuiteDescription *next() const;
+        
+        unsigned numTests() const;
+        const TestDescription &testDescription( unsigned i ) const;
+
+        void activateAllTests();
+        bool leaveOnly( const char *testName );
+        
+    private:
+        RealSuiteDescription( const RealSuiteDescription & );
+        RealSuiteDescription &operator=( const RealSuiteDescription & );
+        
+        const char *_file;
+        unsigned _line;
+        const char *_suiteName;
+        List *_tests;
+
+        static List _suites;
+        friend class RealWorldDescription;
+    };
+
+    class StaticSuiteDescription : public RealSuiteDescription
+    {
+    public:
+        StaticSuiteDescription();
+        StaticSuiteDescription( const char *argFile, unsigned argLine,
+                                const char *argSuiteName, TestSuite &argSuite,
+                                List &argTests );
+
+        void initialize( const char *argFile, unsigned argLine,
+                         const char *argSuiteName, TestSuite &argSuite,
+                         List &argTests );
+        TestSuite *suite() const;
+        
+        bool setUp();
+        bool tearDown();
+        
+    private:
+        StaticSuiteDescription( const StaticSuiteDescription & );
+        StaticSuiteDescription &operator=( const StaticSuiteDescription & );
+
+        void doInitialize( TestSuite &argSuite );
+        
+        TestSuite *_suite;
+    };
+
+    class CommonDynamicSuiteDescription : public RealSuiteDescription
+    {
+    public:
+        CommonDynamicSuiteDescription();
+        CommonDynamicSuiteDescription( const char *argFile, unsigned argLine,
+                                       const char *argSuiteName, List &argTests,
+                                       unsigned argCreateLine, unsigned argDestroyLine );
+
+        void initialize( const char *argFile, unsigned argLine,
+                         const char *argSuiteName, List &argTests,
+                         unsigned argCreateLine, unsigned argDestroyLine );
+
+    protected:
+        unsigned _createLine, _destroyLine;
+
+    private:
+        void doInitialize( unsigned argCreateLine, unsigned argDestroyLine );
+    };
+    
+    template<class S>
+    class DynamicSuiteDescription : public CommonDynamicSuiteDescription
+    {
+    public:
+        DynamicSuiteDescription() {}
+        DynamicSuiteDescription( const char *argFile, unsigned argLine,
+                                 const char *argSuiteName, List &argTests,
+                                 S *&argSuite, unsigned argCreateLine,
+                                 unsigned argDestroyLine ) :
+            CommonDynamicSuiteDescription( argFile, argLine, argSuiteName, argTests, argCreateLine, argDestroyLine )
+        {
+            _suite = &argSuite;
+        }
+
+        void initialize( const char *argFile, unsigned argLine,
+                         const char *argSuiteName, List &argTests,
+                         S *&argSuite, unsigned argCreateLine,
+                         unsigned argDestroyLine )
+        {
+            CommonDynamicSuiteDescription::initialize( argFile, argLine,
+                                                       argSuiteName, argTests,
+                                                       argCreateLine, argDestroyLine );
+            _suite = &argSuite;
+        }
+
+        TestSuite *suite() const { return realSuite(); }
+
+        bool setUp();
+        bool tearDown();
+        
+    private:
+        S *realSuite() const { return *_suite; }
+        void setSuite( S *s ) { *_suite = s; }
+
+        void createSuite()
+        {
+            setSuite( S::createSuite() );
+        }
+        
+        void destroySuite()
+        {
+            S *s = realSuite();
+            setSuite( 0 );
+            S::destroySuite( s );
+        }
+
+        S **_suite;
+    };
+
+    template<class S>
+    bool DynamicSuiteDescription<S>::setUp()
+    {
+        _TS_TRY {
+            _TSM_ASSERT_THROWS_NOTHING( file(), _createLine, "Exception thrown from createSuite()", createSuite() );
+            _TSM_ASSERT( file(), _createLine, "createSuite() failed", suite() != 0 );
+        }
+        _TS_CATCH_ABORT( { return false; } );
+
+        return (suite() != 0);
+    }
+
+    template<class S>
+    bool DynamicSuiteDescription<S>::tearDown()
+    {
+        if ( !_suite )
+            return true;
+            
+        _TS_TRY {
+            _TSM_ASSERT_THROWS_NOTHING( file(), _destroyLine, "destroySuite() failed", destroySuite() );
+        }
+        _TS_CATCH_ABORT( { return false; } );
+
+        return true;
+    }
+        
+    class RealWorldDescription : public WorldDescription
+    {
+    public:
+        static List &suites();
+        unsigned numSuites( void ) const;
+        unsigned numTotalTests( void ) const;
+        SuiteDescription *firstSuite();
+        const SuiteDescription *firstSuite() const;
+        const SuiteDescription &suiteDescription( unsigned i ) const;
+        void activateAllTests();
+        bool leaveOnly( const char *suiteName, const char *testName = 0 );
+        
+        bool setUp();
+        bool tearDown();
+        static void reportError( const char *message );
+    };
+
+    void activateAllTests();
+    bool leaveOnly( const char *suiteName, const char *testName = 0 );
+}
+
+#endif // __cxxtest__RealDescriptions_h__
+
diff --git a/cxxtest/Root.cpp b/cxxtest/Root.cpp
new file mode 100644
index 0000000..c4320fd
--- /dev/null
+++ b/cxxtest/Root.cpp
@@ -0,0 +1,18 @@
+#ifndef __cxxtest__Root_cpp__
+#define __cxxtest__Root_cpp__
+
+//
+// This file holds the "root" of CxxTest, i.e.
+// the parts that must be in a source file file.
+//
+
+#include <cxxtest/Descriptions.cpp>
+#include <cxxtest/DummyDescriptions.cpp>
+#include <cxxtest/GlobalFixture.cpp>
+#include <cxxtest/LinkedList.cpp>
+#include <cxxtest/RealDescriptions.cpp>
+#include <cxxtest/TestSuite.cpp>
+#include <cxxtest/TestTracker.cpp>
+#include <cxxtest/ValueTraits.cpp>
+
+#endif // __cxxtest__Root_cpp__
diff --git a/cxxtest/SelfTest.h b/cxxtest/SelfTest.h
new file mode 100644
index 0000000..6d6b96e
--- /dev/null
+++ b/cxxtest/SelfTest.h
@@ -0,0 +1,7 @@
+#ifndef __cxxtest_SelfTest_h__
+#define __cxxtest_SelfTest_h__
+
+#define CXXTEST_SUITE(name)
+#define CXXTEST_CODE(member)
+
+#endif // __cxxtest_SelfTest_h__
diff --git a/cxxtest/StdHeaders.h b/cxxtest/StdHeaders.h
new file mode 100644
index 0000000..7c80b76
--- /dev/null
+++ b/cxxtest/StdHeaders.h
@@ -0,0 +1,25 @@
+#ifndef __cxxtest_StdHeaders_h__
+#define __cxxtest_StdHeaders_h__
+
+//
+// This file basically #includes the STL headers.
+// It exists to support warning level 4 in Visual C++
+//
+
+#ifdef _MSC_VER
+#   pragma warning( push, 1 )
+#endif // _MSC_VER
+
+#include <complex>
+#include <deque>
+#include <list>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#ifdef _MSC_VER
+#   pragma warning( pop )
+#endif // _MSC_VER
+
+#endif // __cxxtest_StdHeaders_h__
diff --git a/cxxtest/StdValueTraits.h b/cxxtest/StdValueTraits.h
new file mode 100644
index 0000000..036796b
--- /dev/null
+++ b/cxxtest/StdValueTraits.h
@@ -0,0 +1,229 @@
+#ifndef __cxxtest_StdValueTraits_h__
+#define __cxxtest_StdValueTraits_h__
+
+//
+// This file defines ValueTraits for std:: stuff.
+// It is #included by <cxxtest/ValueTraits.h> if you
+// define CXXTEST_HAVE_STD
+//
+
+#include <cxxtest/ValueTraits.h>
+#include <cxxtest/StdHeaders.h>
+
+#ifdef _CXXTEST_OLD_STD
+#   define CXXTEST_STD(x) x
+#else // !_CXXTEST_OLD_STD
+#   define CXXTEST_STD(x) std::x
+#endif // _CXXTEST_OLD_STD
+
+#ifndef CXXTEST_USER_VALUE_TRAITS
+
+namespace CxxTest
+{
+    //
+    // NOTE: This should have been
+    // template<class Char, class Traits, class Allocator>
+    // class ValueTraits< std::basic_string<Char, Traits, Allocator> > {};
+    // But MSVC doesn't support it (yet).
+    //
+
+    //
+    // If we have std::string, we might as well use it
+    //
+    class StdTraitsBase
+    {
+    public:
+        StdTraitsBase &operator<<( const CXXTEST_STD(string) &s ) { _s += s; return *this; }
+        const char *asString() const { return _s.c_str(); }
+
+    private:
+        CXXTEST_STD(string) _s;
+    };
+    
+    //
+    // std::string
+    //
+    CXXTEST_TEMPLATE_INSTANTIATION
+    class ValueTraits<const CXXTEST_STD(string)> : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(string) &s )
+        {
+            *this << "\"";
+            for ( unsigned i = 0; i < s.length(); ++ i ) {
+                char c[sizeof("\\xXX")];
+                charToString( s[i], c );
+                *this << c;
+            }
+            *this << "\"";
+        }
+    };
+
+    CXXTEST_COPY_CONST_TRAITS( CXXTEST_STD(string) );
+
+#ifndef _CXXTEST_OLD_STD
+    //
+    // std::wstring
+    //
+    CXXTEST_TEMPLATE_INSTANTIATION
+    class ValueTraits<const CXXTEST_STD(basic_string<wchar_t>)> : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(basic_string<wchar_t>) &s )
+        {
+            *this << "L\"";
+            for ( unsigned i = 0; i < s.length(); ++ i ) {
+                char c[sizeof("\\x12345678")];
+                charToString( (unsigned long)s[i], c );
+                *this << c;
+            }
+            *this << "\"";
+        }
+    };
+
+    CXXTEST_COPY_CONST_TRAITS( CXXTEST_STD(basic_string<wchar_t>) );
+#endif // _CXXTEST_OLD_STD
+
+    //
+    // Convert a range defined by iterators to a string
+    // This is useful for almost all STL containers
+    //
+    template<class Stream, class Iterator>
+    void dumpRange( Stream &s, Iterator first, Iterator last )
+    {
+        s << "{ ";
+        while ( first != last ) {
+            s << TS_AS_STRING(*first);
+            ++ first;
+            s << ((first == last) ? " }" : ", ");
+        }
+    }
+
+#ifdef _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION
+    //
+    // std::pair
+    //
+    template<class First, class Second>
+    class ValueTraits< CXXTEST_STD(pair)<First, Second> > : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(pair)<First, Second> &p ) 
+        {
+            *this << "<" << TS_AS_STRING( p.first ) << ", " << TS_AS_STRING( p.second ) << ">";
+        }
+    };
+
+    //
+    // std::vector
+    //
+    template<class Element>
+    class ValueTraits< CXXTEST_STD(vector)<Element> > : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(vector)<Element> &v )
+        {
+            dumpRange( *this, v.begin(), v.end() );
+        }
+    };
+
+    //
+    // std::list
+    //
+    template<class Element>
+    class ValueTraits< CXXTEST_STD(list)<Element> > : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(list)<Element> &l )
+        {
+            dumpRange( *this, l.begin(), l.end() );
+        }
+    };
+
+    //
+    // std::set
+    //
+    template<class Element>
+    class ValueTraits< CXXTEST_STD(set)<Element> > : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(set)<Element> &s )
+        {
+            dumpRange( *this, s.begin(), s.end() );
+        }
+    };
+
+    //
+    // std::map
+    //
+    template<class Key, class Value>
+    class ValueTraits< CXXTEST_STD(map)<Key, Value> > : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(map)<Key, Value> &m )
+        {
+            dumpRange( *this, m.begin(), m.end() );
+        }
+    };    
+
+    //
+    // std::deque
+    //
+    template<class Element>
+    class ValueTraits< CXXTEST_STD(deque)<Element> > : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(deque)<Element> &d )
+        {
+            dumpRange( *this, d.begin(), d.end() );
+        }
+    };
+
+    //
+    // std::multiset
+    //
+    template<class Element>
+    class ValueTraits< CXXTEST_STD(multiset)<Element> > : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(multiset)<Element> &ms )
+        {
+            dumpRange( *this, ms.begin(), ms.end() );
+        }
+    };
+
+    //
+    // std::multimap
+    //
+    template<class Key, class Value>
+    class ValueTraits< CXXTEST_STD(multimap)<Key, Value> > : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(multimap)<Key, Value> &mm )
+        {
+            dumpRange( *this, mm.begin(), mm.end() );
+        }
+    };
+
+    //
+    // std::complex
+    //
+    template<class Number>
+    class ValueTraits< CXXTEST_STD(complex)<Number> > : public StdTraitsBase
+    {
+    public:
+        ValueTraits( const CXXTEST_STD(complex)<Number> &c )
+        {
+            if ( !c.imag() )
+                *this << TS_AS_STRING(c.real());
+            else if ( !c.real() )
+                *this << "(" << TS_AS_STRING(c.imag()) << " * i)";
+            else
+                *this << "(" << TS_AS_STRING(c.real()) << " + " << TS_AS_STRING(c.imag()) << " * i)";
+        }
+    };
+#endif // _CXXTEST_PARTIAL_TEMPLATE_SPECIALIZATION
+};
+
+#endif // CXXTEST_USER_VALUE_TRAITS
+
+#endif // __cxxtest_StdValueTraits_h__
diff --git a/cxxtest/StdioFilePrinter.h b/cxxtest/StdioFilePrinter.h
new file mode 100644
index 0000000..47984b6
--- /dev/null
+++ b/cxxtest/StdioFilePrinter.h
@@ -0,0 +1,41 @@
+#ifndef __cxxtest__StdioFilePrinter_h__
+#define __cxxtest__StdioFilePrinter_h__
+
+//
+// The StdioFilePrinter is a simple TestListener that
+// just prints "OK" if everything goes well, otherwise
+// reports the error in the format of compiler messages.
+// This class uses <stdio.h>, i.e. FILE * and fprintf().
+//
+
+#include <cxxtest/ErrorFormatter.h>
+#include <stdio.h>
+
+namespace CxxTest 
+{
+    class StdioFilePrinter : public ErrorFormatter
+    {
+    public:
+        StdioFilePrinter( FILE *o, const char *preLine = ":", const char *postLine = "" ) :
+            ErrorFormatter( new Adapter(o), preLine, postLine ) {}
+        virtual ~StdioFilePrinter() { delete outputStream(); }
+
+    private:
+        class Adapter : public OutputStream
+        {
+            Adapter( const Adapter & );
+            Adapter &operator=( const Adapter & );
+            
+            FILE *_o;
+            
+        public:
+            Adapter( FILE *o ) : _o(o) {}
+            void flush() { fflush( _o ); }
+            OutputStream &operator<<( unsigned i ) { fprintf( _o, "%u", i ); return *this; }
+            OutputStream &operator<<( const char *s ) { fputs( s, _o ); return *this; }
+            OutputStream &operator<<( Manipulator m ) { return OutputStream::operator<<( m ); }
+        };
+    };
+}
+
+#endif // __cxxtest__StdioFilePrinter_h__
diff --git a/cxxtest/StdioPrinter.h b/cxxtest/StdioPrinter.h
new file mode 100644
index 0000000..af5bc6b
--- /dev/null
+++ b/cxxtest/StdioPrinter.h
@@ -0,0 +1,22 @@
+#ifndef __cxxtest__StdioPrinter_h__
+#define __cxxtest__StdioPrinter_h__
+
+//
+// The StdioPrinter is an StdioFilePrinter which defaults to stdout.
+// This should have been called StdOutPrinter or something, but the name
+// has been historically used.
+//
+
+#include <cxxtest/StdioFilePrinter.h>
+
+namespace CxxTest 
+{
+    class StdioPrinter : public StdioFilePrinter
+    {
+    public:
+        StdioPrinter( FILE *o = stdout, const char *preLine = ":", const char *postLine = "" ) :
+            StdioFilePrinter( o, preLine, postLine ) {}
+    };
+}
+
+#endif // __cxxtest__StdioPrinter_h__
diff --git a/cxxtest/TeeListener.h b/cxxtest/TeeListener.h
new file mode 100644
index 0000000..88afdd3
--- /dev/null
+++ b/cxxtest/TeeListener.h
@@ -0,0 +1,182 @@
+#ifndef __cxxtest__TeeListener_h__
+#define __cxxtest__TeeListener_h__
+
+//
+// A TeeListener notifies two "reular" TestListeners
+//
+
+#include <cxxtest/TestListener.h>
+#include <cxxtest/TestListener.h>
+
+namespace CxxTest
+{
+    class TeeListener : public TestListener
+    {
+    public:
+        TeeListener()
+        {
+            setFirst( _dummy );
+            setSecond( _dummy );
+        }
+
+        virtual ~TeeListener()
+        {
+        }
+
+        void setFirst( TestListener &first )
+        {
+            _first = &first;
+        }
+
+        void setSecond( TestListener &second )
+        {
+            _second = &second;
+        }
+
+        void enterWorld( const WorldDescription &d )
+        {
+            _first->enterWorld( d );
+            _second->enterWorld( d );
+        }
+
+        void enterSuite( const SuiteDescription &d )
+        {
+            _first->enterSuite( d );
+            _second->enterSuite( d );
+        }
+        
+        void enterTest( const TestDescription &d )
+        {
+            _first->enterTest( d );
+            _second->enterTest( d );
+        }
+        
+        void trace( const char *file, unsigned line, const char *expression )
+        {
+            _first->trace( file, line, expression );
+            _second->trace( file, line, expression );
+        }
+        
+        void warning( const char *file, unsigned line, const char *expression )
+        {
+            _first->warning( file, line, expression );
+            _second->warning( file, line, expression );
+        }
+        
+        void failedTest( const char *file, unsigned line, const char *expression )
+        {
+            _first->failedTest( file, line, expression );
+            _second->failedTest( file, line, expression );
+        }
+        
+        void failedAssert( const char *file, unsigned line, const char *expression )
+        {
+            _first->failedAssert( file, line, expression );
+            _second->failedAssert( file, line, expression );
+        }
+        
+        void failedAssertEquals( const char *file, unsigned line,
+                                 const char *xStr, const char *yStr,
+                                 const char *x, const char *y )
+        {
+            _first->failedAssertEquals( file, line, xStr, yStr, x, y );
+            _second->failedAssertEquals( file, line, xStr, yStr, x, y );
+        }
+
+        void failedAssertSameData( const char *file, unsigned line,
+                                   const char *xStr, const char *yStr,
+                                   const char *sizeStr, const void *x,
+                                   const void *y, unsigned size )
+        {
+            _first->failedAssertSameData( file, line, xStr, yStr, sizeStr, x, y, size );
+            _second->failedAssertSameData( file, line, xStr, yStr, sizeStr, x, y, size );
+        }
+        
+        void failedAssertDelta( const char *file, unsigned line,
+                                const char *xStr, const char *yStr, const char *dStr,
+                                const char *x, const char *y, const char *d )
+        {
+            _first->failedAssertDelta( file, line, xStr, yStr, dStr, x, y, d );
+            _second->failedAssertDelta( file, line, xStr, yStr, dStr, x, y, d );
+        }
+        
+        void failedAssertDiffers( const char *file, unsigned line,
+                                  const char *xStr, const char *yStr,
+                                  const char *value )
+        {
+            _first->failedAssertDiffers( file, line, xStr, yStr, value );
+            _second->failedAssertDiffers( file, line, xStr, yStr, value );
+        }
+        
+        void failedAssertLessThan( const char *file, unsigned line,
+                                   const char *xStr, const char *yStr,
+                                   const char *x, const char *y )
+        {
+            _first->failedAssertLessThan( file, line, xStr, yStr, x, y );
+            _second->failedAssertLessThan( file, line, xStr, yStr, x, y );
+        }
+        
+        void failedAssertLessThanEquals( const char *file, unsigned line,
+                                         const char *xStr, const char *yStr,
+                                         const char *x, const char *y )
+        {
+            _first->failedAssertLessThanEquals( file, line, xStr, yStr, x, y );
+            _second->failedAssertLessThanEquals( file, line, xStr, yStr, x, y );
+        }
+        
+        void failedAssertPredicate( const char *file, unsigned line,
+                                    const char *predicate, const char *xStr, const char *x )
+        {
+            _first->failedAssertPredicate( file, line, predicate, xStr, x );
+            _second->failedAssertPredicate( file, line, predicate, xStr, x );
+        }
+        
+        void failedAssertRelation( const char *file, unsigned line,
+                                   const char *relation, const char *xStr, const char *yStr,
+                                   const char *x, const char *y )
+        {
+            _first->failedAssertRelation( file, line, relation, xStr, yStr, x, y );
+            _second->failedAssertRelation( file, line, relation, xStr, yStr, x, y );
+        }
+        
+        void failedAssertThrows( const char *file, unsigned line,
+                                 const char *expression, const char *type,
+                                 bool otherThrown )
+        {
+            _first->failedAssertThrows( file, line, expression, type, otherThrown );
+            _second->failedAssertThrows( file, line, expression, type, otherThrown );
+        }
+        
+        void failedAssertThrowsNot( const char *file, unsigned line,
+                                    const char *expression )
+        {
+            _first->failedAssertThrowsNot( file, line, expression );
+            _second->failedAssertThrowsNot( file, line, expression );
+        }
+        
+        void leaveTest( const TestDescription &d )
+        {
+            _first->leaveTest(d);
+            _second->leaveTest(d);
+        }
+        
+        void leaveSuite( const SuiteDescription &d )
+        {
+            _first->leaveSuite(d);
+            _second->leaveSuite(d);
+        }
+        
+        void leaveWorld( const WorldDescription &d )
+        {
+            _first->leaveWorld(d);
+            _second->leaveWorld(d);
+        }
+
+    private:
+        TestListener *_first, *_second;
+        TestListener _dummy;
+    };
+};
+
+
+#endif // __cxxtest__TeeListener_h__
diff --git a/cxxtest/TestListener.h b/cxxtest/TestListener.h
new file mode 100644
index 0000000..0eeb523
--- /dev/null
+++ b/cxxtest/TestListener.h
@@ -0,0 +1,70 @@
+#ifndef __cxxtest__TestListener_h__
+#define __cxxtest__TestListener_h__
+
+//
+// TestListener is the base class for all "listeners",
+// i.e. classes that receive notifications of the
+// testing process.
+//
+// The names of the parameters are in comments to avoid
+// "unused parameter" warnings.
+//
+
+#include <cxxtest/Descriptions.h>
+
+namespace CxxTest
+{
+    class TestListener
+    {
+    public:
+        TestListener() {}
+        virtual ~TestListener() {}
+        
+        virtual void enterWorld( const WorldDescription & /*desc*/ ) {}
+        virtual void enterSuite( const SuiteDescription & /*desc*/ ) {}
+        virtual void enterTest( const TestDescription & /*desc*/ ) {}
+        virtual void trace( const char * /*file*/, unsigned /*line*/,
+                            const char * /*expression*/ ) {}
+        virtual void warning( const char * /*file*/, unsigned /*line*/,
+                              const char * /*expression*/ ) {}
+        virtual void failedTest( const char * /*file*/, unsigned /*line*/,
+                                 const char * /*expression*/ ) {}
+        virtual void failedAssert( const char * /*file*/, unsigned /*line*/,
+                                   const char * /*expression*/ ) {}
+        virtual void failedAssertEquals( const char * /*file*/, unsigned /*line*/,
+                                         const char * /*xStr*/, const char * /*yStr*/,
+                                         const char * /*x*/, const char * /*y*/ ) {}
+        virtual void failedAssertSameData( const char * /*file*/, unsigned /*line*/,
+                                           const char * /*xStr*/, const char * /*yStr*/,
+                                           const char * /*sizeStr*/, const void * /*x*/,
+                                           const void * /*y*/, unsigned /*size*/ ) {}
+        virtual void failedAssertDelta( const char * /*file*/, unsigned /*line*/,
+                                        const char * /*xStr*/, const char * /*yStr*/,
+                                        const char * /*dStr*/, const char * /*x*/,
+                                        const char * /*y*/, const char * /*d*/ ) {}
+        virtual void failedAssertDiffers( const char * /*file*/, unsigned /*line*/,
+                                          const char * /*xStr*/, const char * /*yStr*/,
+                                          const char * /*value*/ ) {}
+        virtual void failedAssertLessThan( const char * /*file*/, unsigned /*line*/,
+                                           const char * /*xStr*/, const char * /*yStr*/,
+                                           const char * /*x*/, const char * /*y*/ ) {}
+        virtual void failedAssertLessThanEquals( const char * /*file*/, unsigned /*line*/,
+                                                 const char * /*xStr*/, const char * /*yStr*/,
+                                                 const char * /*x*/, const char * /*y*/ ) {}
+        virtual void failedAssertPredicate( const char * /*file*/, unsigned /*line*/,
+                                            const char * /*predicate*/, const char * /*xStr*/, const char * /*x*/ ) {}
+        virtual void failedAssertRelation( const char * /*file*/, unsigned /*line*/,
+                                           const char * /*relation*/, const char * /*xStr*/, const char * /*yStr*/,
+                                           const char * /*x*/, const char * /*y*/ ) {}
+        virtual void failedAssertThrows( const char * /*file*/, unsigned /*line*/,
+                                         const char * /*expression*/, const char * /*type*/,
+                                         bool /*otherThrown*/ ) {}
+        virtual void failedAssertThrowsNot( const char * /*file*/, unsigned /*line*/,
+                                            const char * /*expression*/ ) {}
+        virtual void leaveTest( const TestDescription & /*desc*/ ) {}
+        virtual void leaveSuite( const SuiteDescription & /*desc*/ ) {}
+        virtual void leaveWorld( const WorldDescription & /*desc*/ ) {}
+    };
+}
+
+#endif // __cxxtest__TestListener_h__
diff --git a/cxxtest/TestRunner.h b/cxxtest/TestRunner.h
new file mode 100644
index 0000000..43f0832
--- /dev/null
+++ b/cxxtest/TestRunner.h
@@ -0,0 +1,125 @@
+#ifndef __cxxtest_TestRunner_h__
+#define __cxxtest_TestRunner_h__
+
+//
+// TestRunner is the class that runs all the tests.
+// To use it, create an object that implements the TestListener
+// interface and call TestRunner::runAllTests( myListener );
+// 
+
+#include <cxxtest/TestListener.h>
+#include <cxxtest/RealDescriptions.h>
+#include <cxxtest/TestSuite.h>
+#include <cxxtest/TestTracker.h>
+
+namespace CxxTest 
+{
+    class TestRunner
+    {
+    public:
+        static void runAllTests( TestListener &listener )
+        {
+            tracker().setListener( &listener );
+            _TS_TRY { TestRunner().runWorld(); }
+            _TS_LAST_CATCH( { tracker().failedTest( __FILE__, __LINE__, "Exception thrown from world" ); } );
+            tracker().setListener( 0 );
+        }
+
+        static void runAllTests( TestListener *listener )
+        {
+            if ( listener ) {
+                listener->warning( __FILE__, __LINE__, "Deprecated; Use runAllTests( TestListener & )" );
+                runAllTests( *listener );
+            }
+        }        
+    
+    private:
+        void runWorld()
+        {
+            RealWorldDescription wd;
+            WorldGuard sg;
+            
+            tracker().enterWorld( wd );
+            if ( wd.setUp() ) {
+                for ( SuiteDescription *sd = wd.firstSuite(); sd; sd = sd->next() )
+                    if ( sd->active() )
+                        runSuite( *sd );
+            
+                wd.tearDown();
+            }
+            tracker().leaveWorld( wd );
+        }
+    
+        void runSuite( SuiteDescription &sd )
+        {
+            StateGuard sg;
+            
+            tracker().enterSuite( sd );
+            if ( sd.setUp() ) {
+                for ( TestDescription *td = sd.firstTest(); td; td = td->next() )
+                    if ( td->active() )
+                        runTest( *td );
+
+                sd.tearDown();
+            }
+            tracker().leaveSuite( sd );
+        }
+
+        void runTest( TestDescription &td )
+        {
+            StateGuard sg;
+            
+            tracker().enterTest( td );
+            if ( td.setUp() ) {
+                td.run();
+                td.tearDown();
+            }
+            tracker().leaveTest( td );
+        }
+        
+        class StateGuard
+        {
+#ifdef _CXXTEST_HAVE_EH
+            bool _abortTestOnFail;
+#endif // _CXXTEST_HAVE_EH
+            unsigned _maxDumpSize;
+            
+        public:
+            StateGuard()
+            {
+#ifdef _CXXTEST_HAVE_EH
+                _abortTestOnFail = abortTestOnFail();
+#endif // _CXXTEST_HAVE_EH
+                _maxDumpSize = maxDumpSize();
+            }
+            
+            ~StateGuard()
+            {
+#ifdef _CXXTEST_HAVE_EH
+                setAbortTestOnFail( _abortTestOnFail );
+#endif // _CXXTEST_HAVE_EH
+                setMaxDumpSize( _maxDumpSize );
+            }
+        };
+
+        class WorldGuard : public StateGuard
+        {
+        public:
+            WorldGuard() : StateGuard()
+            {
+#ifdef _CXXTEST_HAVE_EH
+                setAbortTestOnFail( CXXTEST_DEFAULT_ABORT );
+#endif // _CXXTEST_HAVE_EH
+                setMaxDumpSize( CXXTEST_MAX_DUMP_SIZE );
+            }
+        };
+    };
+
+    //
+    // For --no-static-init
+    //
+    void initialize();
+};
+
+
+#endif // __cxxtest_TestRunner_h__
diff --git a/cxxtest/TestSuite.cpp b/cxxtest/TestSuite.cpp
new file mode 100644
index 0000000..bc14c2c
--- /dev/null
+++ b/cxxtest/TestSuite.cpp
@@ -0,0 +1,138 @@
+#ifndef __cxxtest__TestSuite_cpp__
+#define __cxxtest__TestSuite_cpp__
+
+#include <cxxtest/TestSuite.h>
+
+namespace CxxTest
+{
+    //
+    // TestSuite members
+    //
+    TestSuite::~TestSuite() {}
+    void TestSuite::setUp() {}
+    void TestSuite::tearDown() {}
+
+    //
+    // Test-aborting stuff
+    //
+    static bool currentAbortTestOnFail = false;
+
+    bool abortTestOnFail()
+    {
+        return currentAbortTestOnFail;
+    }
+
+    void setAbortTestOnFail( bool value )
+    {
+        currentAbortTestOnFail = value;
+    }
+    
+    void doAbortTest()
+    {
+#   if defined(_CXXTEST_HAVE_EH)
+        if ( currentAbortTestOnFail )
+            throw AbortTest();
+#   endif // _CXXTEST_HAVE_EH
+    }
+
+    //
+    // Max dump size
+    //
+    static unsigned currentMaxDumpSize = CXXTEST_MAX_DUMP_SIZE;
+
+    unsigned maxDumpSize()
+    {
+        return currentMaxDumpSize;
+    }
+    
+    void setMaxDumpSize( unsigned value )
+    {
+        currentMaxDumpSize = value;
+    }
+
+    //
+    // Some non-template functions
+    //
+    void doTrace( const char *file, unsigned line, const char *message )
+    {
+        tracker().trace( file, line, message );
+    }
+
+    void doWarn( const char *file, unsigned line, const char *message )
+    {
+        tracker().warning( file, line, message );
+    }
+
+    void doFailTest( const char *file, unsigned line, const char *message )
+    {
+        tracker().failedTest( file, line, message );
+        TS_ABORT();
+    }
+
+    void doFailAssert( const char *file, unsigned line,
+                       const char *expression, const char *message )
+    {
+        if ( message )
+            tracker().failedTest( file, line, message );
+        tracker().failedAssert( file, line, expression );
+        TS_ABORT();
+    }
+
+    bool sameData( const void *x, const void *y, unsigned size )
+    {
+        if ( size == 0 )
+            return true;
+        
+        if ( x == y )
+            return true;
+
+        if ( !x || !y )
+            return false;
+
+        const char *cx = (const char *)x;
+        const char *cy = (const char *)y;
+        while ( size -- )
+            if ( *cx++ != *cy++ )
+                return false;
+
+        return true;
+    }
+
+    void doAssertSameData( const char *file, unsigned line,
+                           const char *xExpr, const void *x,
+                           const char *yExpr, const void *y,
+                           const char *sizeExpr, unsigned size,
+                           const char *message )
+    {
+        if ( !sameData( x, y, size ) ) {
+            if ( message )
+                tracker().failedTest( file, line, message );
+            tracker().failedAssertSameData( file, line, xExpr, yExpr, sizeExpr, x, y, size );
+            TS_ABORT();
+        }
+    }
+
+    void doFailAssertThrows( const char *file, unsigned line,
+                             const char *expr, const char *type,
+                             bool otherThrown,
+                             const char *message )
+    {
+        if ( message )
+            tracker().failedTest( file, line, message );
+        
+        tracker().failedAssertThrows( file, line, expr, type, otherThrown );
+        TS_ABORT();
+    }
+
+    void doFailAssertThrowsNot( const char *file, unsigned line,
+                                const char *expression, const char *message )
+    {
+        if ( message )
+            tracker().failedTest( file, line, message );
+        
+        tracker().failedAssertThrowsNot( file, line, expression );
+        TS_ABORT();
+    }
+};
+
+#endif // __cxxtest__TestSuite_cpp__
diff --git a/cxxtest/TestSuite.h b/cxxtest/TestSuite.h
new file mode 100644
index 0000000..fc5a206
--- /dev/null
+++ b/cxxtest/TestSuite.h
@@ -0,0 +1,512 @@
+#ifndef __cxxtest__TestSuite_h__
+#define __cxxtest__TestSuite_h__
+
+//
+// class TestSuite is the base class for all test suites.
+// To define a test suite, derive from this class and add
+// member functions called void test*();
+//
+
+#include <cxxtest/Flags.h>
+#include <cxxtest/TestTracker.h>
+#include <cxxtest/Descriptions.h>
+#include <cxxtest/ValueTraits.h>
+
+#ifdef _CXXTEST_HAVE_STD
+#   include <stdexcept>
+#endif // _CXXTEST_HAVE_STD
+
+namespace CxxTest
+{
+    class TestSuite
+    {
+    public:
+        virtual ~TestSuite();
+        virtual void setUp();
+        virtual void tearDown();
+    };
+    
+    class AbortTest {};
+    void doAbortTest();
+#   define TS_ABORT() CxxTest::doAbortTest()
+    
+    bool abortTestOnFail();
+    void setAbortTestOnFail( bool value = CXXTEST_DEFAULT_ABORT );
+
+    unsigned maxDumpSize();
+    void setMaxDumpSize( unsigned value = CXXTEST_MAX_DUMP_SIZE );
+
+    void doTrace( const char *file, unsigned line, const char *message );
+    void doWarn( const char *file, unsigned line, const char *message );
+    void doFailTest( const char *file, unsigned line, const char *message );
+    void doFailAssert( const char *file, unsigned line, const char *expression, const char *message );
+
+    template<class X, class Y>
+    bool equals( X x, Y y )
+    {
+        return (x == y);
+    }
+
+    template<class X, class Y>
+    void doAssertEquals( const char *file, unsigned line,
+                         const char *xExpr, X x,
+                         const char *yExpr, Y y,
+                         const char *message )
+    {
+        if ( !equals( x, y ) ) {
+            if ( message )
+                tracker().failedTest( file, line, message );
+            tracker().failedAssertEquals( file, line, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y) );
+            TS_ABORT();
+        }
+    }
+
+    void doAssertSameData( const char *file, unsigned line,
+                           const char *xExpr, const void *x,
+                           const char *yExpr, const void *y,
+                           const char *sizeExpr, unsigned size,
+                           const char *message );
+
+    template<class X, class Y>
+    bool differs( X x, Y y )
+    {
+        return !(x == y);
+    }
+
+    template<class X, class Y>
+    void doAssertDiffers( const char *file, unsigned line,
+                          const char *xExpr, X x,
+                          const char *yExpr, Y y,
+                          const char *message )
+    {
+        if ( !differs( x, y ) ) {
+            if ( message )
+                tracker().failedTest( file, line, message );
+            tracker().failedAssertDiffers( file, line, xExpr, yExpr, TS_AS_STRING(x) );
+            TS_ABORT();
+        }
+    }
+
+    template<class X, class Y>
+    bool lessThan( X x, Y y )
+    {
+        return (x < y);
+    }
+
+    template<class X, class Y>
+    void doAssertLessThan( const char *file, unsigned line,
+                           const char *xExpr, X x,
+                           const char *yExpr, Y y,
+                           const char *message )
+    {
+        if ( !lessThan(x, y) ) {
+            if ( message )
+                tracker().failedTest( file, line, message );
+            tracker().failedAssertLessThan( file, line, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y) );
+            TS_ABORT();
+        }
+    }
+
+    template<class X, class Y>
+    bool lessThanEquals( X x, Y y )
+    {
+        return (x <= y);
+    }
+
+    template<class X, class Y>
+    void doAssertLessThanEquals( const char *file, unsigned line,
+                                 const char *xExpr, X x,
+                                 const char *yExpr, Y y,
+                                 const char *message )
+    {
+        if ( !lessThanEquals( x, y ) ) {
+            if ( message )
+                tracker().failedTest( file, line, message );
+            tracker().failedAssertLessThanEquals( file, line, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y) );
+            TS_ABORT();
+        }
+    }
+
+    template<class X, class P>
+    void doAssertPredicate( const char *file, unsigned line,
+                            const char *pExpr, const P &p,
+                            const char *xExpr, X x,
+                            const char *message )
+    {
+        if ( !p( x ) ) {
+            if ( message )
+                tracker().failedTest( file, line, message );
+            tracker().failedAssertPredicate( file, line, pExpr, xExpr, TS_AS_STRING(x) );
+            TS_ABORT();
+        }
+    }
+
+    template<class X, class Y, class R>
+    void doAssertRelation( const char *file, unsigned line,
+                           const char *rExpr, const R &r, 
+                           const char *xExpr, X x,
+                           const char *yExpr, Y y,
+                           const char *message )
+    {
+        if ( !r( x, y ) ) {
+            if ( message )
+                tracker().failedTest( file, line, message );
+            tracker().failedAssertRelation( file, line, rExpr, xExpr, yExpr, TS_AS_STRING(x), TS_AS_STRING(y) );
+            TS_ABORT();
+        }
+    }
+
+    template<class X, class Y, class D>
+    bool delta( X x, Y y, D d )
+    {
+        return ((y >= x - d) && (y <= x + d));
+    }
+
+    template<class X, class Y, class D>
+    void doAssertDelta( const char *file, unsigned line,
+                        const char *xExpr, X x,
+                        const char *yExpr, Y y,
+                        const char *dExpr, D d,
+                        const char *message )
+    {
+        if ( !delta( x, y, d ) ) {
+            if ( message )
+                tracker().failedTest( file, line, message );
+            
+            tracker().failedAssertDelta( file, line, xExpr, yExpr, dExpr,
+                                         TS_AS_STRING(x), TS_AS_STRING(y), TS_AS_STRING(d) );
+            TS_ABORT();
+        }
+    }
+
+    void doFailAssertThrows( const char *file, unsigned line,
+                             const char *expr, const char *type,
+                             bool otherThrown,
+                             const char *message );
+    
+    void doFailAssertThrowsNot( const char *file, unsigned line,
+                                const char *expression, const char *message );
+
+#   ifdef _CXXTEST_HAVE_EH
+#       define _TS_TRY try
+#       define _TS_CATCH_TYPE(t, b) catch t b
+#       define _TS_CATCH_ABORT(b) _TS_CATCH_TYPE( (const CxxTest::AbortTest &), b )
+#       define _TS_LAST_CATCH(b) _TS_CATCH_TYPE( (...), b )
+#       define _TSM_LAST_CATCH(f,l,m) _TS_LAST_CATCH( { (CxxTest::tracker()).failedTest(f,l,m); } )
+#       ifdef _CXXTEST_HAVE_STD
+#           define ___TSM_CATCH(f,l,m) \
+                    catch(const std::exception &e) { (CxxTest::tracker()).failedTest(f,l,e.what()); } \
+                    _TSM_LAST_CATCH(f,l,m)
+#       else // !_CXXTEST_HAVE_STD
+#           define ___TSM_CATCH(f,l,m) _TSM_LAST_CATCH(f,l,m)
+#       endif // _CXXTEST_HAVE_STD
+#       define __TSM_CATCH(f,l,m) \
+                _TS_CATCH_ABORT( { throw; } ) \
+                ___TSM_CATCH(f,l,m)
+#       define __TS_CATCH(f,l) __TSM_CATCH(f,l,"Unhandled exception")
+#       define _TS_CATCH __TS_CATCH(__FILE__,__LINE__)
+#   else // !_CXXTEST_HAVE_EH
+#       define _TS_TRY
+#       define ___TSM_CATCH(f,l,m)
+#       define __TSM_CATCH(f,l,m)
+#       define __TS_CATCH(f,l)
+#       define _TS_CATCH
+#       define _TS_CATCH_TYPE(t, b)
+#       define _TS_LAST_CATCH(b)
+#       define _TS_CATCH_ABORT(b)
+#   endif // _CXXTEST_HAVE_EH
+
+    // TS_TRACE
+#   define _TS_TRACE(f,l,e) CxxTest::doTrace( (f), (l), TS_AS_STRING(e) )
+#   define TS_TRACE(e) _TS_TRACE( __FILE__, __LINE__, e )
+
+    // TS_WARN
+#   define _TS_WARN(f,l,e) CxxTest::doWarn( (f), (l), TS_AS_STRING(e) )
+#   define TS_WARN(e) _TS_WARN( __FILE__, __LINE__, e )
+
+    // TS_FAIL
+#   define _TS_FAIL(f,l,e) CxxTest::doFailTest( (f), (l), TS_AS_STRING(e) )
+#   define TS_FAIL(e) _TS_FAIL( __FILE__, __LINE__, e )
+
+    // TS_ASSERT
+#   define ___ETS_ASSERT(f,l,e,m) { if ( !(e) ) CxxTest::doFailAssert( (f), (l), #e, (m) ); }
+#   define ___TS_ASSERT(f,l,e,m) { _TS_TRY { ___ETS_ASSERT(f,l,e,m); } __TS_CATCH(f,l) }
+    
+#   define _ETS_ASSERT(f,l,e) ___ETS_ASSERT(f,l,e,0)
+#   define _TS_ASSERT(f,l,e) ___TS_ASSERT(f,l,e,0)
+    
+#   define ETS_ASSERT(e) _ETS_ASSERT(__FILE__,__LINE__,e)
+#   define TS_ASSERT(e) _TS_ASSERT(__FILE__,__LINE__,e)
+    
+#   define _ETSM_ASSERT(f,l,m,e) ___ETS_ASSERT(f,l,e,TS_AS_STRING(m) )
+#   define _TSM_ASSERT(f,l,m,e) ___TS_ASSERT(f,l,e,TS_AS_STRING(m) )
+
+#   define ETSM_ASSERT(m,e) _ETSM_ASSERT(__FILE__,__LINE__,m,e)
+#   define TSM_ASSERT(m,e) _TSM_ASSERT(__FILE__,__LINE__,m,e)
+    
+    // TS_ASSERT_EQUALS
+#   define ___ETS_ASSERT_EQUALS(f,l,x,y,m) CxxTest::doAssertEquals( (f), (l), #x, (x), #y, (y), (m) )
+#   define ___TS_ASSERT_EQUALS(f,l,x,y,m) { _TS_TRY { ___ETS_ASSERT_EQUALS(f,l,x,y,m); } __TS_CATCH(f,l) }
+    
+#   define _ETS_ASSERT_EQUALS(f,l,x,y) ___ETS_ASSERT_EQUALS(f,l,x,y,0)
+#   define _TS_ASSERT_EQUALS(f,l,x,y) ___TS_ASSERT_EQUALS(f,l,x,y,0)
+
+#   define ETS_ASSERT_EQUALS(x,y) _ETS_ASSERT_EQUALS(__FILE__,__LINE__,x,y)
+#   define TS_ASSERT_EQUALS(x,y) _TS_ASSERT_EQUALS(__FILE__,__LINE__,x,y)
+
+#   define _ETSM_ASSERT_EQUALS(f,l,m,x,y) ___ETS_ASSERT_EQUALS(f,l,x,y,TS_AS_STRING(m))
+#   define _TSM_ASSERT_EQUALS(f,l,m,x,y) ___TS_ASSERT_EQUALS(f,l,x,y,TS_AS_STRING(m))
+
+#   define ETSM_ASSERT_EQUALS(m,x,y) _ETSM_ASSERT_EQUALS(__FILE__,__LINE__,m,x,y)
+#   define TSM_ASSERT_EQUALS(m,x,y) _TSM_ASSERT_EQUALS(__FILE__,__LINE__,m,x,y)
+
+    // TS_ASSERT_SAME_DATA
+#   define ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,m) CxxTest::doAssertSameData( (f), (l), #x, (x), #y, (y), #s, (s), (m) )
+#   define ___TS_ASSERT_SAME_DATA(f,l,x,y,s,m) { _TS_TRY { ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,m); } __TS_CATCH(f,l) }
+    
+#   define _ETS_ASSERT_SAME_DATA(f,l,x,y,s) ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,0)
+#   define _TS_ASSERT_SAME_DATA(f,l,x,y,s) ___TS_ASSERT_SAME_DATA(f,l,x,y,s,0)
+
+#   define ETS_ASSERT_SAME_DATA(x,y,s) _ETS_ASSERT_SAME_DATA(__FILE__,__LINE__,x,y,s)
+#   define TS_ASSERT_SAME_DATA(x,y,s) _TS_ASSERT_SAME_DATA(__FILE__,__LINE__,x,y,s)
+
+#   define _ETSM_ASSERT_SAME_DATA(f,l,m,x,y,s) ___ETS_ASSERT_SAME_DATA(f,l,x,y,s,TS_AS_STRING(m))
+#   define _TSM_ASSERT_SAME_DATA(f,l,m,x,y,s) ___TS_ASSERT_SAME_DATA(f,l,x,y,s,TS_AS_STRING(m))
+
+#   define ETSM_ASSERT_SAME_DATA(m,x,y,s) _ETSM_ASSERT_SAME_DATA(__FILE__,__LINE__,m,x,y,s)
+#   define TSM_ASSERT_SAME_DATA(m,x,y,s) _TSM_ASSERT_SAME_DATA(__FILE__,__LINE__,m,x,y,s)
+
+    // TS_ASSERT_DIFFERS
+#   define ___ETS_ASSERT_DIFFERS(f,l,x,y,m) CxxTest::doAssertDiffers( (f), (l), #x, (x), #y, (y), (m) )
+#   define ___TS_ASSERT_DIFFERS(f,l,x,y,m) { _TS_TRY { ___ETS_ASSERT_DIFFERS(f,l,x,y,m); } __TS_CATCH(f,l) }
+
+#   define _ETS_ASSERT_DIFFERS(f,l,x,y) ___ETS_ASSERT_DIFFERS(f,l,x,y,0)
+#   define _TS_ASSERT_DIFFERS(f,l,x,y) ___TS_ASSERT_DIFFERS(f,l,x,y,0)
+
+#   define ETS_ASSERT_DIFFERS(x,y) _ETS_ASSERT_DIFFERS(__FILE__,__LINE__,x,y)
+#   define TS_ASSERT_DIFFERS(x,y) _TS_ASSERT_DIFFERS(__FILE__,__LINE__,x,y)
+
+#   define _ETSM_ASSERT_DIFFERS(f,l,m,x,y) ___ETS_ASSERT_DIFFERS(f,l,x,y,TS_AS_STRING(m))
+#   define _TSM_ASSERT_DIFFERS(f,l,m,x,y) ___TS_ASSERT_DIFFERS(f,l,x,y,TS_AS_STRING(m))
+
+#   define ETSM_ASSERT_DIFFERS(m,x,y) _ETSM_ASSERT_DIFFERS(__FILE__,__LINE__,m,x,y)
+#   define TSM_ASSERT_DIFFERS(m,x,y) _TSM_ASSERT_DIFFERS(__FILE__,__LINE__,m,x,y)
+
+    // TS_ASSERT_LESS_THAN
+#   define ___ETS_ASSERT_LESS_THAN(f,l,x,y,m) CxxTest::doAssertLessThan( (f), (l), #x, (x), #y, (y), (m) )
+#   define ___TS_ASSERT_LESS_THAN(f,l,x,y,m) { _TS_TRY { ___ETS_ASSERT_LESS_THAN(f,l,x,y,m); } __TS_CATCH(f,l) }
+
+#   define _ETS_ASSERT_LESS_THAN(f,l,x,y) ___ETS_ASSERT_LESS_THAN(f,l,x,y,0)
+#   define _TS_ASSERT_LESS_THAN(f,l,x,y) ___TS_ASSERT_LESS_THAN(f,l,x,y,0)
+
+#   define ETS_ASSERT_LESS_THAN(x,y) _ETS_ASSERT_LESS_THAN(__FILE__,__LINE__,x,y)
+#   define TS_ASSERT_LESS_THAN(x,y) _TS_ASSERT_LESS_THAN(__FILE__,__LINE__,x,y)
+
+#   define _ETSM_ASSERT_LESS_THAN(f,l,m,x,y) ___ETS_ASSERT_LESS_THAN(f,l,x,y,TS_AS_STRING(m))
+#   define _TSM_ASSERT_LESS_THAN(f,l,m,x,y) ___TS_ASSERT_LESS_THAN(f,l,x,y,TS_AS_STRING(m))
+
+#   define ETSM_ASSERT_LESS_THAN(m,x,y) _ETSM_ASSERT_LESS_THAN(__FILE__,__LINE__,m,x,y)
+#   define TSM_ASSERT_LESS_THAN(m,x,y) _TSM_ASSERT_LESS_THAN(__FILE__,__LINE__,m,x,y)
+
+    // TS_ASSERT_LESS_THAN_EQUALS
+#   define ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,m) \
+        CxxTest::doAssertLessThanEquals( (f), (l), #x, (x), #y, (y), (m) )
+#   define ___TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,m) \
+        { _TS_TRY { ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,m); } __TS_CATCH(f,l) }
+
+#   define _ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y) ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,0)
+#   define _TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y) ___TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,0)
+
+#   define ETS_ASSERT_LESS_THAN_EQUALS(x,y) _ETS_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,x,y)
+#   define TS_ASSERT_LESS_THAN_EQUALS(x,y) _TS_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,x,y)
+
+#   define _ETSM_ASSERT_LESS_THAN_EQUALS(f,l,m,x,y) ___ETS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,TS_AS_STRING(m))
+#   define _TSM_ASSERT_LESS_THAN_EQUALS(f,l,m,x,y) ___TS_ASSERT_LESS_THAN_EQUALS(f,l,x,y,TS_AS_STRING(m))
+
+#   define ETSM_ASSERT_LESS_THAN_EQUALS(m,x,y) _ETSM_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,m,x,y)
+#   define TSM_ASSERT_LESS_THAN_EQUALS(m,x,y) _TSM_ASSERT_LESS_THAN_EQUALS(__FILE__,__LINE__,m,x,y)
+
+    // TS_ASSERT_PREDICATE
+#   define ___ETS_ASSERT_PREDICATE(f,l,p,x,m) \
+        CxxTest::doAssertPredicate( (f), (l), #p, p(), #x, (x), (m) )
+#   define ___TS_ASSERT_PREDICATE(f,l,p,x,m) \
+        { _TS_TRY { ___ETS_ASSERT_PREDICATE(f,l,p,x,m); } __TS_CATCH(f,l) }
+
+#   define _ETS_ASSERT_PREDICATE(f,l,p,x) ___ETS_ASSERT_PREDICATE(f,l,p,x,0)
+#   define _TS_ASSERT_PREDICATE(f,l,p,x) ___TS_ASSERT_PREDICATE(f,l,p,x,0)
+
+#   define ETS_ASSERT_PREDICATE(p,x) _ETS_ASSERT_PREDICATE(__FILE__,__LINE__,p,x)
+#   define TS_ASSERT_PREDICATE(p,x) _TS_ASSERT_PREDICATE(__FILE__,__LINE__,p,x)
+
+#   define _ETSM_ASSERT_PREDICATE(f,l,m,p,x) ___ETS_ASSERT_PREDICATE(f,l,p,x,TS_AS_STRING(m))
+#   define _TSM_ASSERT_PREDICATE(f,l,m,p,x) ___TS_ASSERT_PREDICATE(f,l,p,x,TS_AS_STRING(m))
+
+#   define ETSM_ASSERT_PREDICATE(m,p,x) _ETSM_ASSERT_PREDICATE(__FILE__,__LINE__,m,p,x)
+#   define TSM_ASSERT_PREDICATE(m,p,x) _TSM_ASSERT_PREDICATE(__FILE__,__LINE__,m,p,x)
+
+    // TS_ASSERT_RELATION
+#   define ___ETS_ASSERT_RELATION(f,l,r,x,y,m) \
+        CxxTest::doAssertRelation( (f), (l), #r, r(), #x, (x), #y, (y), (m) )
+#   define ___TS_ASSERT_RELATION(f,l,r,x,y,m) \
+        { _TS_TRY { ___ETS_ASSERT_RELATION(f,l,r,x,y,m); } __TS_CATCH(f,l) }
+
+#   define _ETS_ASSERT_RELATION(f,l,r,x,y) ___ETS_ASSERT_RELATION(f,l,r,x,y,0)
+#   define _TS_ASSERT_RELATION(f,l,r,x,y) ___TS_ASSERT_RELATION(f,l,r,x,y,0)
+
+#   define ETS_ASSERT_RELATION(r,x,y) _ETS_ASSERT_RELATION(__FILE__,__LINE__,r,x,y)
+#   define TS_ASSERT_RELATION(r,x,y) _TS_ASSERT_RELATION(__FILE__,__LINE__,r,x,y)
+
+#   define _ETSM_ASSERT_RELATION(f,l,m,r,x,y) ___ETS_ASSERT_RELATION(f,l,r,x,y,TS_AS_STRING(m))
+#   define _TSM_ASSERT_RELATION(f,l,m,r,x,y) ___TS_ASSERT_RELATION(f,l,r,x,y,TS_AS_STRING(m))
+
+#   define ETSM_ASSERT_RELATION(m,r,x,y) _ETSM_ASSERT_RELATION(__FILE__,__LINE__,m,r,x,y)
+#   define TSM_ASSERT_RELATION(m,r,x,y) _TSM_ASSERT_RELATION(__FILE__,__LINE__,m,r,x,y)
+
+    // TS_ASSERT_DELTA
+#   define ___ETS_ASSERT_DELTA(f,l,x,y,d,m) CxxTest::doAssertDelta( (f), (l), #x, (x), #y, (y), #d, (d), (m) )
+#   define ___TS_ASSERT_DELTA(f,l,x,y,d,m) { _TS_TRY { ___ETS_ASSERT_DELTA(f,l,x,y,d,m); } __TS_CATCH(f,l) }
+    
+#   define _ETS_ASSERT_DELTA(f,l,x,y,d) ___ETS_ASSERT_DELTA(f,l,x,y,d,0)
+#   define _TS_ASSERT_DELTA(f,l,x,y,d) ___TS_ASSERT_DELTA(f,l,x,y,d,0)
+
+#   define ETS_ASSERT_DELTA(x,y,d) _ETS_ASSERT_DELTA(__FILE__,__LINE__,x,y,d)
+#   define TS_ASSERT_DELTA(x,y,d) _TS_ASSERT_DELTA(__FILE__,__LINE__,x,y,d)
+
+#   define _ETSM_ASSERT_DELTA(f,l,m,x,y,d) ___ETS_ASSERT_DELTA(f,l,x,y,d,TS_AS_STRING(m))
+#   define _TSM_ASSERT_DELTA(f,l,m,x,y,d) ___TS_ASSERT_DELTA(f,l,x,y,d,TS_AS_STRING(m))
+
+#   define ETSM_ASSERT_DELTA(m,x,y,d) _ETSM_ASSERT_DELTA(__FILE__,__LINE__,m,x,y,d)
+#   define TSM_ASSERT_DELTA(m,x,y,d) _TSM_ASSERT_DELTA(__FILE__,__LINE__,m,x,y,d)
+
+    // TS_ASSERT_THROWS
+#   define ___TS_ASSERT_THROWS(f,l,e,t,m) { \
+            bool _ts_threw_expected = false, _ts_threw_else = false; \
+            _TS_TRY { e; } \
+            _TS_CATCH_TYPE( (t), { _ts_threw_expected = true; } ) \
+            _TS_CATCH_ABORT( { throw; } ) \
+            _TS_LAST_CATCH( { _ts_threw_else = true; } ) \
+            if ( !_ts_threw_expected ) { CxxTest::doFailAssertThrows( (f), (l), #e, #t, _ts_threw_else, (m) ); } }
+
+#   define _TS_ASSERT_THROWS(f,l,e,t) ___TS_ASSERT_THROWS(f,l,e,t,0)
+#   define TS_ASSERT_THROWS(e,t) _TS_ASSERT_THROWS(__FILE__,__LINE__,e,t)
+
+#   define _TSM_ASSERT_THROWS(f,l,m,e,t) ___TS_ASSERT_THROWS(f,l,e,t,TS_AS_STRING(m))
+#   define TSM_ASSERT_THROWS(m,e,t) _TSM_ASSERT_THROWS(__FILE__,__LINE__,m,e,t)
+
+    // TS_ASSERT_THROWS_ASSERT
+#   define ___TS_ASSERT_THROWS_ASSERT(f,l,e,t,a,m) { \
+            bool _ts_threw_expected = false, _ts_threw_else = false; \
+            _TS_TRY { e; } \
+            _TS_CATCH_TYPE( (t), { a; _ts_threw_expected = true; } ) \
+            _TS_CATCH_ABORT( { throw; } ) \
+            _TS_LAST_CATCH( { _ts_threw_else = true; } ) \
+            if ( !_ts_threw_expected ) { CxxTest::doFailAssertThrows( (f), (l), #e, #t, _ts_threw_else, (m) ); } }
+
+#   define _TS_ASSERT_THROWS_ASSERT(f,l,e,t,a) ___TS_ASSERT_THROWS_ASSERT(f,l,e,t,a,0)
+#   define TS_ASSERT_THROWS_ASSERT(e,t,a) _TS_ASSERT_THROWS_ASSERT(__FILE__,__LINE__,e,t,a)
+
+#   define _TSM_ASSERT_THROWS_ASSERT(f,l,m,e,t,a) ___TS_ASSERT_THROWS_ASSERT(f,l,e,t,a,TS_AS_STRING(m))
+#   define TSM_ASSERT_THROWS_ASSERT(m,e,t,a) _TSM_ASSERT_THROWS_ASSERT(__FILE__,__LINE__,m,e,t,a)
+
+    // TS_ASSERT_THROWS_EQUALS
+#   define TS_ASSERT_THROWS_EQUALS(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_EQUALS(x,y))
+#   define TSM_ASSERT_THROWS_EQUALS(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_EQUALS(m,x,y))
+
+    // TS_ASSERT_THROWS_DIFFERS
+#   define TS_ASSERT_THROWS_DIFFERS(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_DIFFERS(x,y))
+#   define TSM_ASSERT_THROWS_DIFFERS(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_DIFFERS(m,x,y))
+
+    // TS_ASSERT_THROWS_DELTA
+#   define TS_ASSERT_THROWS_DELTA(e,t,x,y,d) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_DELTA(x,y,d))
+#   define TSM_ASSERT_THROWS_DELTA(m,e,t,x,y,d) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_DELTA(m,x,y,d))
+
+    // TS_ASSERT_THROWS_SAME_DATA
+#   define TS_ASSERT_THROWS_SAME_DATA(e,t,x,y,s) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_SAME_DATA(x,y,s))
+#   define TSM_ASSERT_THROWS_SAME_DATA(m,e,t,x,y,s) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_SAME_DATA(m,x,y,s))
+
+    // TS_ASSERT_THROWS_LESS_THAN
+#   define TS_ASSERT_THROWS_LESS_THAN(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_LESS_THAN(x,y))
+#   define TSM_ASSERT_THROWS_LESS_THAN(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_LESS_THAN(m,x,y))
+
+    // TS_ASSERT_THROWS_LESS_THAN_EQUALS
+#   define TS_ASSERT_THROWS_LESS_THAN_EQUALS(e,t,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_LESS_THAN_EQUALS(x,y))
+#   define TSM_ASSERT_THROWS_LESS_THAN_EQUALS(m,e,t,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_LESS_THAN_EQUALS(m,x,y))
+
+    // TS_ASSERT_THROWS_PREDICATE
+#   define TS_ASSERT_THROWS_PREDICATE(e,t,p,v) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_PREDICATE(p,v))
+#   define TSM_ASSERT_THROWS_PREDICATE(m,e,t,p,v) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_PREDICATE(m,p,v))
+
+    // TS_ASSERT_THROWS_RELATION
+#   define TS_ASSERT_THROWS_RELATION(e,t,r,x,y) TS_ASSERT_THROWS_ASSERT(e,t,TS_ASSERT_RELATION(r,x,y))
+#   define TSM_ASSERT_THROWS_RELATION(m,e,t,r,x,y) TSM_ASSERT_THROWS_ASSERT(m,e,t,TSM_ASSERT_RELATION(m,r,x,y))
+
+    // TS_ASSERT_THROWS_ANYTHING
+#   define ___TS_ASSERT_THROWS_ANYTHING(f,l,e,m) { \
+            bool _ts_threw = false; \
+            _TS_TRY { e; } \
+            _TS_LAST_CATCH( { _ts_threw = true; } ) \
+            if ( !_ts_threw ) { CxxTest::doFailAssertThrows( (f), (l), #e, "...", false, (m) ); } }
+
+#   define _TS_ASSERT_THROWS_ANYTHING(f,l,e) ___TS_ASSERT_THROWS_ANYTHING(f,l,e,0)
+#   define TS_ASSERT_THROWS_ANYTHING(e) _TS_ASSERT_THROWS_ANYTHING(__FILE__, __LINE__, e)
+
+#   define _TSM_ASSERT_THROWS_ANYTHING(f,l,m,e) ___TS_ASSERT_THROWS_ANYTHING(f,l,e,TS_AS_STRING(m))
+#   define TSM_ASSERT_THROWS_ANYTHING(m,e) _TSM_ASSERT_THROWS_ANYTHING(__FILE__,__LINE__,m,e)
+
+    // TS_ASSERT_THROWS_NOTHING
+#   define ___TS_ASSERT_THROWS_NOTHING(f,l,e,m) { \
+            _TS_TRY { e; } \
+            _TS_CATCH_ABORT( { throw; } ) \
+            _TS_LAST_CATCH( { CxxTest::doFailAssertThrowsNot( (f), (l), #e, (m) ); } ) }
+
+#   define _TS_ASSERT_THROWS_NOTHING(f,l,e) ___TS_ASSERT_THROWS_NOTHING(f,l,e,0)
+#   define TS_ASSERT_THROWS_NOTHING(e) _TS_ASSERT_THROWS_NOTHING(__FILE__,__LINE__,e)
+
+#   define _TSM_ASSERT_THROWS_NOTHING(f,l,m,e) ___TS_ASSERT_THROWS_NOTHING(f,l,e,TS_AS_STRING(m))
+#   define TSM_ASSERT_THROWS_NOTHING(m,e) _TSM_ASSERT_THROWS_NOTHING(__FILE__,__LINE__,m,e)
+
+
+    //
+    // This takes care of "signed <-> unsigned" warnings
+    //
+#   define CXXTEST_COMPARISONS(CXXTEST_X, CXXTEST_Y, CXXTEST_T) \
+    inline bool equals( CXXTEST_X x, CXXTEST_Y y ) { return (((CXXTEST_T)x) == ((CXXTEST_T)y)); } \
+    inline bool equals( CXXTEST_Y y, CXXTEST_X x ) { return (((CXXTEST_T)y) == ((CXXTEST_T)x)); } \
+    inline bool differs( CXXTEST_X x, CXXTEST_Y y ) { return (((CXXTEST_T)x) != ((CXXTEST_T)y)); } \
+    inline bool differs( CXXTEST_Y y, CXXTEST_X x ) { return (((CXXTEST_T)y) != ((CXXTEST_T)x)); } \
+    inline bool lessThan( CXXTEST_X x, CXXTEST_Y y ) { return (((CXXTEST_T)x) < ((CXXTEST_T)y)); } \
+    inline bool lessThan( CXXTEST_Y y, CXXTEST_X x ) { return (((CXXTEST_T)y) < ((CXXTEST_T)x)); } \
+    inline bool lessThanEquals( CXXTEST_X x, CXXTEST_Y y ) { return (((CXXTEST_T)x) <= ((CXXTEST_T)y)); } \
+    inline bool lessThanEquals( CXXTEST_Y y, CXXTEST_X x ) { return (((CXXTEST_T)y) <= ((CXXTEST_T)x)); }
+
+#   define CXXTEST_INTEGRAL(CXXTEST_T) \
+    CXXTEST_COMPARISONS( signed CXXTEST_T, unsigned CXXTEST_T, unsigned CXXTEST_T )
+
+    CXXTEST_INTEGRAL( char )
+    CXXTEST_INTEGRAL( short )
+    CXXTEST_INTEGRAL( int )
+    CXXTEST_INTEGRAL( long )
+#   ifdef _CXXTEST_LONGLONG
+    CXXTEST_INTEGRAL( _CXXTEST_LONGLONG )
+#   endif // _CXXTEST_LONGLONG
+
+#   define CXXTEST_SMALL_BIG(CXXTEST_SMALL, CXXTEST_BIG) \
+    CXXTEST_COMPARISONS( signed CXXTEST_SMALL, unsigned CXXTEST_BIG, unsigned CXXTEST_BIG ) \
+    CXXTEST_COMPARISONS( signed CXXTEST_BIG, unsigned CXXTEST_SMALL, unsigned CXXTEST_BIG )
+
+    CXXTEST_SMALL_BIG( char, short )    
+    CXXTEST_SMALL_BIG( char, int )
+    CXXTEST_SMALL_BIG( short, int )
+    CXXTEST_SMALL_BIG( char, long )
+    CXXTEST_SMALL_BIG( short, long )
+    CXXTEST_SMALL_BIG( int, long )
+        
+#   ifdef _CXXTEST_LONGLONG
+    CXXTEST_SMALL_BIG( char, _CXXTEST_LONGLONG )
+    CXXTEST_SMALL_BIG( short, _CXXTEST_LONGLONG )
+    CXXTEST_SMALL_BIG( int, _CXXTEST_LONGLONG )
+    CXXTEST_SMALL_BIG( long, _CXXTEST_LONGLONG )
+#   endif // _CXXTEST_LONGLONG
+}
+
+#endif // __cxxtest__TestSuite_h__
diff --git a/cxxtest/TestTracker.cpp b/cxxtest/TestTracker.cpp
new file mode 100644
index 0000000..f3ce781
--- /dev/null
+++ b/cxxtest/TestTracker.cpp
@@ -0,0 +1,248 @@
+#ifndef __cxxtest__TestTracker_cpp__
+#define __cxxtest__TestTracker_cpp__
+
+#include <cxxtest/TestTracker.h>
+
+namespace CxxTest
+{
+    bool TestTracker::_created = false;
+
+    TestTracker::TestTracker()
+    {
+        if ( !_created ) {
+            initialize();
+            _created = true;
+        }
+    }
+
+    TestTracker::~TestTracker()
+    {
+    }
+    
+    TestTracker & TestTracker::tracker()
+    {
+        static TestTracker theTracker;
+        return theTracker;
+    }
+
+    void TestTracker::initialize()
+    {
+        _warnings = 0;
+        _failedTests = 0;
+        _testFailedAsserts = 0;
+        _suiteFailedTests = 0;
+        _failedSuites = 0;
+        setListener( 0 );
+        _world = 0;
+        _suite = 0;
+        _test = 0;
+    }
+
+    const TestDescription *TestTracker::fixTest( const TestDescription *d ) const
+    {
+        return d ? d : &dummyTest();
+    }
+    
+    const SuiteDescription *TestTracker::fixSuite( const SuiteDescription *d ) const
+    {
+        return d ? d : &dummySuite();
+    }
+    
+    const WorldDescription *TestTracker::fixWorld( const WorldDescription *d ) const
+    {
+        return d ? d : &dummyWorld();
+    }
+    
+    const TestDescription &TestTracker::dummyTest() const
+    {
+        return dummySuite().testDescription(0);
+    }
+    
+    const SuiteDescription &TestTracker::dummySuite() const
+    {
+        return dummyWorld().suiteDescription(0);
+    }
+    
+    const WorldDescription &TestTracker::dummyWorld() const
+    {
+        return _dummyWorld;
+    }
+
+    void TestTracker::setListener( TestListener *l )
+    {
+        _l = l ? l : &_dummyListener;
+    }
+
+    void TestTracker::enterWorld( const WorldDescription &wd )
+    {
+        setWorld( &wd );
+        _warnings = _failedTests = _testFailedAsserts = _suiteFailedTests = _failedSuites = 0;
+        _l->enterWorld( wd );
+    }
+
+    void TestTracker::enterSuite( const SuiteDescription &sd )
+    {
+        setSuite( &sd );
+        _testFailedAsserts = _suiteFailedTests = 0;
+        _l->enterSuite(sd);
+    }
+        
+    void TestTracker::enterTest( const TestDescription &td )
+    {
+        setTest( &td );
+        _testFailedAsserts = false;
+        _l->enterTest(td);
+    }
+
+    void TestTracker::leaveTest( const TestDescription &td )
+    {
+        _l->leaveTest( td );
+        setTest( 0 );
+    }
+
+    void TestTracker::leaveSuite( const SuiteDescription &sd )
+    {
+        _l->leaveSuite( sd );
+        setSuite( 0 );
+    }
+
+    void TestTracker::leaveWorld( const WorldDescription &wd )
+    {
+        _l->leaveWorld( wd );
+        setWorld( 0 );
+    }
+
+    void TestTracker::trace( const char *file, unsigned line, const char *expression )
+    {
+        _l->trace( file, line, expression );
+    }
+
+    void TestTracker::warning( const char *file, unsigned line, const char *expression )
+    {
+        countWarning();
+        _l->warning( file, line, expression );
+    }
+
+    void TestTracker::failedTest( const char *file, unsigned line, const char *expression )
+    {
+        countFailure();
+        _l->failedTest( file, line, expression );
+    }
+        
+    void TestTracker::failedAssert( const char *file, unsigned line, const char *expression )
+    {
+        countFailure();
+        _l->failedAssert( file, line, expression );
+    }
+
+    void TestTracker::failedAssertEquals( const char *file, unsigned line,
+                                          const char *xStr, const char *yStr,
+                                          const char *x, const char *y )
+    {
+        countFailure();
+        _l->failedAssertEquals( file, line, xStr, yStr, x, y );
+    }
+
+    void TestTracker::failedAssertSameData( const char *file, unsigned line,
+                                            const char *xStr, const char *yStr,
+                                            const char *sizeStr, const void *x,
+                                            const void *y, unsigned size )
+    {
+        countFailure();
+        _l->failedAssertSameData( file, line, xStr, yStr, sizeStr, x, y, size );
+    }
+
+    void TestTracker::failedAssertDelta( const char *file, unsigned line,
+                                         const char *xStr, const char *yStr, const char *dStr,
+                                         const char *x, const char *y, const char *d )
+    {
+        countFailure();
+        _l->failedAssertDelta( file, line, xStr, yStr, dStr, x, y, d );
+    }
+    
+    void TestTracker::failedAssertDiffers( const char *file, unsigned line,
+                                           const char *xStr, const char *yStr,
+                                           const char *value )
+    {
+        countFailure();
+        _l->failedAssertDiffers( file, line, xStr, yStr, value );
+    }
+        
+    void TestTracker::failedAssertLessThan( const char *file, unsigned line,
+                                            const char *xStr, const char *yStr,
+                                            const char *x, const char *y )
+    {
+        countFailure();
+        _l->failedAssertLessThan( file, line, xStr, yStr, x, y );
+    }
+
+    void TestTracker::failedAssertLessThanEquals( const char *file, unsigned line,
+                                                  const char *xStr, const char *yStr,
+                                                  const char *x, const char *y )
+    {
+        countFailure();
+        _l->failedAssertLessThanEquals( file, line, xStr, yStr, x, y );
+    }
+
+    void TestTracker::failedAssertPredicate( const char *file, unsigned line,
+                                             const char *predicate, const char *xStr, const char *x )
+    {
+        countFailure();
+        _l->failedAssertPredicate( file, line, predicate, xStr, x );
+    }
+        
+    void TestTracker::failedAssertRelation( const char *file, unsigned line,
+                                            const char *relation, const char *xStr, const char *yStr,
+                                            const char *x, const char *y )
+    {
+        countFailure();
+        _l->failedAssertRelation( file, line, relation, xStr, yStr, x, y );
+    }
+        
+    void TestTracker::failedAssertThrows( const char *file, unsigned line,
+                                          const char *expression, const char *type,
+                                          bool otherThrown )
+    {
+        countFailure();
+        _l->failedAssertThrows( file, line, expression, type, otherThrown );
+    }
+        
+    void TestTracker::failedAssertThrowsNot( const char *file, unsigned line, const char *expression )
+    {
+        countFailure();
+        _l->failedAssertThrowsNot( file, line, expression );
+    }
+
+    void TestTracker::setWorld( const WorldDescription *w )
+    {
+        _world = fixWorld( w );
+        setSuite( 0 );
+    }
+
+    void TestTracker::setSuite( const SuiteDescription *s )
+    {
+        _suite = fixSuite( s );
+        setTest( 0 );
+    }
+
+    void TestTracker::setTest( const TestDescription *t )
+    {
+        _test = fixTest( t );
+    }
+
+    void TestTracker::countWarning()
+    {
+        ++ _warnings;
+    }
+
+    void TestTracker::countFailure()
+    {
+        if ( ++ _testFailedAsserts == 1 ) {
+            ++ _failedTests;
+            if ( ++ _suiteFailedTests == 1 )
+                ++ _failedSuites;
+        }
+    }
+};
+
+#endif // __cxxtest__TestTracker_cpp__
diff --git a/cxxtest/TestTracker.h b/cxxtest/TestTracker.h
new file mode 100644
index 0000000..c85abff
--- /dev/null
+++ b/cxxtest/TestTracker.h
@@ -0,0 +1,114 @@
+#ifndef __cxxtest__TestTracker_h__
+#define __cxxtest__TestTracker_h__
+
+//
+// The TestTracker tracks running tests
+// The actual work is done in CountingListenerProxy,
+// but this way avoids cyclic references TestListener<->CountingListenerProxy
+//
+
+#include <cxxtest/TestListener.h>
+#include <cxxtest/DummyDescriptions.h>
+
+namespace CxxTest
+{
+    class TestListener;
+    
+    class TestTracker : public TestListener
+    {
+    public:
+        virtual ~TestTracker();
+        
+        static TestTracker &tracker();
+
+        const TestDescription *fixTest( const TestDescription *d ) const;
+        const SuiteDescription *fixSuite( const SuiteDescription *d ) const;
+        const WorldDescription *fixWorld( const WorldDescription *d ) const;
+
+        const TestDescription &test() const { return *_test; }
+        const SuiteDescription &suite() const { return *_suite; }
+        const WorldDescription &world() const { return *_world; }
+        
+        bool testFailed() const { return (testFailedAsserts() > 0); }
+        bool suiteFailed() const { return (suiteFailedTests() > 0); }
+        bool worldFailed() const { return (failedSuites() > 0); }
+        
+        unsigned warnings() const { return _warnings; }
+        unsigned failedTests() const { return _failedTests; }
+        unsigned testFailedAsserts() const { return _testFailedAsserts; }
+        unsigned suiteFailedTests() const { return _suiteFailedTests; }
+        unsigned failedSuites() const { return _failedSuites; }
+
+        void enterWorld( const WorldDescription &wd );
+        void enterSuite( const SuiteDescription &sd );
+        void enterTest( const TestDescription &td );
+        void leaveTest( const TestDescription &td );
+        void leaveSuite( const SuiteDescription &sd );
+        void leaveWorld( const WorldDescription &wd );
+        void trace( const char *file, unsigned line, const char *expression );
+        void warning( const char *file, unsigned line, const char *expression );
+        void failedTest( const char *file, unsigned line, const char *expression );
+        void failedAssert( const char *file, unsigned line, const char *expression );
+        void failedAssertEquals( const char *file, unsigned line,
+                                 const char *xStr, const char *yStr,
+                                 const char *x, const char *y );
+        void failedAssertSameData( const char *file, unsigned line,
+                                   const char *xStr, const char *yStr,
+                                   const char *sizeStr, const void *x,
+                                   const void *y, unsigned size );
+        void failedAssertDelta( const char *file, unsigned line,
+                                const char *xStr, const char *yStr, const char *dStr,
+                                const char *x, const char *y, const char *d );
+        void failedAssertDiffers( const char *file, unsigned line,
+                                  const char *xStr, const char *yStr,
+                                  const char *value );
+        void failedAssertLessThan( const char *file, unsigned line,
+                                   const char *xStr, const char *yStr,
+                                   const char *x, const char *y );
+        void failedAssertLessThanEquals( const char *file, unsigned line,
+                                         const char *xStr, const char *yStr,
+                                         const char *x, const char *y );
+        void failedAssertPredicate( const char *file, unsigned line,
+                                    const char *predicate, const char *xStr, const char *x );
+        void failedAssertRelation( const char *file, unsigned line,
+                                   const char *relation, const char *xStr, const char *yStr,
+                                   const char *x, const char *y );
+        void failedAssertThrows( const char *file, unsigned line,
+                                 const char *expression, const char *type,
+                                 bool otherThrown );
+        void failedAssertThrowsNot( const char *file, unsigned line, const char *expression );
+        
+    private:
+        TestTracker( const TestTracker & );
+        TestTracker &operator=( const TestTracker & );
+
+        static bool _created;
+        TestListener _dummyListener;
+        DummyWorldDescription _dummyWorld;
+        unsigned _warnings, _failedTests, _testFailedAsserts, _suiteFailedTests, _failedSuites;
+        TestListener *_l;
+        const WorldDescription *_world;
+        const SuiteDescription *_suite;
+        const TestDescription *_test;
+
+        const TestDescription &dummyTest() const;
+        const SuiteDescription &dummySuite() const;
+        const WorldDescription &dummyWorld() const;
+        
+        void setWorld( const WorldDescription *w );
+        void setSuite( const SuiteDescription *s );
+        void setTest( const TestDescription *t );
+        void countWarning();
+        void countFailure();
+
+        friend class TestRunner;
+        
+        TestTracker();
+        void initialize();
+        void setListener( TestListener *l );
+    };
+
+    inline TestTracker &tracker() { return TestTracker::tracker(); }
+};
+
+#endif // __cxxtest__TestTracker_h__
diff --git a/cxxtest/ValueTraits.cpp b/cxxtest/ValueTraits.cpp
new file mode 100644
index 0000000..7d29ada
--- /dev/null
+++ b/cxxtest/ValueTraits.cpp
@@ -0,0 +1,140 @@
+#ifndef __cxxtest__ValueTraits_cpp__
+#define __cxxtest__ValueTraits_cpp__
+
+#include <cxxtest/ValueTraits.h>
+
+namespace CxxTest 
+{
+    //
+    // Non-inline functions from ValueTraits.h
+    //
+    
+    char digitToChar( unsigned digit )
+    {
+        if ( digit < 10 )
+            return (char)('0' + digit);
+        if ( digit <= 10 + 'Z' - 'A' )
+            return (char)('A' + digit - 10);
+        return '?';
+    }
+
+    const char *byteToHex( unsigned char byte )
+    {
+        static char asHex[3];
+        asHex[0] = digitToChar( byte >> 4 );
+        asHex[1] = digitToChar( byte & 0x0F );
+        asHex[2] = '\0';
+        return asHex;
+    }
+    
+    char *copyString( char *dst, const char *src )
+    {
+        while ( (*dst = *src) != '\0' ) {
+            ++ dst;
+            ++ src;
+        }
+        return dst;
+    }
+
+    bool stringsEqual( const char *s1, const char *s2 )
+    {
+        char c;
+        while ( (c = *s1++) == *s2++ )
+            if ( c == '\0' )
+                return true;
+        return false;
+    }
+
+    char *charToString( unsigned long c, char *s )
+    {
+        switch( c ) {
+        case '\\': return copyString( s, "\\\\" );
+        case '\"': return copyString( s, "\\\"" );
+        case '\'': return copyString( s, "\\\'" );
+        case '\0': return copyString( s, "\\0" );
+        case '\a': return copyString( s, "\\a" );
+        case '\b': return copyString( s, "\\b" );
+        case '\n': return copyString( s, "\\n" );
+        case '\r': return copyString( s, "\\r" );
+        case '\t': return copyString( s, "\\t" );
+        }
+        if ( c >= 32 && c <= 127 ) {
+            s[0] = (char)c;
+            s[1] = '\0';
+            return s + 1;
+        }
+        else {
+            s[0] = '\\';
+            s[1] = 'x';
+            if ( c < 0x10 ) {
+                s[2] = '0';
+                ++ s;
+            }
+            return numberToString( c, s + 2, 16UL );
+        }
+    }
+
+    char *charToString( char c, char *s )
+    {
+        return charToString( (unsigned long)(unsigned char)c, s );
+    }
+    
+    char *bytesToString( const unsigned char *bytes, unsigned numBytes, unsigned maxBytes, char *s )
+    {
+        bool truncate = (numBytes > maxBytes);
+        if ( truncate )
+            numBytes = maxBytes;
+        
+        s = copyString( s, "{ " );
+        for ( unsigned i = 0; i < numBytes; ++ i, ++ bytes )
+            s = copyString( copyString( s, byteToHex( *bytes ) ), " " );
+        if ( truncate )
+            s = copyString( s, "..." );
+        return copyString( s, " }" );
+    }
+
+#ifndef CXXTEST_USER_VALUE_TRAITS
+    unsigned ValueTraits<const double>::requiredDigitsOnLeft( double t )
+    {
+        unsigned digits = 1;
+        for ( t = (t < 0.0) ? -t : t; t > 1.0; t /= BASE )
+            ++ digits;
+        return digits;
+    }
+
+    char *ValueTraits<const double>::doNegative( double &t )
+    {
+        if ( t >= 0 )
+            return _asString;
+        _asString[0] = '-';
+        t = -t;
+        return _asString + 1;
+    }
+
+    void ValueTraits<const double>::hugeNumber( double t )
+    {
+        char *s = doNegative( t );
+        s = doubleToString( t, s, 0, 1 );
+        s = copyString( s, "." );
+        s = doubleToString( t, s, 1, DIGITS_ON_RIGHT );
+        s = copyString( s, "E" );
+        s = numberToString( requiredDigitsOnLeft( t ) - 1, s );
+    }
+        
+    void ValueTraits<const double>::normalNumber( double t )
+    {
+        char *s = doNegative( t );
+        s = doubleToString( t, s );
+        s = copyString( s, "." );
+        for ( unsigned i = 0; i < DIGITS_ON_RIGHT; ++ i )
+            s = numberToString( (unsigned)(t *= BASE) % BASE, s );
+    }
+
+    char *ValueTraits<const double>::doubleToString( double t, char *s, unsigned skip, unsigned max )
+    {
+        return numberToString<double>( t, s, BASE, skip, max );
+    }
+#endif // !CXXTEST_USER_VALUE_TRAITS
+};
+
+#endif // __cxxtest__ValueTraits_cpp__
diff --git a/cxxtest/ValueTraits.h b/cxxtest/ValueTraits.h
new file mode 100644
index 0000000..71145ad
--- /dev/null
+++ b/cxxtest/ValueTraits.h
@@ -0,0 +1,377 @@
+#ifndef __cxxtest__ValueTraits_h__
+#define __cxxtest__ValueTraits_h__
+
+//
+// ValueTraits are used by CxxTest to convert arbitrary
+// values used in TS_ASSERT_EQUALS() to a string representation.
+// 
+// This header file contains value traits for builtin integral types.
+// To declare value traits for new types you should instantiate the class
+// ValueTraits<YourClass>.
+//
+
+#include <cxxtest/Flags.h>
+
+#ifdef _CXXTEST_OLD_TEMPLATE_SYNTAX
+#   define CXXTEST_TEMPLATE_INSTANTIATION
+#else // !_CXXTEST_OLD_TEMPLATE_SYNTAX
+#   define CXXTEST_TEMPLATE_INSTANTIATION template<>
+#endif // _CXXTEST_OLD_TEMPLATE_SYNTAX
+
+namespace CxxTest 
+{
+    //
+    // This is how we use the value traits
+    //
+#   define TS_AS_STRING(x) CxxTest::traits(x).asString()
+
+    //
+    // Char representation of a digit
+    //
+    char digitToChar( unsigned digit );
+
+    //
+    // Convert byte value to hex digits
+    // Returns pointer to internal buffer
+    //
+    const char *byteToHex( unsigned char byte );
+
+    //
+    // Convert byte values to string
+    // Returns one past the copied data
+    //
+    char *bytesToString( const unsigned char *bytes, unsigned numBytes, unsigned maxBytes, char *s );
+
+    //
+    // Copy a string.
+    // Returns one past the end of the destination string
+    // Remember -- we can't use the standard library!
+    //
+    char *copyString( char *dst, const char *src );
+
+    //
+    // Compare two strings.
+    // Remember -- we can't use the standard library!
+    //
+    bool stringsEqual( const char *s1, const char *s2 );
+
+    //
+    // Represent a character value as a string
+    // Returns one past the end of the string
+    // This will be the actual char if printable or '\xXXXX' otherwise
+    //
+    char *charToString( unsigned long c, char *s );
+
+    //
+    // Prevent problems with negative (signed char)s
+    //
+    char *charToString( char c, char *s );
+
+    //
+    // The default ValueTraits class dumps up to 8 bytes as hex values
+    //
+    template <class T>
+    class ValueTraits
+    {
+        enum { MAX_BYTES = 8 };
+        char _asString[sizeof("{ ") + sizeof("XX ") * MAX_BYTES + sizeof("... }")];
+        
+    public:
+        ValueTraits( const T &t ) { bytesToString( (const unsigned char *)&t, sizeof(T), MAX_BYTES, _asString ); }
+        const char *asString( void ) const { return _asString; }
+    };    
+
+    //
+    // traits( T t )
+    // Creates an object of type ValueTraits<T>
+    //
+    template <class T>
+    inline ValueTraits<T> traits( T t )
+    {
+        return ValueTraits<T>( t );
+    }
+
+    //
+    // You can duplicate the implementation of an existing ValueTraits
+    //
+#   define CXXTEST_COPY_TRAITS(CXXTEST_NEW_CLASS, CXXTEST_OLD_CLASS) \
+    CXXTEST_TEMPLATE_INSTANTIATION \
+    class ValueTraits< CXXTEST_NEW_CLASS > \
+    { \
+        ValueTraits< CXXTEST_OLD_CLASS > _old; \
+    public: \
+        ValueTraits( CXXTEST_NEW_CLASS n ) : _old( (CXXTEST_OLD_CLASS)n ) {} \
+        const char *asString( void ) const { return _old.asString(); } \
+    }
+
+    //
+    // Certain compilers need separate declarations for T and const T
+    //
+#   ifdef _CXXTEST_NO_COPY_CONST
+#       define CXXTEST_COPY_CONST_TRAITS(CXXTEST_CLASS)
+#   else // !_CXXTEST_NO_COPY_CONST
+#       define CXXTEST_COPY_CONST_TRAITS(CXXTEST_CLASS) CXXTEST_COPY_TRAITS(CXXTEST_CLASS, const CXXTEST_CLASS)
+#   endif // _CXXTEST_NO_COPY_CONST
+    
+    //
+    // Avoid compiler warnings about unsigned types always >= 0
+    //
+    template<class N> inline bool negative( N n ) { return n < 0; }
+    template<class N> inline N abs( N n ) { return negative(n) ? -n : n; }
+
+#   define CXXTEST_NON_NEGATIVE(Type) \
+    CXXTEST_TEMPLATE_INSTANTIATION \
+    inline bool negative<Type>( Type ) { return false; } \
+    CXXTEST_TEMPLATE_INSTANTIATION \
+    inline Type abs<Type>( Type value ) { return value; }
+
+    CXXTEST_NON_NEGATIVE( bool )
+    CXXTEST_NON_NEGATIVE( unsigned char )
+    CXXTEST_NON_NEGATIVE( unsigned short int )
+    CXXTEST_NON_NEGATIVE( unsigned int )
+    CXXTEST_NON_NEGATIVE( unsigned long int )
+#   ifdef _CXXTEST_LONGLONG
+    CXXTEST_NON_NEGATIVE( unsigned _CXXTEST_LONGLONG )
+#   endif // _CXXTEST_LONGLONG
+
+    //
+    // Represent (integral) number as a string
+    // Returns one past the end of the string
+    // Remember -- we can't use the standard library!
+    //
+    template<class N>
+    char *numberToString( N n, char *s,
+                          N base = 10,
+                          unsigned skipDigits = 0,
+                          unsigned maxDigits = (unsigned)-1 )
+    {
+        if ( negative(n) ) {
+            *s++ = '-';
+            n = abs(n);
+        }
+    
+        N digit = 1;
+        while ( digit <= (n / base) )
+            digit *= base;
+        N digitValue;
+        for ( ; digit >= 1 && skipDigits; n -= digit * digitValue, digit /= base, -- skipDigits )
+            digitValue = (unsigned)(n / digit);
+        for ( ; digit >= 1 && maxDigits; n -= digit * digitValue, digit /= base, -- maxDigits )
+            *s++ = digitToChar( (unsigned)(digitValue = (unsigned)(n / digit)) );
+
+        *s = '\0';
+        return s;
+    }
+
+    //
+    // All the specific ValueTraits follow.
+    // You can #define CXXTEST_USER_VALUE_TRAITS if you don't want them
+    //
+    
+#ifndef CXXTEST_USER_VALUE_TRAITS
+    //
+    // ValueTraits: const char * const &
+    // This is used for printing strings, as in TS_FAIL( "Message" )
+    //
+    CXXTEST_TEMPLATE_INSTANTIATION
+    class ValueTraits<const char * const &>
+    {
+        ValueTraits &operator=( const ValueTraits & );
+        const char *_asString;
+        
+    public:
+        ValueTraits( const char * const &value ) : _asString( value ) {}
+        ValueTraits( const ValueTraits &other ) : _asString( other._asString ) {}
+        const char *asString( void ) const { return _asString; }
+    };
+
+    CXXTEST_COPY_TRAITS( const char *, const char * const & );
+    CXXTEST_COPY_TRAITS( char *, const char * const & );
+
+    //
+    // ValueTraits: bool
+    //    
+    CXXTEST_TEMPLATE_INSTANTIATION
+    class ValueTraits<const bool>
+    {
+        bool _value;
+        
+    public:
+        ValueTraits( const bool value ) : _value( value ) {}
+        const char *asString( void ) const { return _value ? "true" : "false"; }
+    };
+
+    CXXTEST_COPY_CONST_TRAITS( bool );
+
+#   ifdef _CXXTEST_LONGLONG
+    //
+    // ValueTraits: signed long long
+    //
+    CXXTEST_TEMPLATE_INSTANTIATION
+    class ValueTraits<const signed _CXXTEST_LONGLONG>
+    {
+        typedef _CXXTEST_LONGLONG T;
+        char _asString[2 + 3 * sizeof(T)];
+    public:
+        ValueTraits( T t ) { numberToString<T>( t, _asString ); }
+        const char *asString( void ) const { return _asString; }
+    };
+
+    CXXTEST_COPY_CONST_TRAITS( signed _CXXTEST_LONGLONG );
+
+    //
+    // ValueTraits: unsigned long long
+    //
+    CXXTEST_TEMPLATE_INSTANTIATION
+    class ValueTraits<const unsigned _CXXTEST_LONGLONG>
+    {
+        typedef unsigned _CXXTEST_LONGLONG T;
+        char _asString[1 + 3 * sizeof(T)];
+    public:
+        ValueTraits( T t ) { numberToString<T>( t, _asString ); }
+        const char *asString( void ) const { return _asString; }
+    };
+
+    CXXTEST_COPY_CONST_TRAITS( unsigned _CXXTEST_LONGLONG );
+#   endif // _CXXTEST_LONGLONG
+
+    //
+    // ValueTraits: signed long
+    //
+    CXXTEST_TEMPLATE_INSTANTIATION
+    class ValueTraits<const signed long int>
+    {
+        typedef signed long int T;
+        char _asString[2 + 3 * sizeof(T)];
+    public:
+        ValueTraits( T t ) { numberToString<T>( t, _asString ); }
+        const char *asString( void ) const { return _asString; }
+    };
+
+    CXXTEST_COPY_CONST_TRAITS( signed long int );
+    
+    //
+    // ValueTraits: unsigned long
+    //
+    CXXTEST_TEMPLATE_INSTANTIATION
+    class ValueTraits<const unsigned long int>
+    {
+        typedef unsigned long int T;
+        char _asString[1 + 3 * sizeof(T)];
+    public:
+        ValueTraits( T t ) { numberToString<T>( t, _asString ); }
+        const char *asString( void ) const { return _asString; }
+    };
+
+    CXXTEST_COPY_CONST_TRAITS( unsigned long int );
+    
+    //
+    // All decimals are the same as the long version
+    //
+    
+    CXXTEST_COPY_TRAITS( const signed int, const signed long int );
+    CXXTEST_COPY_TRAITS( const unsigned int, const unsigned long int );
+    CXXTEST_COPY_TRAITS( const signed short int, const signed long int );
+    CXXTEST_COPY_TRAITS( const unsigned short int, const unsigned long int );
+    CXXTEST_COPY_TRAITS( const unsigned char, const unsigned long int );
+    
+    CXXTEST_COPY_CONST_TRAITS( signed int );
+    CXXTEST_COPY_CONST_TRAITS( unsigned int );
+    CXXTEST_COPY_CONST_TRAITS( signed short int );
+    CXXTEST_COPY_CONST_TRAITS( unsigned short int );
+    CXXTEST_COPY_CONST_TRAITS( unsigned char );
+
+    //
+    // ValueTraits: char
+    // Returns 'x' for printable chars, '\x??' for others
+    //
+    CXXTEST_TEMPLATE_INSTANTIATION
+    class ValueTraits<const char>
+    {
+        char _asString[sizeof("'\\xXX'")];
+    public:
+        ValueTraits( char c ) { copyString( charToString( c, copyString( _asString, "'" ) ), "'" ); }
+        const char *asString( void ) const { return _asString; }
+    };
+
+    CXXTEST_COPY_CONST_TRAITS( char );
+
+    //
+    // ValueTraits: signed char
+    // Same as char, some compilers need it
+    //
+    CXXTEST_COPY_TRAITS( const signed char, const char );
+    CXXTEST_COPY_CONST_TRAITS( signed char );
+
+    //
+    // ValueTraits: double
+    //
+    CXXTEST_TEMPLATE_INSTANTIATION
+    class ValueTraits<const double>
+    {
+    public:
+        ValueTraits( double t ) 
+        {
+            ( requiredDigitsOnLeft( t ) > MAX_DIGITS_ON_LEFT ) ?
+                hugeNumber( t ) :
+                normalNumber( t );
+        }
+
+        const char *asString( void ) const { return _asString; }
+        
+    private:
+        enum { MAX_DIGITS_ON_LEFT = 24, DIGITS_ON_RIGHT = 4, BASE = 10 };
+        char _asString[1 + MAX_DIGITS_ON_LEFT + 1 + DIGITS_ON_RIGHT + 1];
+
+        static unsigned requiredDigitsOnLeft( double t );
+        char *doNegative( double &t );
+        void hugeNumber( double t );
+        void normalNumber( double t );
+        char *doubleToString( double t, char *s, unsigned skip = 0, unsigned max = (unsigned)-1 );
+    };
+
+    CXXTEST_COPY_CONST_TRAITS( double );
+
+    //
+    // ValueTraits: float
+    //
+    CXXTEST_COPY_TRAITS( const float, const double );
+    CXXTEST_COPY_CONST_TRAITS( float );
+#endif // !CXXTEST_USER_VALUE_TRAITS
+};
+
+#ifdef _CXXTEST_HAVE_STD
+#   include <cxxtest/StdValueTraits.h>
+#endif // _CXXTEST_HAVE_STD
+
+//
+// CXXTEST_ENUM_TRAITS
+//
+#define CXXTEST_ENUM_TRAITS( TYPE, VALUES ) \
+    namespace CxxTest \
+    { \
+        CXXTEST_TEMPLATE_INSTANTIATION \
+        class ValueTraits<TYPE> \
+        { \
+            TYPE _value; \
+            char _fallback[sizeof("(" #TYPE ")") + 3 * sizeof(TYPE)]; \
+        public: \
+            ValueTraits( TYPE value ) { \
+                _value = value; \
+                numberToString<unsigned long int>( _value, copyString( _fallback, "(" #TYPE ")" ) ); \
+            } \
+            const char *asString( void ) const \
+            { \
+                switch ( _value ) \
+                { \
+                    VALUES \
+                    default: return _fallback; \
+                } \
+            } \
+        }; \
+    }
+
+#define CXXTEST_ENUM_MEMBER( MEMBER ) \
+    case MEMBER: return #MEMBER;
+
+#endif // __cxxtest__ValueTraits_h__
diff --git a/cxxtest/Win32Gui.h b/cxxtest/Win32Gui.h
new file mode 100644
index 0000000..6b3e758
--- /dev/null
+++ b/cxxtest/Win32Gui.h
@@ -0,0 +1,531 @@
+#ifndef __cxxtest__Win32Gui_h__
+#define __cxxtest__Win32Gui_h__
+
+//
+// The Win32Gui displays a simple progress bar using the Win32 API.
+//
+// It accepts the following command line options:
+//   -minimized    Start minimized, pop up on error
+//   -keep         Don't close the window at the end
+//   -title TITLE  Set the window caption
+//
+// If both -minimized and -keep are specified, GUI will only keep the
+// window if it's in focus.
+//
+// N.B. If you're wondering why this class doesn't use any standard
+// library or STL (<string> would have been nice) it's because it only
+// uses "straight" Win32 API.
+//
+
+#include <cxxtest/Gui.h>
+
+#include <windows.h>
+#include <commctrl.h>
+
+namespace CxxTest
+{
+    class Win32Gui : public GuiListener
+    {
+    public:
+        void enterGui( int &argc, char **argv )
+	{
+	    parseCommandLine( argc, argv );
+	}
+	
+        void enterWorld( const WorldDescription &wd )
+        {
+            getTotalTests( wd );
+            _testsDone = 0;
+            startGuiThread();
+        }
+
+	void guiEnterSuite( const char *suiteName )
+	{
+	    showSuiteName( suiteName );
+            reset( _suiteStart );
+	}
+
+        void guiEnterTest( const char *suiteName, const char *testName )
+        {
+            ++ _testsDone;
+            setTestCaption( suiteName, testName );
+            showTestName( testName );
+	    showTestsDone();
+            progressBarMessage( PBM_STEPIT );
+            reset( _testStart );
+        }
+
+        void yellowBar()
+        {
+	    setColor( 255, 255, 0 );
+            setIcon( IDI_WARNING );
+            getTotalTests();
+        }
+        
+        void redBar()
+        {
+            if ( _startMinimized )
+                showMainWindow( SW_SHOWNORMAL );
+	    setColor( 255, 0, 0 );
+	    setIcon( IDI_ERROR );
+            getTotalTests();
+        }
+
+        void leaveGui()
+        {
+            if ( keep() )
+            {
+                showSummary();
+                WaitForSingleObject( _gui, INFINITE );
+            }
+            DestroyWindow( _mainWindow );
+        }
+
+    private:
+        const char *_title;
+        bool _startMinimized, _keep;
+        HANDLE _gui;
+        WNDCLASSEX _windowClass;
+        HWND _mainWindow, _progressBar, _statusBar;
+        HANDLE _canStartTests;
+        unsigned _numTotalTests, _testsDone;
+        char _strTotalTests[WorldDescription::MAX_STRLEN_TOTAL_TESTS];
+        enum { 
+            STATUS_SUITE_NAME, STATUS_SUITE_TIME,
+            STATUS_TEST_NAME, STATUS_TEST_TIME,
+            STATUS_TESTS_DONE, STATUS_WORLD_TIME,
+            STATUS_TOTAL_PARTS 
+        };
+        int _statusWidths[STATUS_TOTAL_PARTS];
+        unsigned _statusOffsets[STATUS_TOTAL_PARTS];
+        unsigned _statusTotal;
+        char _statusTestsDone[sizeof("1000000000 of  (100%)") + WorldDescription::MAX_STRLEN_TOTAL_TESTS];
+        DWORD _worldStart, _suiteStart, _testStart;
+        char _timeString[sizeof("00:00:00")];
+
+        void parseCommandLine( int argc, char **argv )
+        {
+            _startMinimized = _keep = false;
+	    _title = argv[0];
+            
+            for ( int i = 1; i < argc; ++ i )
+            {
+                if ( !lstrcmpA( argv[i], "-minimized" ) )
+                    _startMinimized = true;
+                else if ( !lstrcmpA( argv[i], "-keep" ) )
+                    _keep = true;
+                else if ( !lstrcmpA( argv[i], "-title" ) && (i + 1 < argc) )
+                    _title = argv[++i];
+            }
+        }
+        
+        void getTotalTests()
+        {
+            getTotalTests( tracker().world() );
+        }
+
+        void getTotalTests( const WorldDescription &wd )
+        {
+            _numTotalTests = wd.numTotalTests();
+            wd.strTotalTests( _strTotalTests );
+        }
+
+        void startGuiThread()
+        {
+            _canStartTests = CreateEvent( NULL, TRUE, FALSE, NULL );
+			DWORD threadId;
+            _gui = CreateThread( NULL, 0, &(Win32Gui::guiThread), (LPVOID)this, 0, &threadId );
+            WaitForSingleObject( _canStartTests, INFINITE );
+        }
+
+        static DWORD WINAPI guiThread( LPVOID parameter )
+        {
+            ((Win32Gui *)parameter)->gui();
+            return 0;
+        }
+
+        void gui()
+        {
+            registerWindowClass();
+            createMainWindow();
+            initCommonControls();
+            createProgressBar();
+            createStatusBar();
+            centerMainWindow();
+            showMainWindow();
+            startTimer();
+            startTests();
+
+            messageLoop();
+        }
+
+        void registerWindowClass()
+        {
+            _windowClass.cbSize = sizeof(_windowClass);
+            _windowClass.style = CS_HREDRAW | CS_VREDRAW;
+            _windowClass.lpfnWndProc = &(Win32Gui::windowProcedure);
+            _windowClass.cbClsExtra = 0;
+            _windowClass.cbWndExtra = sizeof(LONG);
+            _windowClass.hInstance = (HINSTANCE)NULL;
+            _windowClass.hIcon = (HICON)NULL;
+            _windowClass.hCursor = (HCURSOR)NULL;
+            _windowClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
+            _windowClass.lpszMenuName = NULL;
+            _windowClass.lpszClassName = TEXT("CxxTest Window Class");
+            _windowClass.hIconSm = (HICON)NULL;
+
+            RegisterClassEx( &_windowClass );
+        }
+
+        void createMainWindow()
+        {
+            _mainWindow = createWindow( _windowClass.lpszClassName, WS_OVERLAPPEDWINDOW );
+        }
+
+        void initCommonControls()
+        {
+            HMODULE dll = LoadLibraryA( "comctl32.dll" );
+            if ( !dll )
+		return;
+		
+	    typedef void (WINAPI *FUNC)( void );
+	    FUNC func = (FUNC)GetProcAddress( dll, "InitCommonControls" );
+	    if ( !func )
+                return;
+
+	    func();
+        }
+
+        void createProgressBar()
+        {
+            _progressBar = createWindow( PROGRESS_CLASS, WS_CHILD | WS_VISIBLE | PBS_SMOOTH, _mainWindow );
+
+#ifdef PBM_SETRANGE32
+            progressBarMessage( PBM_SETRANGE32, 0, _numTotalTests );
+#else // No PBM_SETRANGE32, use PBM_SETRANGE
+	    progressBarMessage( PBM_SETRANGE, 0, MAKELPARAM( 0, (WORD)_numTotalTests ) );
+#endif // PBM_SETRANGE32
+            progressBarMessage( PBM_SETPOS, 0 );
+            progressBarMessage( PBM_SETSTEP, 1 );
+            greenBar();
+            UpdateWindow( _progressBar );
+        }
+
+        void createStatusBar()
+        {
+            _statusBar = createWindow( STATUSCLASSNAME, WS_CHILD | WS_VISIBLE, _mainWindow );
+            setRatios( 4, 1, 3, 1, 3, 1 );
+        }
+
+        void setRatios( unsigned suiteNameRatio, unsigned suiteTimeRatio,
+                        unsigned testNameRatio, unsigned testTimeRatio,
+                        unsigned testsDoneRatio, unsigned worldTimeRatio )
+        {
+            _statusTotal = 0;
+            _statusOffsets[STATUS_SUITE_NAME] = (_statusTotal += suiteNameRatio);
+            _statusOffsets[STATUS_SUITE_TIME] = (_statusTotal += suiteTimeRatio);
+            _statusOffsets[STATUS_TEST_NAME] = (_statusTotal += testNameRatio);
+            _statusOffsets[STATUS_TEST_TIME] = (_statusTotal += testTimeRatio);
+            _statusOffsets[STATUS_TESTS_DONE] = (_statusTotal += testsDoneRatio);
+            _statusOffsets[STATUS_WORLD_TIME] = (_statusTotal += worldTimeRatio);
+        }
+
+        HWND createWindow( LPCTSTR className, DWORD style, HWND parent = (HWND)NULL )
+        {
+            return CreateWindow( className, NULL, style, 0, 0, 0, 0, parent,
+                                 (HMENU)NULL, (HINSTANCE)NULL, (LPVOID)this );
+        }
+
+        void progressBarMessage( UINT message, WPARAM wParam = 0, LPARAM lParam = 0 )
+        {
+            SendMessage( _progressBar, message, wParam, lParam );
+        }
+
+        void centerMainWindow()
+        {
+            RECT screen;
+            getScreenArea( screen );
+
+            LONG screenWidth = screen.right - screen.left;
+            LONG screenHeight = screen.bottom - screen.top;
+
+            LONG xCenter = (screen.right + screen.left) / 2;
+            LONG yCenter = (screen.bottom + screen.top) / 2;
+
+            LONG windowWidth = (screenWidth * 4) / 5;
+            LONG windowHeight = screenHeight / 10;
+            LONG minimumHeight = 2 * (GetSystemMetrics( SM_CYCAPTION ) + GetSystemMetrics( SM_CYFRAME ));
+            if ( windowHeight < minimumHeight )
+                windowHeight = minimumHeight;
+
+            SetWindowPos( _mainWindow, HWND_TOP,
+                          xCenter - (windowWidth / 2), yCenter - (windowHeight / 2),
+                          windowWidth, windowHeight, 0 );
+        }
+
+        void getScreenArea( RECT &area )
+        {
+            if ( !getScreenAreaWithoutTaskbar( area ) )
+                getWholeScreenArea( area );
+        }
+
+        bool getScreenAreaWithoutTaskbar( RECT &area )
+        {
+            return (SystemParametersInfo( SPI_GETWORKAREA, sizeof(RECT), &area, 0 ) != 0);
+        }
+
+        void getWholeScreenArea( RECT &area )
+        {
+            area.left = area.top = 0;
+            area.right = GetSystemMetrics( SM_CXSCREEN );
+            area.bottom = GetSystemMetrics( SM_CYSCREEN );
+        }
+
+        void showMainWindow()
+        {
+            showMainWindow( _startMinimized ? SW_MINIMIZE : SW_SHOWNORMAL );
+            UpdateWindow( _mainWindow );
+        }
+
+        void showMainWindow( int mode )
+        {
+            ShowWindow( _mainWindow, mode );
+        }
+
+        enum { TIMER_ID = 1, TIMER_DELAY = 1000 };
+
+        void startTimer()
+        {
+            reset( _worldStart );
+            reset( _suiteStart );
+            reset( _testStart );
+            SetTimer( _mainWindow, TIMER_ID, TIMER_DELAY, 0 );
+        }
+
+        void reset( DWORD &tick )
+        {
+            tick = GetTickCount();
+        }
+
+        void startTests()
+        {
+            SetEvent( _canStartTests );
+        }
+
+        void messageLoop()
+        {
+            MSG message;
+            while ( BOOL haveMessage = GetMessage( &message, NULL, 0, 0 ) )
+                if ( haveMessage != -1 )
+                    DispatchMessage( &message );
+        }
+
+        static LRESULT CALLBACK windowProcedure( HWND window, UINT message, WPARAM wParam, LPARAM lParam )
+        {
+            if ( message == WM_CREATE )
+                setUp( window, (LPCREATESTRUCT)lParam );
+
+            Win32Gui *that = (Win32Gui *)GetWindowLong( window, GWL_USERDATA );
+            return that->handle( window, message, wParam, lParam );
+        }
+
+        static void setUp( HWND window, LPCREATESTRUCT create )
+        {
+            SetWindowLong( window, GWL_USERDATA, (LONG)create->lpCreateParams );
+        }
+
+        LRESULT handle( HWND window, UINT message, WPARAM wParam, LPARAM lParam )
+        {
+            switch ( message )
+            {
+            case WM_SIZE: resizeControls(); break;
+
+            case WM_TIMER: updateTime(); break;
+
+            case WM_CLOSE:
+            case WM_DESTROY:
+            case WM_QUIT:
+                ExitProcess( 0 );
+
+            default: return DefWindowProc( window, message, wParam, lParam );
+            }
+            return 0;
+        }
+
+        void resizeControls()
+        {
+            RECT r;
+            GetClientRect( _mainWindow, &r );
+            LONG width = r.right - r.left;
+            LONG height = r.bottom - r.top;
+
+            GetClientRect( _statusBar, &r );
+            LONG statusHeight = r.bottom - r.top;
+            LONG resizeGripWidth = statusHeight;
+            LONG progressHeight = height - statusHeight;
+
+            SetWindowPos( _progressBar, HWND_TOP, 0, 0, width, progressHeight, 0 );
+            SetWindowPos( _statusBar, HWND_TOP, 0, progressHeight, width, statusHeight, 0 );
+            setStatusParts( width - resizeGripWidth );
+        }
+
+        void setStatusParts( LONG width )
+        {
+            for ( unsigned i = 0; i < STATUS_TOTAL_PARTS; ++ i )
+                _statusWidths[i] = (width * _statusOffsets[i]) / _statusTotal;
+
+            statusBarMessage( SB_SETPARTS, STATUS_TOTAL_PARTS, _statusWidths );
+        }
+
+        void statusBarMessage( UINT message, WPARAM wParam = 0, const void *lParam = 0 )
+        {
+            SendMessage( _statusBar, message, wParam, (LPARAM)lParam );
+        }
+
+        void greenBar()
+        {
+            setColor( 0, 255, 0 );
+            setIcon( IDI_INFORMATION );
+        }
+
+#ifdef PBM_SETBARCOLOR
+        void setColor( BYTE red, BYTE green, BYTE blue )
+        {
+            progressBarMessage( PBM_SETBARCOLOR, 0, RGB( red, green, blue ) );
+        }
+#else // !PBM_SETBARCOLOR
+        void setColor( BYTE, BYTE, BYTE ) 
+        {
+        }
+#endif // PBM_SETBARCOLOR
+
+        void setIcon( LPCTSTR icon )
+        {
+            SendMessage( _mainWindow, WM_SETICON, ICON_BIG, (LPARAM)loadStandardIcon( icon ) );
+        }
+
+        HICON loadStandardIcon( LPCTSTR icon )
+        {
+            return LoadIcon( (HINSTANCE)NULL, icon );
+        }
+
+        void setTestCaption( const char *suiteName, const char *testName )
+        {
+            setCaption( suiteName, "::", testName, "()" );
+        }
+
+        void setCaption( const char *a = "", const char *b = "", const char *c = "", const char *d = "" )
+        {
+            unsigned length = lstrlenA( _title ) + sizeof( " - " ) +
+                lstrlenA( a ) + lstrlenA( b ) + lstrlenA( c ) + lstrlenA( d );
+            char *name = allocate( length );
+            lstrcpyA( name, _title );
+            lstrcatA( name, " - " );
+            lstrcatA( name, a );
+            lstrcatA( name, b );
+            lstrcatA( name, c );
+            lstrcatA( name, d );
+            SetWindowTextA( _mainWindow, name );
+            deallocate( name );
+        }
+
+        void showSuiteName( const char *suiteName )
+        {
+            setStatusPart( STATUS_SUITE_NAME, suiteName );
+	}
+
+	void showTestName( const char *testName )
+	{
+            setStatusPart( STATUS_TEST_NAME, testName );
+	}
+
+	void showTestsDone()
+	{
+            wsprintfA( _statusTestsDone, "%u of %s (%u%%)",
+                       _testsDone, _strTotalTests,
+                       (_testsDone * 100) / _numTotalTests );
+            setStatusPart( STATUS_TESTS_DONE, _statusTestsDone );
+        }
+
+        void updateTime()
+        {
+            setStatusTime( STATUS_WORLD_TIME, _worldStart );
+            setStatusTime( STATUS_SUITE_TIME, _suiteStart );
+            setStatusTime( STATUS_TEST_TIME, _testStart );
+        }
+
+        void setStatusTime( unsigned part, DWORD start )
+        {
+            unsigned total = (GetTickCount() - start) / 1000;
+            unsigned hours = total / 3600;
+            unsigned minutes = (total / 60) % 60;
+            unsigned seconds = total % 60;
+
+            if ( hours )
+                wsprintfA( _timeString, "%u:%02u:%02u", hours, minutes, seconds );
+            else
+                wsprintfA( _timeString, "%02u:%02u", minutes, seconds );
+
+            setStatusPart( part, _timeString );
+        }
+
+        bool keep()
+        {
+            if ( !_keep )
+                return false;
+            if ( !_startMinimized )
+                return true;
+            return (_mainWindow == GetForegroundWindow());
+        }
+
+        void showSummary()
+        {
+            stopTimer();
+            setSummaryStatusBar();
+            setSummaryCaption();
+        }
+
+        void setStatusPart( unsigned part, const char *text )
+        {
+            statusBarMessage( SB_SETTEXTA, part, text );
+        }
+
+        void stopTimer()
+        {
+            KillTimer( _mainWindow, TIMER_ID );
+            setStatusTime( STATUS_WORLD_TIME, _worldStart );
+        }
+
+        void setSummaryStatusBar()
+        {
+            setRatios( 0, 0, 0, 0, 1, 1 );
+            resizeControls();
+        
+            const char *tests = (_numTotalTests == 1) ? "test" : "tests";
+            if ( tracker().failedTests() )
+                wsprintfA( _statusTestsDone, "Failed %u of %s %s",
+                          tracker().failedTests(), _strTotalTests, tests );
+            else
+                wsprintfA( _statusTestsDone, "%s %s passed", _strTotalTests, tests );
+
+            setStatusPart( STATUS_TESTS_DONE, _statusTestsDone );
+        }
+
+        void setSummaryCaption()
+        {
+            setCaption( _statusTestsDone );
+        }
+
+        char *allocate( unsigned length )
+        {
+            return (char *)HeapAlloc( GetProcessHeap(), 0, length );
+        }
+
+        void deallocate( char *data )
+        {
+            HeapFree( GetProcessHeap(), 0, data );
+        }
+    };
+};
+
+#endif // __cxxtest__Win32Gui_h__
diff --git a/cxxtest/X11Gui.h b/cxxtest/X11Gui.h
new file mode 100644
index 0000000..f14431d
--- /dev/null
+++ b/cxxtest/X11Gui.h
@@ -0,0 +1,327 @@
+#ifndef __cxxtest__X11Gui_h__
+#define __cxxtest__X11Gui_h__
+
+//
+// X11Gui displays a simple progress bar using X11
+// 
+// It accepts the following command-line arguments:
+//  -title <title>              - Sets the application title
+//  -fn or -font <font>         - Sets the font
+//  -bg or -background <color>  - Sets the background color (default=Grey)
+//  -fg or -foreground <color>  - Sets the text color (default=Black)
+//  -green/-yellow/-red <color> - Sets the colors of the bar
+//
+
+#include <cxxtest/Gui.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+namespace CxxTest
+{
+    class X11Gui : public GuiListener
+    {
+    public:
+        void enterGui( int &argc, char **argv )
+        {
+            parseCommandLine( argc, argv );
+        }
+        
+        void enterWorld( const WorldDescription &wd )
+        {
+            openDisplay();
+            if ( _display ) {
+                createColors();
+                createWindow();
+                createGc();
+                createFont();
+                centerWindow();
+                initializeEvents();
+                initializeBar( wd );
+                processEvents();
+            }
+        }
+        
+        void guiEnterTest( const char *suiteName, const char *testName )
+        {
+            if ( _display ) {
+                ++ _testsDone;
+                setWindowName( suiteName, testName );
+                redraw();
+            }
+        }
+        
+        void yellowBar()
+        {
+            if ( _display ) {
+                _barColor = getColor( _yellowName );
+                getTotalTests();
+                processEvents();
+            }
+        }
+
+        void redBar()
+        {
+            if ( _display ) {
+                _barColor = getColor( _redName );
+                getTotalTests();
+                processEvents();
+            }
+        }
+
+        void leaveGui()
+        {
+            if ( _display ) {
+                freeFontInfo();
+                destroyGc();
+                destroyWindow();
+                closeDisplay();
+            }
+        }
+
+    private:
+        const char *_programName;
+        Display *_display;
+        Window _window;
+        unsigned _numTotalTests, _testsDone;
+        char _strTotalTests[WorldDescription::MAX_STRLEN_TOTAL_TESTS];
+        const char *_foregroundName, *_backgroundName;
+        const char *_greenName, *_yellowName, *_redName;
+        unsigned long _foreground, _background, _barColor;
+        int _width, _height;
+        GC _gc;
+        const char *_fontName;
+        XID _fontId;
+        XFontStruct *_fontInfo;
+        int _textHeight, _textDescent;
+        long _eventMask;
+        Colormap _colormap;
+
+        void parseCommandLine( int &argc, char **argv )
+        {
+            _programName = argv[0];
+
+            _fontName = 0;
+            _foregroundName = "Black";
+            _backgroundName = "Grey";
+            _greenName = "Green";
+            _yellowName = "Yellow";
+            _redName = "Red";
+
+            for ( int i = 1; i + 1 < argc; ++ i ) {
+                if ( !strcmp( argv[i], "-title" ) )
+                    _programName = argv[++ i];
+                else if ( !strcmp( argv[i], "-fn" ) || !strcmp( argv[i], "-font" ) )
+                    _fontName = argv[++ i];
+                else if ( !strcmp( argv[i], "-fg" ) || !strcmp( argv[i], "-foreground" ) )
+                    _foregroundName = argv[++ i];
+                else if ( !strcmp( argv[i], "-bg" ) || !strcmp( argv[i], "-background" ) )
+                    _backgroundName = argv[++ i];
+                else if ( !strcmp( argv[i], "-green" ) )
+                    _greenName = argv[++ i];
+                else if ( !strcmp( argv[i], "-yellow" ) )
+                    _yellowName = argv[++ i];
+                else if ( !strcmp( argv[i], "-red" ) )
+                    _redName = argv[++ i];
+            }
+        }
+
+        void openDisplay()
+        {
+            _display = XOpenDisplay( NULL );
+        }
+
+        void createColors()
+        {
+            _colormap = DefaultColormap( _display, 0 );
+            _foreground = getColor( _foregroundName );
+            _background = getColor( _backgroundName );
+        }
+
+        unsigned long getColor( const char *colorName )
+        {
+            XColor color;
+            XParseColor( _display, _colormap, colorName, &color );
+            XAllocColor( _display, _colormap, &color );
+            return color.pixel;
+        }
+        
+        void createWindow()
+        {
+            _window = XCreateSimpleWindow( _display, RootWindow( _display, 0 ), 0, 0, 1, 1, 0, 0, _background );
+        }
+
+        void createGc()
+        {
+            _gc = XCreateGC( _display, _window, 0, 0 );
+        }
+
+        void createFont()
+        {
+            if ( !loadFont() )
+                useDefaultFont();
+            getFontInfo();
+            _textHeight = _fontInfo->ascent + _fontInfo->descent;
+            _textDescent = _fontInfo->descent;
+        }
+
+        bool loadFont()
+        {
+            if ( !_fontName )
+                return false;
+            _fontId = XLoadFont( _display, _fontName );
+            return (XSetFont( _display, _gc, _fontId ) == Success);
+        }
+
+        void useDefaultFont()
+        {
+            _fontId = XGContextFromGC( _gc );
+        }
+
+        void getFontInfo()
+        {
+            _fontInfo = XQueryFont( _display, _fontId );
+        }
+
+        void freeFontInfo()
+        {
+            XFreeFontInfo( NULL, _fontInfo, 1 );
+        }
+
+        void initializeEvents()
+        {
+            _eventMask = ExposureMask;
+            XSelectInput( _display, _window, _eventMask );
+        }
+
+        void initializeBar( const WorldDescription &wd )
+        {
+            getTotalTests( wd );
+            _testsDone = 0;
+            _barColor = getColor( _greenName );
+        }
+
+        void getTotalTests()
+        {
+            getTotalTests( tracker().world() );
+        }
+
+        void getTotalTests( const WorldDescription &wd )
+        {
+            _numTotalTests = wd.numTotalTests();
+            wd.strTotalTests( _strTotalTests );
+        }
+
+        void centerWindow()
+        {
+            XMapWindow( _display, _window );
+            
+            Screen *screen = XDefaultScreenOfDisplay( _display );
+            int screenWidth = WidthOfScreen( screen );
+            int screenHeight = HeightOfScreen( screen );
+            int xCenter = screenWidth / 2;
+            int yCenter = screenHeight / 2;
+
+            _width = (screenWidth * 4) / 5;
+            _height = screenHeight / 14;
+            
+            XMoveResizeWindow( _display, _window, xCenter - (_width / 2), yCenter - (_height / 2), _width, _height );
+        }
+
+        void processEvents()
+        {
+            redraw();
+            
+            XEvent event;
+            while( XCheckMaskEvent( _display, _eventMask, &event ) )
+                redraw();
+        }
+
+        void setWindowName( const char *suiteName, const char *testName )
+        {
+            unsigned length = strlen( _programName ) + strlen( suiteName ) + strlen( testName ) + sizeof( " - ::()" );
+            char *name = (char *)malloc( length );
+            sprintf( name, "%s - %s::%s()", _programName, suiteName, testName );
+            XSetStandardProperties( _display, _window, name, 0, 0, 0, 0, 0 );
+            free( name );
+        }
+
+        void redraw()
+        {
+            getWindowSize();
+            drawSolidBar();
+            drawDividers();
+            drawPercentage();
+            flush();
+        }
+
+        void getWindowSize()
+        {
+            XWindowAttributes attributes;
+            XGetWindowAttributes( _display, _window, &attributes );
+            _width = attributes.width;
+            _height = attributes.height;
+        }
+
+        void drawSolidBar()
+        {
+            unsigned barWidth = (_width * _testsDone) / _numTotalTests;
+
+            XSetForeground( _display, _gc, _barColor );
+            XFillRectangle( _display, _window, _gc, 0, 0, barWidth, _height );
+
+            XSetForeground( _display, _gc, _background );
+            XFillRectangle( _display, _window, _gc, barWidth, 0, _width + 1 - barWidth, _height );
+        }
+
+        void drawDividers()
+        {
+            if(_width / _numTotalTests < 5)
+                return;
+            for ( unsigned i = 1; i < _testsDone; ++ i ) {
+                int x = (_width * i) / _numTotalTests;
+                XDrawLine( _display, _window, _gc, x, 0, x, _height);
+            }
+        }
+
+        void drawPercentage()
+        {
+            XSetForeground( _display, _gc, _foreground );
+            
+            char str[sizeof("1000000000 of ") + sizeof(_strTotalTests) + sizeof(" (100%)")];
+            sprintf( str, "%u of %s (%u%%)", _testsDone, _strTotalTests, (_testsDone * 100) / _numTotalTests );
+            unsigned len = strlen( str );
+
+            int textWidth = XTextWidth( _fontInfo, str, len );
+
+            XDrawString( _display, _window, _gc,
+                         (_width - textWidth) / 2, ((_height + _textHeight) / 2) - _textDescent,
+                         str, len );
+        }
+
+        void flush()
+        {
+            XFlush( _display );
+        }
+
+        void destroyGc()
+        {
+            XFreeGC( _display, _gc );
+        }
+
+        void destroyWindow()
+        {
+            XDestroyWindow( _display, _window );
+        }
+
+        void closeDisplay()
+        {
+            XCloseDisplay( _display );
+        }
+    };
+};
+
+#endif //__cxxtest__X11Gui_h__
diff --git a/cxxtest/YesNoRunner.h b/cxxtest/YesNoRunner.h
new file mode 100644
index 0000000..e7b83b6
--- /dev/null
+++ b/cxxtest/YesNoRunner.h
@@ -0,0 +1,29 @@
+#ifndef __cxxtest__YesNoRunner_h__
+#define __cxxtest__YesNoRunner_h__
+
+//
+// The YesNoRunner is a simple TestListener that
+// just returns true iff all tests passed.
+//
+
+#include <cxxtest/TestRunner.h>
+#include <cxxtest/TestListener.h>
+
+namespace CxxTest 
+{
+    class YesNoRunner : public TestListener
+    {
+    public:
+        YesNoRunner()
+        {
+        }
+        
+        int run()
+        {
+            TestRunner::runAllTests( *this );
+            return tracker().failedTests();
+        }
+    };
+}
+
+#endif // __cxxtest__YesNoRunner_h__