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.

3 files changed, 209 insertions, 164 deletions

diff --git a/src/cppunit/TestFailure.cpp b/src/cppunit/TestFailure.cpp
index 6a48696..0db1628 100644
--- a/src/cppunit/TestFailure.cpp
+++ b/src/cppunit/TestFailure.cpp
@@ -1,26 +1,53 @@
-#include "cppunit/TestFailure.h"
 #include "cppunit/Exception.h"
 #include "cppunit/Test.h"
+#include "cppunit/TestFailure.h"
 
 namespace CppUnit {
 
-/// Returns a short description of the failure.
-std::string 
-TestFailure::toString () const 
-{ 
-  return m_failedTest->toString () + ": " + m_thrownException->what ();
-}
-
 /// Constructs a TestFailure with the given test and exception.
-TestFailure::TestFailure (Test *failedTest, Exception *thrownException)
-  : m_failedTest (failedTest), m_thrownException (thrownException) 
+TestFailure::TestFailure( Test *failedTest, 
+                          Exception *thrownException,
+                          bool isError ) :
+    m_failedTest( failedTest ), 
+    m_thrownException( thrownException ),
+    m_isError( isError )
 {
 }
 
 /// Deletes the owned exception.
-TestFailure::~TestFailure ()
+TestFailure::~TestFailure()
 { 
   delete m_thrownException; 
 }
 
+/// Gets the failed test.
+Test *
+TestFailure::failedTest() const
+{ 
+  return m_failedTest; 
+}
+
+
+/// Gets the thrown exception. Never \c NULL.
+Exception *
+TestFailure::thrownException() const
+{ 
+  return m_thrownException; 
+}
+
+
+/// Indicates if the failure is a failed assertion or an error.
+bool 
+TestFailure::isError() const
+{
+  return m_isError;
+}
+
+/// Returns a short description of the failure.
+std::string 
+TestFailure::toString() const 
+{ 
+  return m_failedTest->toString() + ": " + m_thrownException->what();
+}
+
 } // namespace CppUnit
diff --git a/src/cppunit/TestResult.cpp b/src/cppunit/TestResult.cpp
index 31d445f..06253d8 100644
--- a/src/cppunit/TestResult.cpp
+++ b/src/cppunit/TestResult.cpp
@@ -4,44 +4,39 @@
 
 namespace CppUnit {
 
-/// Destroys a test result
-TestResult::~TestResult ()
-{
-  std::vector<TestFailure *>::iterator it;
+/// Construct a TestResult
+TestResult::TestResult( SynchronizationObject *syncObject ) : 
+    m_syncObject( syncObject == 0 ?  new SynchronizationObject() :
+                                     syncObject  )
+{ 
+  m_runTests = 0;
+  m_testErrors = 0;
+  m_stop = false; 
+}
 
-  for (it = m_errors.begin (); it != m_errors.end (); ++it)
-    delete *it;
 
-  for (it = m_failures.begin (); it != m_failures.end (); ++it)
-    delete *it;
+/// Destroys a test result
+TestResult::~TestResult()
+{
+  TestFailures::iterator itFailure = m_failures.begin();
+  while ( itFailure != m_failures.end() )
+    delete *itFailure++;
 
   delete m_syncObject;
 }
 
-/// Construct a TestResult
-
-  TestResult::TestResult ()
-    : m_syncObject (new SynchronizationObject ())
-{ 
-    m_runTests = 0; 
-    m_stop = false; 
-}
-
 
 /** Adds an error to the list of errors. 
  *  The passed in exception
  *  caused the error
  */
 void 
-  TestResult::addError (Test *test, Exception *e)
+TestResult::addError( Test *test, 
+                      Exception *e )
 { 
-  ExclusiveZone zone (m_syncObject); 
-  m_errors.push_back (new TestFailure (test, e)); 
-
-  for ( std::vector<TestListener *>::iterator it = m_listeners.begin();
-        it != m_listeners.end(); 
-        ++it )
-    (*it)->addError( test, e );
+  ExclusiveZone zone( m_syncObject ); 
+  ++m_testErrors;
+  addFailure( new TestFailure( test, e, true ) );
 }
 
 
@@ -49,21 +44,30 @@ void
  * caused the failure.
  */
 void 
-  TestResult::addFailure (Test *test, Exception *e)
+TestResult::addFailure( Test *test, Exception *e )
 { 
-  ExclusiveZone zone (m_syncObject); 
-  m_failures.push_back (new TestFailure (test, e)); 
+  ExclusiveZone zone( m_syncObject ); 
+  addFailure( new TestFailure( test, e, false ) );
+}
+
+
+/** Called to add a failure to the list of failures.
+ */
+void 
+TestResult::addFailure( TestFailure *failure )
+{
+  m_failures.push_back( failure ); 
 
   for ( std::vector<TestListener *>::iterator it = m_listeners.begin();
         it != m_listeners.end(); 
         ++it )
-    (*it)->addFailure( test, e );
+    (*it)->addFailure( failure );
 }
 
 
 /// Informs the result that a test will be started.
 void 
-  TestResult::startTest (Test *test)
+TestResult::startTest( Test *test )
 { 
   ExclusiveZone zone (m_syncObject); 
   m_runTests++; 
@@ -77,7 +81,7 @@ void
   
 /// Informs the result that a test was completed.
 void 
-  TestResult::endTest (Test *test)
+TestResult::endTest( Test *test )
 { 
   ExclusiveZone zone (m_syncObject); 
 
@@ -90,72 +94,72 @@ void
 
 /// Gets the number of run tests.
 int 
-  TestResult::runTests ()
+TestResult::runTests() const
 { 
-  ExclusiveZone zone (m_syncObject); 
+  ExclusiveZone zone( m_syncObject ); 
   return m_runTests; 
 }
 
 
-/// Gets the number of detected errors.
+/// Gets the number of detected errors (uncaught exception).
 int 
-  TestResult::testErrors ()
+TestResult::testErrors() const
 { 
-  ExclusiveZone zone (m_syncObject); 
-  return m_errors.size (); 
+  ExclusiveZone zone( m_syncObject );
+  return m_testErrors;
 }
 
 
-/// Gets the number of detected failures.
+/// Gets the number of detected failures (failed assertion).
 int 
-  TestResult::testFailures ()
+TestResult::testFailures() const
 { 
-  ExclusiveZone zone (m_syncObject); 
-  return m_failures.size (); 
+  ExclusiveZone zone( m_syncObject ); 
+  return m_failures.size() - m_testErrors;
 }
 
 
-/// Returns whether the entire test was successful or not.
-bool 
-  TestResult::wasSuccessful ()
-{ 
-  ExclusiveZone zone (m_syncObject); 
-  return m_failures.size () == 0 && m_errors.size () == 0; 
+/// Gets the total number of detected failures.
+int 
+TestResult::testFailuresTotal() const
+{
+  ExclusiveZone zone( m_syncObject ); 
+  return m_failures.size();
 }
 
 
-/// Returns a vector of the errors.
-std::vector<TestFailure *>& 
-  TestResult::errors ()
+/// Returns whether the entire test was successful or not.
+bool 
+TestResult::wasSuccessful() const
 { 
-  ExclusiveZone zone (m_syncObject); 
-  return m_errors; 
+  ExclusiveZone zone( m_syncObject );
+  return m_failures.size() == 0;
 }
 
 
 /// Returns a vector of the failures.
-std::vector<TestFailure *>& 
-  TestResult::failures ()
+const std::vector<TestFailure *>& 
+TestResult::failures() const
 { 
-  ExclusiveZone zone (m_syncObject); 
+  ExclusiveZone zone( m_syncObject );
   return m_failures; 
 }
 
 
 /// Returns whether testing should be stopped
 bool 
-  TestResult::shouldStop ()
+TestResult::shouldStop() const
 { 
-  ExclusiveZone zone (m_syncObject); 
+  ExclusiveZone zone( m_syncObject );
   return m_stop; 
 }
 
 
 /// Stop testing
 void 
-  TestResult::stop ()
+TestResult::stop()
 { 
-  ExclusiveZone zone (m_syncObject); 
+  ExclusiveZone zone( m_syncObject );
   m_stop = true; 
 }
 
@@ -164,7 +168,7 @@ void
  * TestResult assumes ownership of the object
  */
 void 
-  TestResult::setSynchronizationObject (SynchronizationObject *syncObject)
+TestResult::setSynchronizationObject( SynchronizationObject *syncObject )
 { 
   delete m_syncObject; 
   m_syncObject = syncObject; 
@@ -183,7 +187,9 @@ void
 TestResult::removeListener ( TestListener *listener )
 {
   ExclusiveZone zone (m_syncObject); 
-  m_listeners.erase( std::remove( m_listeners.begin(), m_listeners.end(), listener ),
+  m_listeners.erase( std::remove( m_listeners.begin(), 
+                                  m_listeners.end(), 
+                                  listener ),
                      m_listeners.end());
 }
 
diff --git a/src/cppunit/TextTestResult.cpp b/src/cppunit/TextTestResult.cpp
index d04ce92..bfd6fb9 100644
--- a/src/cppunit/TextTestResult.cpp
+++ b/src/cppunit/TextTestResult.cpp
@@ -6,28 +6,27 @@
 
 namespace CppUnit {
 
-std::ostream& 
-operator<< (std::ostream& stream, TextTestResult& result)
-{ 
-  result.print (stream); return stream; 
-}
 
 void 
-TextTestResult::addError (Test *test, Exception *e)
+TextTestResult::addError( Test *test, 
+                          Exception *e )
 {
-    TestResult::addError (test, e);
-    std::cerr << "E";
+  TestResult::addError( test, e );
+  std::cerr << "E";
 }
 
+
 void 
-TextTestResult::addFailure (Test *test, Exception *e)
+TextTestResult::addFailure( Test *test, 
+                            Exception *e )
 {
-    TestResult::addFailure (test, e);
-    std::cerr << "F";
+  TestResult::addFailure (test, e);
+  std::cerr << "F";
 }
 
+
 void 
-TextTestResult::startTest (Test *test)
+TextTestResult::startTest( Test *test )
 {
   TestResult::startTest (test);
   std::cerr << ".";
@@ -35,104 +34,117 @@ TextTestResult::startTest (Test *test)
 
 
 void 
-TextTestResult::printErrors (std::ostream& stream)
+TextTestResult::printFailures( std::ostream &stream )
+{
+  TestFailures::const_iterator itFailure = failures().begin();
+  int failureNumber = 1;
+  while ( itFailure != failures().end() ) 
+    printFailure( *itFailure++, failureNumber++, stream );
+}
+
+
+void 
+TextTestResult::printFailure( TestFailure *failure,
+                              int failureNumber,
+                              std::ostream &stream )
+{
+  printFailureListMark( failureNumber, stream );
+  stream << ' ';
+  printFailureTestName( failure, stream );
+  stream << ' ';
+  printFailureType( failure, stream );
+  stream << ' ';
+  printFailureLocation( failure->thrownException(), stream );
+  stream << std::endl;
+  printFailureDetail( failure->thrownException(), stream );
+  stream << std::endl;
+}
+
+
+void 
+TextTestResult::printFailureListMark( int failureNumber,
+                                      std::ostream &stream )
+{
+  stream << failureNumber << ")";
+}
+
+
+void 
+TextTestResult::printFailureTestName( TestFailure *failure,
+                                      std::ostream &stream )
 {
-    if ( testErrors() == 0 )
-	return;
-
-    if (testErrors () == 1)
-	stream << "There was 1 error: " << std::endl;
-    else
-	stream << "There were " << testErrors () << " errors: " << std::endl;
-
-    int i = 1;
-
-    for (std::vector<TestFailure *>::iterator it = errors ().begin (); it != errors ().end (); ++it) {
-	TestFailure* failure = *it;
-	Exception* e = failure->thrownException ();
-
-	stream << i 
-	       << ")"
-	       << " test: " << failure->failedTest()->getName();
-	if ( e ) 
-	    stream << " line: " << e->lineNumber()
-		   << ' ' << e->fileName();
-	stream << " \"" << failure->thrownException()->what() << "\""
-	       << std::endl;
-	i++;
-    }
+  stream << "test: " << failure->failedTest()->getName();
 }
 
 
 void 
-TextTestResult::printFailures (std::ostream& stream) 
+TextTestResult::printFailureType( TestFailure *failure,
+                                  std::ostream &stream )
 {
-    if ( testFailures() == 0 )
-	return;
-
-    if (testFailures () == 1)
-	stream << "There was 1 failure: " << std::endl;
-    else
-	stream << "There were " << testFailures () << " failures: " << std::endl;
-
-    int i = 1;
-
-    for (std::vector<TestFailure *>::iterator it = failures ().begin (); it != failures ().end (); ++it) {
-	TestFailure* failure = *it;
-	Exception* e = failure->thrownException();
-
-	stream << i 
-	       << ")"
-	       << " test: " << failure->failedTest()->getName();
-	if ( e ) 
-	    stream << " line: " << e->lineNumber()
-		   << ' ' << e->fileName();
-
-	if ( failure->thrownException()->isInstanceOf( NotEqualException::type() ) )
-        {
-	    NotEqualException *e = (NotEqualException*)failure->thrownException();
-	    stream << std::endl 
-		   << "expected: " << e->expectedValue() << std::endl
-		   << "but was:  " << e->actualValue();
-	} 
-	else 
-        {
-	    stream << " \"" << failure->thrownException ()->what () << "\"";
-	}
-
-	stream << std::endl;
-	i++;
-    }
+  stream << "("
+         << (failure->isError() ? "E" : "F")
+         << ")";
 }
 
 
 void 
-TextTestResult::print (std::ostream& stream) 
+TextTestResult::printFailureLocation( Exception *thrownException,
+                                      std::ostream &stream )
 {
-    printHeader (stream);
-    printErrors (stream);
-    printFailures (stream);
+  stream << "line: " << thrownException->lineNumber()
+         << ' ' << thrownException->fileName();
+}
+
 
+void 
+TextTestResult::printFailureDetail( Exception *thrownException,
+                                    std::ostream &stream )
+{
+  if ( thrownException->isInstanceOf( NotEqualException::type() ) )
+  {
+    NotEqualException *e = (NotEqualException*)thrownException;
+    stream << "expected: " << e->expectedValue() << std::endl
+           << "but was:  " << e->actualValue();
+  }
+  else
+  {
+    stream << " \"" << thrownException->what() << "\"";
+  }
 }
 
 
 void 
-TextTestResult::printHeader (std::ostream& stream)
+TextTestResult::print( std::ostream& stream ) 
 {
-    if (wasSuccessful ())
-        stream << std::endl << "OK (" << runTests () << " tests)" << std::endl;
-    else
-        stream << std::endl
-             << "!!!FAILURES!!!" << std::endl
-             << "Test Results:" << std::endl
-             << "Run:  "
-             << runTests ()
-             << "   Failures: "
-             << testFailures ()
-             << "   Errors: "
-             << testErrors ()
-             << std::endl;
+  printHeader( stream );
+  stream << std::endl;
+  printFailures( stream );
+}
+
 
+void 
+TextTestResult::printHeader( std::ostream &stream )
+{
+  if (wasSuccessful ())
+    stream << std::endl << "OK (" << runTests () << " tests)" 
+           << std::endl;
+  else
+    stream << std::endl
+           << "!!!FAILURES!!!" << std::endl
+           << "Test Results:" << std::endl
+           << "Run:  "  << runTests()
+           << "   Failures: "  << testFailures()
+           << "   Errors: "  << testErrors()
+           << std::endl;
+}
+
+
+std::ostream &
+operator <<( std::ostream &stream, 
+             TextTestResult &result )
+{ 
+  result.print (stream); return stream; 
 }
 
+
 } // namespace CppUnit