[Cppunit-cvs] cppunit2/src/cpput testrunner.cpp,NONE,1.1

[Baptiste L. <bl...@us...>]

Update of /cvsroot/cppunit/cppunit2/src/cpput
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2484/cpput

Added Files:
	testrunner.cpp 
Log Message:
* basic TestRunner implementation for use with OpenTest TestDriver.

--- NEW FILE: testrunner.cpp ---
#include <cpput/testrunner.h>
#include <cpput/message.h>
#include <cpput/testcontext.h>
#include <cpput/testlistener.h>
#include <cpput/testresult.h>
#include <cpput/testsuite.h>
#include <cpput/testvisitor.h>
#include <opentest/properties.h>
#include <opentest/testplan.h>


namespace CppUT {


// Class TestRunner::TestDeclaratorVisitor
// //////////////////////////////////////////////////////////////////

class TestRunner::TestDeclaratorVisitor : public TestVisitor
{
public:
   TestDeclaratorVisitor( OpenTest::TestDeclarator &declarator,
                          TestRunner::DeclaredTests &tests )
      : declarator_( declarator )
      , tests_( tests )
   {
   }

public: // overridden from TestVisitor
   void visitTestCase( Test &test )
   {
      OpenTest::TestId id = declarator_.addTest( test.name(), 
                                                 OpenTest::Properties() );
      tests_.insert( TestRunner::DeclaredTests::value_type( id, &test ) );
   }

   void visitTestSuite( AbstractTestSuite &suite )
   {
      OpenTest::TestId id = declarator_.beginSuite( suite.name(), 
                                                    OpenTest::Properties() );
      tests_.insert( TestRunner::DeclaredTests::value_type( id, &suite ) );
      for ( int index = 0; index < suite.testCount(); ++index )
         suite.testAt( index )->accept( *this );
      declarator_.endSuite();
   }

private:
   OpenTest::TestDeclarator &declarator_;
   TestRunner::DeclaredTests &tests_;
};



class TestRunner::TestTrackerListener : public TestListener
{
public:
   TestTrackerListener( OpenTest::TestRunTracker &tracker )
      : tracker_( tracker )
      , testEntry_( 0 )
   {
   }

   void setTestPlanEntry( const OpenTest::TestPlanEntry &entry )
   {
      testEntry_ = &entry;
   }

public: // overridden from TestListener
   void processTestResult( TestResult &result, 
                           TestContext &context )
   {
      if ( !testEntry_ )
         return;

      // Notes: at the current time, we don't retrieve the message
      // in a structured way. => need to change message to use 
      // OpenTest::Properties.

      OpenTest::Properties openResult;
      openResult["result"]["status"]["success"] = result.succeeded();
      openResult["result"]["status"]["type"] = result.resultType();
      openResult["result"]["status"]["message"] = result.message().toString();
      if ( result.location().isValid() )
      {
         OpenTest::Value &openLocation = openResult["result"]["status"]["location"];
         openLocation["file"] = result.location().fileName();
         openLocation["line"] = result.location().lineNumber();
         if ( result.location().hasFunctionName() )
            openLocation["function"] = result.location().functionName();
      }

      tracker_.addTestInfo( *testEntry_, openResult );
   }

private:
   OpenTest::TestRunTracker &tracker_;
   const OpenTest::TestPlanEntry *testEntry_;
};

   

// Class TestRunner
// //////////////////////////////////////////////////////////////////


TestRunner::TestRunner()
   : suite_( new TestSuite( "All Tests" ) )
{
}


void 
TestRunner::setRootSuite( const AbstractTestSuitePtr &suite )
{
   suite_ = suite;
}


AbstractTestSuitePtr 
TestRunner::rootSuite() const
{
   return suite_;
}


void 
TestRunner::declareTests( OpenTest::TestDeclarator &declarator )
{
   TestDeclaratorVisitor visitor( declarator, tests_ );
   suite_->accept( visitor );
}


void 
TestRunner::runTests( const OpenTest::TestPlan &testPlan,
                      OpenTest::TestRunTracker &tracker,
                      const OpenTest::Properties &configuration )
{
   TestTrackerListener listener( tracker );
   TestContext testContext;
   testContext.add( listener );

   tracker.startTestRun();

   OpenTest::TestPlanEntryPtrEnum enumEntries = testPlan.entries();
   while ( enumEntries.hasNext() )
   {
      const OpenTest::TestPlanEntry &entry = *enumEntries.next();
      OpenTest::TestId id = entry.test();
      DeclaredTests::const_iterator itTest = tests_.find( id );
      listener.setTestPlanEntry( entry );
      tracker.startTest( entry );
      if ( itTest == tests_.end() ) // protocol error => unknown test
      {
         OpenTest::Properties openResult;
         openResult["result"]["status"]["success"] = false;
         openResult["result"]["status"]["type"] = "skip";
         tracker.addTestInfo( entry, openResult );
      }
      else
      {
         Test &test = *( itTest->second );
         test.run( testContext );
      }
      tracker.endTest( entry );
   }

   tracker.endTestRun();
}


} // namespace CppUT