NEW: updated and restructured.

NEW: updated and restructured.

* include/cppunit/CompilerOutputter.h:
* src/cppunit/CompilerOutputter.cpp:
updated against TestResultChange. Changed TestResult to TestResultCollector.

* include/cppunit/extensions/HelperMacros.h: minor documentation fix.

* include/cppunit/Outputter.h: added. Abstract base class for all Outputter.

* include/cppunit/Portability.h: made the fix on OStringStream suggested by
Bob Summerwill to remove level 4 warning with VC++.

* include/cppunit/TestAssert.h: added macro CPPUNIT_ASSERT_EQUAL_MESSAGE.

* src/cppunit/TestFailure.cpp:
* include/cppunit/TestFailure.h: added method clone() to duplicate a failure. Made
all method virtual.

* include/cppunit/TestListener.h: changed signature of addFailure() to
addFailure( const TestFailure &failure ). Failure is now only a temporary object.

* include/cppunit/Outputter.h: added. Abstract base class for all outputter. Used
by TextTestRunner.

* include/cppunit/SynchronizedObject.h:
* src/cppunit/SynchronizedObject.cpp: added. Class extracted from TestResult.
Base class for objects that can be accessed from different threads.

* include/cppunit/TestResult.h: TestFailure.h is no longer included.

* include/cppunit/TestResult.h:
* src/cppunit/TestResult.cpp: extracted all methods related to keeping track
of the result to the new TestResultCollector class which is a TestListener.

* include/cppunit/TestResultCollector.h:
* src/cppunit/TestResultCollector.cpp: added. TestListener which kept track
of the result of the test run. All failure/error, and tests are tracked.

* include/cppunit/TestSucessListener.h:
* src/cppunit/TestSucessListener.cpp: added. TestListener extracted from
TestResult. Is responsible for wasSucessful().

* include/cppunit/TestCase.h:
* src/cppunit/TestCase.cpp: reindented.

* include/cppunit/TextOutputter.h:
* src/cppunit/TextOutputter.cpp: added. Copied from the deprecated
TextTestResult and modified to act as an Ouputter.

* include/cppunit/TextTestProgressListener.h:
* src/cppunit/TextTestProgressListener.cpp: Copied from the deprecated
TextTestResult and modified to print the dot while the test are running.

* include/cppunit/TextTestResult.h:
* src/cppunit/TextTestResult.cpp: updated against TestResult change.
No compatiblity break. Deprecated.

* include/cppunit/TextTestRunner.h:
* src/cppunit/TextTestRunner.cpp: updated to work with the new TestResult.
Use TextTestProgressListener and TextOutputter instead of TextTestResult.
Any outputter with interface Outputter can be used to print the test result
(CompilerOutputter, XmlOutputter, TextOutputter...)

* include/cppunit/XmlOutputter.h:
* src/cppunit/XmlOutputter.cpp: updated against TestResultChange.
Changed TestResult to TestResultCollector.

* src/msvc6/TestRunnerDlg.h:
* src/msvc6/TestRunnerDlg.cpp: fixed the 'fullrowselect' feature of the list view.
The dialog is a TestListener itself, it no longer use the GUITestResult class.

* src/msvc6/TestRunner.rc: moved the "autorun test button" in such a way that it
did not overlap the progress bar anymore.

* src/msvc6/MfcSynchronizationObject.h: added. Generic SynchronizedObject
lock for MFC.

* src/msvc6/GUITestResult.h :
* src/msvc6/GUITestResult.cpp : removed.

* src/qttestrunner/TestRunnerModel.h:
* src/qttestrunner/TestRunnerModel.cpp: changed addFailure() signature to reflect
change on TestListener.

* examples/cppunittest/CppUnitTestMain.cpp: updated to use the new Outputter
abstraction and TextTestRunner facilities.

* examples/cppunittest/FailingTestCase.h:
* examples/cppunittest/FailingTestCase.cpp: removed. Replaced by MockTestCase.

* examples/cppunittest/FailingTestCase.h:
* examples/cppunittest/FailingTestCase.h:

* examples/cppunittest/HelperMacrosTest.h:
* examples/cppunittest/HelperMacrosTest.cpp: Updated against TestResult change.
Use MockTestListener instead of TestResult to check for sucess or failure.

* examples/cppunittest/MockTestListener.h:
* examples/cppunittest/MockTestListener.cpp: the class now behave like a mock
object.

* examples/cppunittest/MockTestCase.h:
* examples/cppunittest/MockTestCase.cpp: added. Mock TestCase object.

* examples/cppunittest/OrthodoxTest.h:
* examples/cppunittest/OrthodoxTest.cpp: Updated against TestResult change.
Use MockTestListener instead of TestResult to check for sucess or failure.

* examples/cppunittest/SynchronizedTestResult.h: Updated against TestResult
change.

* examples/cppunittest/TestCallerTest.h:
* examples/cppunittest/TestCallerTest.cpp: Updated against TestResult change.
Use MockTestListener instead of TestResult.

* examples/cppunittest/TestCaseTest.h:
* examples/cppunittest/TestCaseTest.cpp: Updated against TestResult change.
Use MockTestListener and MockTestCase instead of FailingTestCase and TestResult.

* examples/cppunittest/TestDecoratorTest.h:
* examples/cppunittest/TestDecoratorTest.cpp: Updated against TestResult change.
Use MockTestCase instead of FailingTestCase.

* examples/cppunittest/TestListenerTest.h:
* examples/cppunittest/TestListenerTest.cpp: removed. Those unit tests have been
rewrote and moved to TestResultTest.

* examples/cppunittest/TestResultTest.h:
* examples/cppunittest/TestResultTest.cpp: Updated to test the new interface.
Tests from TestListenerTest have been moved here.

* examples/cppunittest/TestResultCollectorTest.h:
* examples/cppunittest/TestResultCollectorTest.cpp: added. Tests for the class
that been extracted from TestResult.

* examples/cppunittest/TestSetUpTest.h:
* examples/cppunittest/TestSetUpTest.cpp: renamed SetUp inner class to MockSetUp.
Changed interface to be more akin to a Mock object.

* examples/cppunittest/TestSuiteTest.h:
* examples/cppunittest/TestSuiteTest.cpp: Updated against TestResult change,
and rewrote to use MockTestCase instead of FailingTestCase.

* examples/cppunittest/XmlOutputterTest.h:
* examples/cppunittest/XmlOutputterTest.cpp: Updated against TestResult change.
Added some utility methods to make the update easier.

1 files changed, 297 insertions, 0 deletions

diff --git a/examples/cppunittest/TestResultCollectorTest.cpp b/examples/cppunittest/TestResultCollectorTest.cpp
new file mode 100644
index 0000000..bac6485
--- /dev/null
+++ b/examples/cppunittest/TestResultCollectorTest.cpp
@@ -0,0 +1,297 @@
+#include "CoreSuite.h"
+#include "TestResultCollectorTest.h"
+
+
+
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( TestResultCollectorTest,
+                                       CppUnitTest::coreSuiteName() );
+
+
+TestResultCollectorTest::TestResultCollectorTest()
+{
+}
+
+
+TestResultCollectorTest::~TestResultCollectorTest()
+{
+}
+
+
+void 
+TestResultCollectorTest::setUp()
+{
+  m_lockCount = 0;
+  m_unlockCount = 0;
+  m_result = new CppUnit::TestResultCollector();
+  m_synchronizedResult = new SynchronizedTestResult( this );  
+  m_test = new CppUnit::TestCase();
+  m_test2 = new CppUnit::TestCase();
+}
+
+
+void 
+TestResultCollectorTest::tearDown()
+{
+  delete m_test2;
+  delete m_test;
+  delete m_synchronizedResult;
+  delete m_result;
+}
+
+
+void 
+TestResultCollectorTest::testConstructor()
+{
+  checkResult( 0, 0, 0 );
+}
+
+
+void 
+TestResultCollectorTest::testAddTwoErrors()
+{
+  std::string errorMessage1( "First Error" );
+  std::string errorMessage2( "Second Error" );
+  {
+    CppUnit::TestFailure failure1( m_test, 
+                                   new CppUnit::Exception( errorMessage1 ),
+                                   true );
+    m_result->addFailure( failure1 );
+
+    CppUnit::TestFailure failure2( m_test2, 
+                                   new CppUnit::Exception( errorMessage2 ),
+                                   true );
+    m_result->addFailure( failure2 );
+  } // ensure that the test result duplicate the failures.
+
+  checkResult( 0, 2, 0 );
+  checkFailure( m_result->failures()[0],
+                errorMessage1,
+                m_test,
+                true );
+  checkFailure( m_result->failures()[1],
+                errorMessage2,
+                m_test2,
+                true );
+}
+
+
+void 
+TestResultCollectorTest::testAddTwoFailures()
+{
+  std::string errorMessage1( "First Failure" );
+  std::string errorMessage2( "Second Failure" );
+  {
+    CppUnit::TestFailure failure1( m_test, 
+                                   new CppUnit::Exception( errorMessage1 ),
+                                   false );
+    m_result->addFailure( failure1 );
+
+    CppUnit::TestFailure failure2( m_test2, 
+                                   new CppUnit::Exception( errorMessage2 ),
+                                   false );
+    m_result->addFailure( failure2 );
+  } // ensure that the test result duplicate the failures.
+  checkResult( 2, 0, 0 );
+  checkFailure( m_result->failures()[0],
+                errorMessage1,
+                m_test,
+                false );
+  checkFailure( m_result->failures()[1],
+                errorMessage2,
+                m_test2,
+                false );
+}
+
+
+void 
+TestResultCollectorTest::testStartTest()
+{
+  m_result->startTest( m_test );
+  m_result->startTest( m_test );
+  checkResult( 0, 0, 2 );
+}
+
+
+void 
+TestResultCollectorTest::testWasSuccessfulWithNoTest()
+{
+  checkWasSuccessful( true );
+}
+
+
+void 
+TestResultCollectorTest::testWasSuccessfulWithErrors()
+{
+  addError( "Error1" );
+  addError( "Error2" );
+  checkWasSuccessful( false );
+}
+
+
+void 
+TestResultCollectorTest::testWasSuccessfulWithFailures()
+{
+  addFailure( "Failure1" );
+  addFailure( "Failure2" );
+  checkWasSuccessful( false );
+}
+
+
+void 
+TestResultCollectorTest::testWasSuccessfulWithErrorsAndFailures()
+{
+  addError( "Error1" );
+  addFailure( "Failure2" );
+  checkWasSuccessful( false );
+}
+
+
+void 
+TestResultCollectorTest::testWasSuccessfulWithSucessfulTest()
+{
+  m_result->startTest( m_test );
+  m_result->endTest( m_test );
+  m_result->startTest( m_test2 );
+  m_result->endTest( m_test2 );
+  checkWasSuccessful( true );
+}
+
+
+void 
+TestResultCollectorTest::testSynchronizationAddFailure()
+{
+  addFailure( "Failure1", m_test, false, m_synchronizedResult );
+  checkSynchronization();
+}
+
+
+void 
+TestResultCollectorTest::testSynchronizationStartTest()
+{
+  m_synchronizedResult->startTest( m_test );
+  checkSynchronization();
+}
+
+
+void 
+TestResultCollectorTest::testSynchronizationRunTests()
+{
+  m_synchronizedResult->runTests();
+  checkSynchronization();
+}
+
+
+void 
+TestResultCollectorTest::testSynchronizationTestErrors()
+{
+  m_synchronizedResult->testErrors();
+  checkSynchronization();
+}
+
+
+void 
+TestResultCollectorTest::testSynchronizationTestFailures()
+{
+  m_synchronizedResult->testFailures();
+  checkSynchronization();
+}
+
+
+void 
+TestResultCollectorTest::testSynchronizationFailures()
+{
+  m_synchronizedResult->failures();
+  checkSynchronization();
+}
+
+
+void 
+TestResultCollectorTest::testSynchronizationWasSuccessful()
+{
+  m_synchronizedResult->wasSuccessful();
+  checkSynchronization();
+}
+
+
+void 
+TestResultCollectorTest::checkResult( int failures,
+                             int errors,
+                             int testsRun )
+{
+  CPPUNIT_ASSERT_EQUAL( testsRun, m_result->runTests() );
+  CPPUNIT_ASSERT_EQUAL( errors, m_result->testErrors() );
+  CPPUNIT_ASSERT_EQUAL( failures, m_result->testFailures() );
+  CPPUNIT_ASSERT_EQUAL( errors + failures, 
+                        m_result->testFailuresTotal() );
+}
+
+
+void
+TestResultCollectorTest::checkFailure( CppUnit::TestFailure *failure,
+                                       std::string expectedMessage,
+                                       CppUnit::Test *expectedTest,
+                                       bool expectedIsError )
+{
+  std::string actualMessage( failure->thrownException()->what() );
+  CPPUNIT_ASSERT_EQUAL( expectedMessage, actualMessage );
+  CPPUNIT_ASSERT_EQUAL( expectedTest, failure->failedTest() );
+  CPPUNIT_ASSERT_EQUAL( expectedIsError, failure->isError() );
+}
+
+
+void 
+TestResultCollectorTest::checkWasSuccessful( bool shouldBeSuccessful )
+{
+  CPPUNIT_ASSERT_EQUAL( shouldBeSuccessful, m_result->wasSuccessful() );
+}
+
+
+void 
+TestResultCollectorTest::locked()
+{
+  CPPUNIT_ASSERT_EQUAL( m_lockCount, m_unlockCount );
+  ++m_lockCount;
+}
+
+
+void 
+TestResultCollectorTest::unlocked()
+{
+  ++m_unlockCount;
+  CPPUNIT_ASSERT_EQUAL( m_lockCount, m_unlockCount );
+}
+
+
+void 
+TestResultCollectorTest::checkSynchronization()
+{
+  CPPUNIT_ASSERT_EQUAL( m_lockCount, m_unlockCount );
+  CPPUNIT_ASSERT( m_lockCount > 0 );
+}
+
+
+void 
+TestResultCollectorTest::addFailure( std::string message )
+{
+  addFailure( message, m_test, false, m_result );
+}
+
+
+void 
+TestResultCollectorTest::addError( std::string message )
+{
+  addFailure( message, m_test, true, m_result );
+}
+
+
+void 
+TestResultCollectorTest::addFailure( std::string message, 
+                                     CppUnit::Test *failedTest, 
+                                     bool isError,
+                                     CppUnit::TestResultCollector *result )
+{
+  CppUnit::TestFailure failure( failedTest, 
+                                new CppUnit::Exception( message ), 
+                                isError );
+  result->addFailure( failure );
+}