14 files changed, 635 insertions, 97 deletions

diff --git a/include/cppunit/Makefile.am b/include/cppunit/Makefile.am
index 01e0019..803f725 100644
--- a/include/cppunit/Makefile.am
+++ b/include/cppunit/Makefile.am
@@ -19,12 +19,17 @@ libcppunitinclude_HEADERS =  \
 	TestAssert.h \
 	TestCase.h \
 	TestCaller.h \
+	TestComposite.h \
 	TestFailure.h \
 	TestFixture.h \
+	TestLeaf.h \
+	TestPath.h \
 	TestResult.h \
 	TestResultCollector.h \
+	TestRunner.h \
 	TestSucessListener.h \
 	TestSuite.h \
+	TestTest.h \
 	TextOutputter.h \
 	TextTestProgressListener.h \
 	TextTestResult.h \
diff --git a/include/cppunit/Test.h b/include/cppunit/Test.h
index 2ee2a48..dde4958 100644
--- a/include/cppunit/Test.h
+++ b/include/cppunit/Test.h
@@ -7,6 +7,7 @@
 namespace CppUnit {
 
 class TestResult;
+class TestPath;
 
 /*! \brief Base class for all test objects.
  * \ingroup BrowsingCollectedTestResult
@@ -23,37 +24,85 @@ class TestResult;
 class CPPUNIT_API Test
 {
 public:
-    virtual                       ~Test () {};
-
-    /*! \brief Run the test, collecting results.
-     */
-    virtual void                  run (TestResult *result)    = 0;
-
-    /*! \brief Return the number of test cases invoked by run().
-     *
-     * The base unit of testing is the class TestCase.  This
-     * method returns the number of TestCase objects invoked by
-     * the run() method.
-     */
-    virtual int                   countTestCases () const     = 0;
-
-    /*! \brief Returns the test name.
-     * 
-     * Each test has a name.  This name may be used to find the
-     * test in a suite or registry of tests.
-     */
-    virtual std::string           getName () const            = 0;
-
-    /*! \brief Description of the test, for diagnostic output.
-     *
-     * The test description will typically include the test name,
-     * but may have additional description.  For example, a test
-     * suite named <tt>complex_add</tt> may be described as 
-     * <tt>suite complex_add</tt>.
-     */
-    virtual std::string           toString () const           = 0;
+  virtual ~Test() {};
 
+  /*! \brief Run the test, collecting results.
+   */
+  virtual void run( TestResult *result ) =0;
 
+  /*! \brief Return the number of test cases invoked by run().
+   *
+   * The base unit of testing is the class TestCase.  This
+   * method returns the number of TestCase objects invoked by
+   * the run() method.
+   */
+  virtual int countTestCases () const =0;
+
+  /*! \brief Returns the number of direct child of the test.
+   */
+  virtual int getChildTestCount() const =0;
+
+  /*! \brief Returns the test name.
+   * 
+   * Each test has a name.  This name may be used to find the
+   * test in a suite or registry of tests.
+   */
+  virtual std::string getName () const =0;
+
+  /*! \brief Returns the child test of the specified index.
+   *
+   * This method test if the index is valid, then call doGetChildTestAt() if 
+   * the index is valid. Otherwise std::out_of_range exception is thrown.
+   *
+   * You should override doGetChildTestAt() method.
+   * 
+   * \param index Zero based index of the child test to return.
+   * \return Pointer on the test. Never \c NULL.
+   * \exception std::out_of_range is \a index is < 0 or >= getChildTestCount().
+   */
+  virtual Test *getChildTestAt( int index ) const;
+
+  /*! \brief Finds the test with the specified name and its parents test.
+   * \param testName Name of the test to find.
+   * \return \c true if a test with the specified name is found, \c false otherwise.
+   */
+  virtual bool findTestPath( const std::string &testName,
+                             TestPath &testPath );
+
+  /*! \brief Finds the specified test and its parents test.
+   * \param test Test to find.
+   * \return \c true if the specified test is found, \c false otherwise.
+   */
+  virtual bool findTestPath( const Test *test,
+                             TestPath &testPath );
+
+  /*! \brief Finds the test with the specified name in the hierarchy.
+   * \param testName Name of the test to find.
+   * \return Pointer on the first test found that is named \a testName. Never \c NULL.
+   * \exception std::invalid_argument if no test named \a testName is found.
+   */
+  virtual Test *findTest( const std::string &testName ) const;
+
+  /*! \brief Resolved the specified test path with this test acting as 'root'.
+   * \param testPath Test path string to resolve.
+   * \return Resolved TestPath. 
+   * \exception std::invalid_argument if \a testPath could not be resolved.
+   * \see TestPath.
+   */
+  virtual TestPath resolveTestPath( const std::string &testPath );
+
+protected:
+  /*! Throws an exception if the specified index is invalid.
+   * \param Zero base index of a child test.
+   * \exception std::out_of_range is \a index is < 0 or >= getChildTestCount().
+   */
+  virtual void checkIsValidIndex( int index ) const;
+
+  /*! \brief Returns the child test of the specified valid index.
+   * \param index Zero based valid index of the child test to return.
+   * \return Pointer on the test. Never \c NULL.
+   */
+  virtual Test *doGetChildTestAt( int index ) const =0;
 };
 
 
diff --git a/include/cppunit/TestCase.h b/include/cppunit/TestCase.h
index f9cb1d9..0d319dc 100644
--- a/include/cppunit/TestCase.h
+++ b/include/cppunit/TestCase.h
@@ -2,7 +2,7 @@
 #define CPPUNIT_TESTCASE_H
 
 #include <cppunit/Portability.h>
-#include <cppunit/Test.h>
+#include <cppunit/TestLeaf.h>
 #include <cppunit/TestAssert.h>
 #include <cppunit/TestFixture.h>
 #include <string>
@@ -23,30 +23,24 @@ class TestResult;
  * You are expected to subclass TestCase is you need to write a class similiar
  * to TestCaller.
  */
-class CPPUNIT_API TestCase : public Test,
+class CPPUNIT_API TestCase : public TestLeaf,
                              public TestFixture
 {
 public:
 
-    TestCase( std::string Name );
-    //! \internal
+    TestCase( const std::string &name );
+
     TestCase();
+
     ~TestCase();
     
     virtual void run(TestResult *result);
-    virtual int countTestCases() const;
+
     std::string getName() const;
-    std::string toString() const;
 
-    //! FIXME: what is this for?
-    virtual TestResult *run();
-    
 protected:
     //! FIXME: this should probably be pure virtual.
     virtual void runTest();
-
-    //! Create TestResult for the run(void) method.
-    TestResult *defaultResult();
     
 private:
     TestCase( const TestCase &other ); 
diff --git a/include/cppunit/TestComposite.h b/include/cppunit/TestComposite.h
new file mode 100644
index 0000000..7faeea8
--- /dev/null
+++ b/include/cppunit/TestComposite.h
@@ -0,0 +1,41 @@
+#ifndef CPPUNIT_TESTCOMPSITE_H    // -*- C++ -*-
+#define CPPUNIT_TESTCOMPSITE_H
+
+#include <cppunit/Test.h>
+#include <string>
+
+namespace CppUnit {
+
+
+/*! \brief A Composite of Tests.
+ *
+ * Base class for all test composites. Subclass this class if you need to implement
+ * a custom TestSuite.
+ * 
+ * \see Test, TestSuite.
+ */
+class CPPUNIT_API TestComposite : public Test
+{
+public:
+  TestComposite( const std::string &name = "" );
+
+  ~TestComposite();
+
+  void run( TestResult *result );
+
+  int countTestCases() const;
+  
+  std::string getName() const;
+
+private:
+  TestComposite( const TestComposite &other );
+  TestComposite &operator =( const TestComposite &other ); 
+
+private:
+  const std::string m_name;
+};
+
+
+} // namespace CppUnit
+
+#endif // CPPUNIT_TESTCOMPSITE_H
diff --git a/include/cppunit/TestFailure.h b/include/cppunit/TestFailure.h
index a610072..798d0c5 100644
--- a/include/cppunit/TestFailure.h
+++ b/include/cppunit/TestFailure.h
@@ -38,8 +38,6 @@ public:
   virtual bool isError() const;
 
   virtual std::string failedTestName() const;
-  
-  virtual std::string toString() const;
 
   virtual TestFailure *clone() const;
 
diff --git a/include/cppunit/TestLeaf.h b/include/cppunit/TestLeaf.h
new file mode 100644
index 0000000..393dda7
--- /dev/null
+++ b/include/cppunit/TestLeaf.h
@@ -0,0 +1,43 @@
+#ifndef CPPUNIT_TESTLEAF_H
+#define CPPUNIT_TESTLEAF_H
+
+#include <cppunit/Test.h>
+
+
+namespace CppUnit {
+
+/*! \brief A single test object.
+ *
+ * Base class for single test case: a test that doesn't have any children.
+ *
+ */
+class CPPUNIT_API TestLeaf: public Test
+{
+public:
+  /*! Returns 1 as the default number of test cases invoked by run().
+   * 
+   * You may override this method when many test cases are invoked (RepeatedTest
+   * for example).
+   * 
+   * \return 1.
+   * \see Test::countTestCases().
+   */
+  int countTestCases() const;
+
+  /*! Returns the number of child of this test case: 0.
+   *
+   * You should never override this method: a TestLeaf as no children by definition.
+   *
+   * \return 0.
+   */
+  int getChildTestCount() const;
+
+  /*! Always throws std::out_of_range.
+   * \see Test::doGetChildTestAt().
+   */
+  Test *doGetChildTestAt( int index ) const;
+};
+
+} // namespace CppUnit
+
+#endif // CPPUNIT_TESTLEAF_H
diff --git a/include/cppunit/TestListener.h b/include/cppunit/TestListener.h
index 595bcb7..2140fe4 100644
--- a/include/cppunit/TestListener.h
+++ b/include/cppunit/TestListener.h
@@ -25,6 +25,59 @@ class TestFailure;
  * unanticipated problems signified by exceptions that are not generated
  * by the framework.
  *
+ * \code
+ *
+ * #include <cppunit/TestListener.h>
+ * #include <cppunit/Test.h>
+ * #include <time.h>    // for clock()
+ *
+ * class TimingListener : public CppUnit::TestListener
+ * {
+ * public:
+ *   void startTest( CppUnit::Test *test )
+ *   {
+ *     _chronometer.start();
+ *   }
+ *  
+ *   void endTest( CppUnit::Test *test )
+ *   {
+ *     _chronometer.end();
+ *     addTest( test, _chronometer.elapsedTime() );
+ *   }
+ *
+ *   // ... (interface to add/read test timing result)
+ *
+ * private:
+ *
+ *   class Clock
+ *   {
+ *   public:
+ *     Clock() : _startTime( 0 ), _endTime(0) {}
+ * 
+ *     void start()
+ *     {
+ *       _startTime = clock();
+ *     }
+ * 
+ *     void end()
+ *     {
+ *       _endTime = clock();
+ *     }
+ *
+ *     double elapsedTime() const
+ *     {
+ *       return double(_endTime - _startTime) / CLOCKS_PER_SEC;
+ *     }
+ *  
+ *   private:
+ *     clock_t _startTime, _endTime;   
+ *   };
+ *
+ *   Clock _chronometer;
+ * };
+ *   
+ *
+ *
  * \see TestResult
  */
 class CPPUNIT_API TestListener
diff --git a/include/cppunit/TestPath.h b/include/cppunit/TestPath.h
new file mode 100644
index 0000000..02016ef
--- /dev/null
+++ b/include/cppunit/TestPath.h
@@ -0,0 +1,198 @@
+#ifndef CPPUNIT_TESTPATH_H
+#define CPPUNIT_TESTPATH_H
+
+#include <cppunit/Portability.h>
+
+#if CPPUNIT_NEED_DLL_DECL
+#pragma warning( push )
+#pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
+#endif
+
+#include <deque>
+
+namespace CppUnit {
+
+class Test;
+
+#if CPPUNIT_NEED_DLL_DECL
+  template class CPPUNIT_API std::deque<Test *>;
+#endif
+
+
+/*! \brief A List of Test representing a path to access a Test.
+ * \ingroup ExecutingTest
+ *
+ * The path can be converted to a string and resolved from a string with toString()
+ * and TestPath( Test *root, const std::string &pathAsString ).
+ *
+ * Pointed tests are not owned by the class.
+ *
+ * \see Test::resolvedTestPath()
+ */
+class CPPUNIT_API TestPath
+{
+public:
+  /*! Constructs an invalid path.
+   * 
+   * The path is invalid until a test is added with add().
+   */
+  TestPath();
+
+  /*! Constructs a valid path.
+   *
+   * \param root Test to add.
+   */
+  TestPath( Test *root );
+
+  /*! Constructs a path using a slice of another path.
+   * \param otherPath Path the test are copied from.
+   * \param indexFirst Zero based index of the first test to copy. Adjusted to be in valid
+   *                   range. \a count is adjusted with \a indexFirst.
+   * \param count Number of tests to copy. If < 0 then all test starting from index
+   *              \a indexFirst are copied.
+   */
+  TestPath( const TestPath &otherPath, 
+            int indexFirst, 
+            int count = -1 );
+
+  /*! Resolves a path from a string returned by toString().
+   *
+   * If \a pathAsString is an absolute path (begins with '/'), then the first test name
+   * of the path must be the name of \a searchRoot. Otherwise, \a pathAsString is a 
+   * relative path, and the first test found using Test::findTest() matching the first
+   * test name is used as root. An empty string resolve to a path containing 
+   * \a searchRoot.
+   *
+   * The resolved path is always valid.
+   *
+   * \param searchRoot Test used to resolve the path.
+   * \param pathAsString String that contains the path as a string created by toString().
+   * \exception std::invalid_argument if one of the test names can not be resolved.
+   * \see toString().
+   */
+  TestPath( Test *searchRoot, 
+            const std::string &pathAsString );
+
+  virtual ~TestPath();
+
+  /*! Tests if the path contains at least one test.
+   * \return \c true if the path contains at least one test, otherwise returns \c false.
+   */
+  virtual bool isValid() const;
+
+  /*! Adds a test to the path.
+   * \param test Pointer on the test to add. Must not be \c NULL.
+   */
+  virtual void add( Test *test );
+
+  /*! Adds all the tests of the specified path.
+   * \param path Path that contains the test to add.
+   */
+  virtual void add( const TestPath &path );
+
+  /*! Inserts a test at the specified index.
+   * \param test Pointer on the test to insert. Must not be \c NULL.
+   * \param index Zero based index indicating where the test is inserted.
+   * \exception std::out_of_range is \a index < 0 or \a index > getTestCount().
+   */
+  virtual void insert( Test *test, int index );
+
+  /*! Inserts all the tests at the specified path at a given index.
+   * \param path Path that contains the test to insert.
+   * \param index Zero based index indicating where the tests are inserted.
+   * \exception std::out_of_range is \a index < 0 or \a index > getTestCount(), and
+   *            \a path is valid.
+   */
+  virtual void insert( const TestPath &path, int index );
+
+  /*! Removes all the test from the path.
+   *
+   * The path becomes invalid after this call.
+   */
+  virtual void removeTests();
+
+  /*! Removes the test at the specified index of the path.
+   * \param index Zero based index of the test to remove.
+   * \exception std::out_of_range is \a index < 0 or \a index >= getTestCount().
+   */
+  virtual void removeTest( int index );
+
+  /*! Removes the last test.
+   * \exception std::out_of_range is the path is invalid.
+   * \see isValid().
+   */
+  virtual void up();
+
+  /*! Returns the number of tests in the path.
+   * \return Number of tests in the path.
+   */
+  virtual int getTestCount() const;
+
+  /*! Returns the test of the specified index.
+   * \param index Zero based index of the test to return.
+   * \return Pointer on the test at index \a index. Never \c NULL.
+   * \exception std::out_of_range is \a index < 0 or \a index >= getTestCount().
+   */
+  virtual Test *getTestAt( int index ) const;
+
+  /*! \brief Get the last test of the path.
+   * \return Pointer on the last test (test at the bottom of the hierarchy). Never \c NULL.
+   * \exception std::out_of_range if the path is not valid ( isValid() returns \c false ).
+   */
+  virtual Test *getChildTest() const;
+
+  /*! \brief Returns the path as a string.
+   *
+   * For example, if a path is composed of three tests named "All Tests", "Math" and
+   * "Math::testAdd", toString() will return:
+   *
+   * "All Tests/Math/Math::testAdd".
+   * 
+   * \return A string composed of the test names separated with a '/'. It is a relative
+   *         path.
+   */
+  virtual std::string toString() const;
+
+protected:
+  /*! Checks that the specified test index is within valid range.
+   * \param index Zero based index to check.
+   * \exception std::out_of_range is \a index < 0 or \a index >= getTestCount().
+   */
+  void checkIndexValid( int index ) const;
+
+  /// A list of test names.
+  typedef std::deque<std::string> PathTestNames;
+
+  /*! Splits a path string into its test name components.
+   * \param pathAsString Path string created with toString().
+   * \param testNames Test name components are added to that container.
+   * \return \c true if the path is relative (does not begin with '/'), \c false
+   *         if it is absolute (begin with '/').
+   */
+  bool splitPathString( const std::string &pathAsString,
+                        PathTestNames &testNames );
+
+  /*! Finds the actual root of a path string and get the path string name components.
+   * \param searchRoot Test used as root if the path string is absolute, or to search
+   *                   the root test if the path string is relative.
+   * \param pathAsString Path string. May be absolute or relative.
+   * \param testNames Test name components are added to that container.
+   * \return Pointer on the resolved root test. Never \c NULL.
+   * \exception std::invalid_argument if either the root name can not be resolved or if
+   *            pathAsString contains no name components.
+   */
+  Test *findActualRoot( Test *searchRoot,
+                        const std::string &pathAsString,
+                        PathTestNames &testNames );
+
+protected:
+  typedef std::deque<Test *> Tests;
+  Tests _tests;
+
+};
+
+
+} // namespace CppUnit
+
+#endif // CPPUNIT_TESTPATH_H
+
diff --git a/include/cppunit/TestRunner.h b/include/cppunit/TestRunner.h
new file mode 100644
index 0000000..7c7073e
--- /dev/null
+++ b/include/cppunit/TestRunner.h
@@ -0,0 +1,134 @@
+#ifndef CPPUNIT_TESTRUNNER_H
+#define CPPUNIT_TESTRUNNER_H
+
+#include <cppunit/TestSuite.h>
+#include <string>
+
+namespace CppUnit
+{
+
+class Test;
+class TestResult;
+
+
+/*! \brief Generic test runner.
+ * \ingroup ExecutingTest
+ *
+ * The TestRunner assumes ownership of all added tests: you can not add test
+ * or suite that are local variable since they can't be deleted.
+ *
+ * Example of usage:
+ * \code
+ * #include <cppunit/extensions/TestFactoryRegistry.h>
+ * #include <cppunit/CompilerOutputter.h>
+ * #include <cppunit/TestResult.h>
+ * #include <cppunit/TestResultCollector.h>
+ * #include <cppunit/TestRunner.h>
+ * #include <cppunit/TextTestProgressListener.h>
+ * 
+ * 
+ * int 
+ * main( int argc, char* argv[] )
+ * {
+ *   std::string testPath = (argc > 1) ? std::string(argv[1]) : "";
+ * 
+ *   // Create the event manager and test controller
+ *   CppUnit::TestResult controller;
+ * 
+ *   // Add a listener that colllects test result
+ *   CppUnit::TestResultCollector result;
+ *   controller.addListener( &result );        
+ * 
+ *   // Add a listener that print dots as test run.
+ *   CppUnit::TextTestProgressListener progress;
+ *   controller.addListener( &progress );      
+ * 
+ *   // Add the top suite to the test runner
+ *   CppUnit::TestRunner runner;
+ *   runner.addTest( CppUnit::TestFactoryRegistry::getRegistry().makeTest() );   
+ *   try
+ *   {
+ *     std::cout << "Running "  <<  testPath;
+ *     runner.run( controller, testPath );
+ * 
+ *     std::cerr << std::endl;
+ * 
+ *     // Print test in a compiler compatible format.
+ *     CppUnit::CompilerOutputter outputter( &result, std::cerr );
+ *     outputter.write();                      
+ *   }
+ *   catch ( std::invalid_argument &e )  // Test path not resolved
+ *   {
+ *     std::cerr  <<  std::endl  
+ *                <<  "ERROR: "  <<  e.what()
+ *                << std::endl;
+ *     return 0;
+ *   }
+ * 
+ *   return result.wasSuccessful() ? 0 : 1;
+ * }
+ * \endcode
+ */
+class CPPUNIT_API TestRunner
+{
+public:
+  /*! Constructs a TestRunner object.
+   */
+  TestRunner(  );
+
+  /// Destructor.
+  virtual ~TestRunner();
+
+  /*! Adds the specified test.
+   * \param test Test to add. The TestRunner takes ownership of the test.
+   */
+  virtual void addTest( Test *test );
+
+  /*! Runs a test using the specified controller.
+   * \param controller Event manager and controller used for testing
+   * \param testPath Test path string. See Test::resolveTestPath() for detail.
+   * \exception std::invalid_argument if no test matching \a testPath is found.
+   *                                  see TestPath::TestPath( Test*, const std::string &)
+   *                                  for detail.
+   */
+  virtual void run( TestResult &controller,
+                    const std::string &testPath = "" );
+
+protected:
+  class CPPUNIT_API WrappingSuite : public TestSuite
+  {
+  public:
+    WrappingSuite( const std::string &name = "All Tests" );
+
+    int getChildTestCount() const;
+
+    std::string getName () const;
+
+    void run( TestResult *result );
+
+  protected:
+    Test *doGetChildTestAt( int index ) const;
+
+    bool hasOnlyOneTest() const;
+
+    Test *getUniqueChildTest() const;
+  };
+
+protected:
+  WrappingSuite *m_suite;
+
+private:
+  /// Prevents the use of the copy constructor.
+  TestRunner( const TestRunner &copy );
+
+  /// Prevents the use of the copy operator.
+  void operator =( const TestRunner &copy );
+
+private:
+};
+
+
+} //  namespace CppUnit
+
+
+#endif  // CPPUNIT_TESTRUNNER_H
diff --git a/include/cppunit/TestSuite.h b/include/cppunit/TestSuite.h
index 3cd77cb..7fdafc9 100644
--- a/include/cppunit/TestSuite.h
+++ b/include/cppunit/TestSuite.h
@@ -8,14 +8,11 @@
 #pragma warning( disable: 4251 )  // X needs to have dll-interface to be used by clients of class Z
 #endif
 
-#include <cppunit/Test.h>
+#include <cppunit/TestComposite.h>
 #include <vector>
-#include <string>
 
 namespace CppUnit {
 
-class TestResult;
-
 #if CPPUNIT_NEED_DLL_DECL
   template class CPPUNIT_API std::vector<Test *>;
 #endif
@@ -32,34 +29,41 @@ class TestResult;
  * suite->addTest(new CppUnit::TestCaller<MathTest> (
  *                  "testDivideByZero", testDivideByZero));
  * \endcode
- * Note that TestSuites assume lifetime
+ * Note that \link TestSuite TestSuites assume lifetime
  * control for any tests added to them.
  *
  * TestSuites do not register themselves in the TestRegistry.
  * \see Test 
  * \see TestCaller
  */
-
-
-class CPPUNIT_API TestSuite : public Test
+class CPPUNIT_API TestSuite : public TestComposite
 {
 public:
+  /*! Constructs a test suite with the specified name.
+   */
   TestSuite( std::string name = "" );
-  ~TestSuite();
 
-  void run( TestResult *result );
-  int countTestCases() const;
-  std::string getName() const;
-  std::string toString() const;
+  ~TestSuite();
 
+  /*! Adds the specified test to the suite.
+   * \param test Test to add. Must not be \c NULL.
+    */
   void addTest( Test *test );
+
+  /*! Returns the list of the tests (DEPRECATED).
+   * \deprecated Use getChildTestCount() & getChildTestAt() of the 
+   *             TestComposite interface instead.
+   * \return Reference on a vector that contains the tests of the suite.
+   */
   const std::vector<Test *> &getTests() const;
 
+  /*! Destroys all the tests of the suite.
+   */
   virtual void deleteContents();
 
-private:
-  TestSuite( const TestSuite &other );
-  TestSuite &operator =( const TestSuite &other ); 
+  int getChildTestCount() const;
+
+  Test *doGetChildTestAt( int index ) const;
 
 private:
   std::vector<Test *> m_tests;
diff --git a/include/cppunit/XmlOutputter.h b/include/cppunit/XmlOutputter.h
index 80fbcee..e1b12f5 100644
--- a/include/cppunit/XmlOutputter.h
+++ b/include/cppunit/XmlOutputter.h
@@ -49,6 +49,13 @@ public:
    */
   virtual void write();
 
+  /*! Sets the XSL style sheet used.
+   *
+   * \param styleSheet Name of the style sheet used. If empty, then no style sheet
+   *                   is used (default).
+   */
+  virtual void setStyleSheet( const std::string &styleSheet );
+
   /*! \brief An XML Element.
    * \warning This class will probably be replaced with an abstract
    * builder in future version.
@@ -113,6 +120,7 @@ protected:
   TestResultCollector *m_result;
   std::ostream &m_stream;
   std::string m_encoding;
+  std::string m_styleSheet;
 
 private:
   /// Prevents the use of the copy constructor.
diff --git a/include/cppunit/extensions/RepeatedTest.h b/include/cppunit/extensions/RepeatedTest.h
index 067fd20..5db7dc2 100644
--- a/include/cppunit/extensions/RepeatedTest.h
+++ b/include/cppunit/extensions/RepeatedTest.h
@@ -17,20 +17,22 @@ class TestResult;
 class CPPUNIT_API RepeatedTest : public TestDecorator 
 {
 public:
-    RepeatedTest( Test *test, 
-                  int timesRepeat ) : 
-        TestDecorator( test ), 
-        m_timesRepeat(timesRepeat) {}
+  RepeatedTest( Test *test, 
+                int timesRepeat ) : 
+      TestDecorator( test ), 
+      m_timesRepeat(timesRepeat) 
+  {
+  }
 
-    void run( TestResult *result );
-    int countTestCases() const;
-    std::string toString() const;
+  void run( TestResult *result );
+
+  int countTestCases() const;
 
 private:
-    RepeatedTest( const RepeatedTest & );
-    void operator=( const RepeatedTest & );
+  RepeatedTest( const RepeatedTest & );
+  void operator=( const RepeatedTest & );
 
-    const int m_timesRepeat;
+  const int m_timesRepeat;
 };
 
 
diff --git a/include/cppunit/extensions/TestDecorator.h b/include/cppunit/extensions/TestDecorator.h
index c3dc343..9777540 100644
--- a/include/cppunit/extensions/TestDecorator.h
+++ b/include/cppunit/extensions/TestDecorator.h
@@ -2,7 +2,7 @@
 #define CPPUNIT_EXTENSIONS_TESTDECORATOR_H
 
 #include <cppunit/Portability.h>
-#include <cppunit/Test.h>
+#include <cppunit/TestLeaf.h>
 
 namespace CppUnit {
 
@@ -17,48 +17,57 @@ class TestResult;
  *
  * Does not assume ownership of the test it decorates
  */ 
-class CPPUNIT_API TestDecorator : public Test 
+class CPPUNIT_API TestDecorator : public TestLeaf
 {
 public:
-    TestDecorator   (Test *test);
-    ~TestDecorator  ();
+  TestDecorator( Test *test );
+  ~TestDecorator();
 
-    void        run             (TestResult *result);
-    int         countTestCases  () const;
-    std::string getName         () const;
-    std::string toString        () const;
+  int countTestCases() const;
+  std::string getName() const;
+  void run( TestResult *result );
 
 protected:
-    Test        *m_test;
+  Test *m_test;
 
 private:
-    TestDecorator( const TestDecorator &);
-    void operator =( const TestDecorator & );
+  TestDecorator( const TestDecorator &);
+  void operator =( const TestDecorator & );
 };
 
 
-inline TestDecorator::TestDecorator (Test *test)
-{ m_test = test; }
+inline 
+TestDecorator::TestDecorator( Test *test )
+{ 
+  m_test = test; 
+}
 
 
-inline TestDecorator::~TestDecorator ()
-{}
-
-
-inline int TestDecorator::countTestCases () const
-{ return m_test->countTestCases (); }
+inline 
+TestDecorator::~TestDecorator()
+{
+}
 
 
-inline void TestDecorator::run (TestResult *result)
-{ m_test->run (result); }
+inline int 
+TestDecorator::countTestCases() const
+{ 
+  return m_test->countTestCases(); 
+}
 
 
-inline std::string TestDecorator::toString () const
-{ return m_test->toString (); }
+inline void 
+TestDecorator::run( TestResult *result )
+{ 
+  m_test->run(result); 
+}
 
 
-inline std::string TestDecorator::getName () const
-{ return m_test->getName(); }
+inline std::string 
+TestDecorator::getName() const
+{ 
+  return m_test->getName(); 
+}
 
 } // namespace CppUnit
 
diff --git a/include/cppunit/ui/text/TestRunner.h b/include/cppunit/ui/text/TestRunner.h
index 6bfa6c9..7b4588f 100644
--- a/include/cppunit/ui/text/TestRunner.h
+++ b/include/cppunit/ui/text/TestRunner.h
@@ -1,5 +1,5 @@
-#ifndef CPPUNITUI_TEXT_TESTRUNNER_H
-#define CPPUNITUI_TEXT_TESTRUNNER_H
+#ifndef CPPUNIT_UI_TEXT_TESTRUNNER_H
+#define CPPUNIT_UI_TEXT_TESTRUNNER_H
 
 #include <cppunit/Portability.h>
 #include <string>
@@ -100,4 +100,4 @@ protected:
 
 } // namespace CppUnit
 
-#endif  // CPPUNITUI_TEXT_TESTRUNNER_H
+#endif  // CPPUNIT_UI_TEXT_TESTRUNNER_H