Include/cppunit/TestFailure.

include/cppunit/TestFailure.cpp :
* include/cppunit/TestFailure.h : fixed some constness issues. Added
argument to indicate the type of failure to constructor. Added
isError().

* include/cppunit/TestListener.h : removed addError(). addFailure()
now take a TestFailure as argument.

* include/cppunit/TestResult.h :
* include/cppunit/TestResult.cpp : removed errors(). Refactored. Fixed
some constness issues. Added typedef TestFailures for vector returned
by failures(). failures() returns a const reference on the list of
failure. added testFailuresTotal(). Constructor can take an optional
synchronization object.

* include/cppunit/TextTestResult.h :
* include/cppunit/TextTestResult.cpp : removed printErrors().
Refactored. Updated to suit new TestResult, errors and failures are
reported in the same list.

* examples/cppunittest/TestFailureTest.cpp :
* examples/cppunittest/TestFailureTest.h : modified to use the new
TestFailure constructor. Added one test.

* examples/cppunittest/TestListenerTest.cpp: removed addError().
Refactored to suit new TestListener.

* examples/cppunittest/TestResultTest.h :
* examples/cppunittest/TestResultTest.cpp : modified to suit the
new TestResult.

1 files changed, 92 insertions, 85 deletions

diff --git a/include/cppunit/TestResult.h b/include/cppunit/TestResult.h
index 75fe3ee..0a7ce58 100644
--- a/include/cppunit/TestResult.h
+++ b/include/cppunit/TestResult.h
@@ -6,93 +6,100 @@
 
 namespace CppUnit {
 
-  class Exception;
-  class Test;
-  class TestListener;
-
-
-  /**
-   * A TestResult collects the results of executing a test case. It is an 
-   * instance of the Collecting Parameter pattern.
-   *
-   * The test framework distinguishes between failures and errors.
-   * A failure is anticipated and checked for with assertions. Errors are
-   * unanticipated problems signified by exceptions that are not generated
-   * by the framework.
-   *
-   * TestResult supplies a template method 'setSynchronizationObject ()'
-   * so that subclasses can provide mutual exclusion in the face of multiple
-   * threads.  This can be useful when tests execute in one thread and
-   * they fill a subclass of TestResult which effects change in another 
-   * thread.  To have mutual exclusion, override setSynchronizationObject ()
-   * and make sure that you create an instance of ExclusiveZone at the 
-   * beginning of each method.
-   *
-   * \see Test
-   */
-
-  class TestResult
-  {
+class Exception;
+class Test;
+class TestListener;
+
+
+/**
+ * A TestResult collects the results of executing a test case. It is an 
+ * instance of the Collecting Parameter pattern.
+ *
+ * The test framework distinguishes between failures and errors.
+ * A failure is anticipated and checked for with assertions. Errors are
+ * unanticipated problems signified by exceptions that are not generated
+ * by the framework.
+ *
+ * TestResult supplies a template method 'setSynchronizationObject ()'
+ * so that subclasses can provide mutual exclusion in the face of multiple
+ * threads.  This can be useful when tests execute in one thread and
+ * they fill a subclass of TestResult which effects change in another 
+ * thread.  To have mutual exclusion, override setSynchronizationObject ()
+ * and make sure that you create an instance of ExclusiveZone at the 
+ * beginning of each method.
+ *
+ * \see Test
+ */
+
+class TestResult
+{
+  public:
+    typedef std::vector<TestFailure *> TestFailures;
+
+    class SynchronizationObject
+    {
+      public:
+        SynchronizationObject() {}
+        virtual ~SynchronizationObject() {}
+
+        virtual void lock() {}
+        virtual void unlock() {}
+    };
+
+    TestResult( SynchronizationObject *syncObject =0 );
+    virtual ~TestResult();
+
+    virtual void addError( Test *test, Exception *e );
+    virtual void addFailure( Test *test, Exception *e );
+    virtual void startTest( Test *test );
+    virtual void endTest( Test *test );
+    virtual int runTests() const;
+    virtual int testErrors() const;
+    virtual int testFailures() const;
+    virtual int testFailuresTotal() const;
+    virtual bool wasSuccessful() const;
+    virtual bool shouldStop() const;
+
+    virtual void stop();
+
+    virtual const TestFailures& failures() const;
+
+    virtual void addListener( TestListener *listener );
+    virtual void removeListener( TestListener *listener );
+
+
+    class ExclusiveZone
+    {
+      SynchronizationObject *m_syncObject;
 
     public:
-      TestResult  ();
-      virtual                             ~TestResult ();
-
-      virtual void                        addError       (Test *test, Exception *e);
-      virtual void                        addFailure     (Test *test, Exception *e);
-      virtual void                        startTest      (Test *test);
-      virtual void                        endTest        (Test *test);
-      virtual int                         runTests       ();
-      virtual int                         testErrors     ();
-      virtual int                         testFailures   ();
-      virtual bool                        wasSuccessful  ();
-      virtual bool                        shouldStop     ();
-      virtual void                        stop           ();
-
-      virtual std::vector<TestFailure *>& errors         ();
-      virtual std::vector<TestFailure *>& failures       ();
-
-      virtual void                        addListener    ( TestListener *listener );
-      virtual void                        removeListener ( TestListener *listener );
-
-
-      class SynchronizationObject
-      {
-        public:
-          SynchronizationObject  () {}
-          virtual                 ~SynchronizationObject () {}
-
-          virtual void            lock                   () {}
-          virtual void            unlock                 () {}
-      };
-
-      class ExclusiveZone
-      {
-          SynchronizationObject   *m_syncObject;
-
-        public:
-          ExclusiveZone (SynchronizationObject *syncObject) 
-            : m_syncObject (syncObject) 
-          { m_syncObject->lock (); }
-
-          ~ExclusiveZone () 
-          { m_syncObject->unlock (); }
-      };
-
-    protected:
-      virtual void                setSynchronizationObject (SynchronizationObject *syncObject);
-
-      std::vector<TestFailure *>  m_errors;
-      std::vector<TestFailure *>  m_failures;
-      std::vector<TestListener *> m_listeners;
-      int                         m_runTests;
-      bool                        m_stop;
-      SynchronizationObject       *m_syncObject;
-    private: 
-      TestResult (const TestResult& other); 
-      TestResult& operator= (const TestResult& other); 
-
-  };
+      ExclusiveZone( SynchronizationObject *syncObject ) 
+        : m_syncObject( syncObject ) 
+      { 
+        m_syncObject->lock(); 
+      }
+
+      ~ExclusiveZone() 
+      { 
+        m_syncObject->unlock (); 
+      }
+    };
+
+  protected:
+    virtual void setSynchronizationObject( SynchronizationObject *syncObject );
+    virtual void addFailure( TestFailure *failure );
+
+    TestFailures m_failures;
+    std::vector<TestListener *> m_listeners;
+    int m_runTests;
+    int m_testErrors;
+    bool m_stop;
+    SynchronizationObject *m_syncObject;
+
+  private: 
+    TestResult( const TestResult &other );
+    TestResult &operator =( const TestResult &other );
+};
 
 } // namespace CppUnit