CompositeTestRunner.h

#ifndef COMPOSITE_TEST_RUNNER_H
#define COMPOSITE_TEST_RUNNER_H
 
/*
* Simpatico - Simulation Package for Polymeric and Molecular Liquids
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include "TestRunner.h"
#include <vector>
 
class CompositeTestRunner : public TestRunner
{
 
public:
 
   // Default constructor.
 
   virtual ~CompositeTestRunner();
 
   void addChild(TestRunner& child);
 
   void addChild(TestRunner* childPtr);
 
   void addChild(TestRunner* childPtr, const std::string& prefix);
 
   virtual void addFilePrefix(const std::string& prefix);
 
   virtual int run(); 
 
private:
 
   std::vector<TestRunner*> children_;
 
   std::vector<TestRunner*> ownedChildren_;
 
};
 
// Function definitions
 
/*
* Destructor.
*/
CompositeTestRunner::~CompositeTestRunner()
{
   unsigned int i; 
   for (i = 0; i < children_.size(); ++i) {
      delete ownedChildren_[i]; 
   }
}
 
/*
* Add an existing TestRunner as a child.
*/
void CompositeTestRunner::addChild(TestRunner& child)
{
   children_.push_back(&child); 
   child.setParent(*this);
}
 
/*
* Add a TestRunner as a child, and accept ownership.
*/
void CompositeTestRunner::addChild(TestRunner* childPtr)
{
   children_.push_back(childPtr);
   ownedChildren_.push_back(childPtr);
   childPtr->setParent(*this);
}
 
/*
* Add a TestRunner as a child, accept ownership, and set file prefix.
*/
void CompositeTestRunner::addChild(TestRunner* childPtr, 
                                   const std::string& prefix)
{
   addChild(childPtr);
   childPtr->addFilePrefix(prefix);
}
 
/*
* Prepend argument prefix to existing filePrefix.
*/
void CompositeTestRunner::addFilePrefix(const std::string& prefix) 
{
   TestRunner::addFilePrefix(prefix);
   for (unsigned int i = 0; i < children_.size(); ++i) {
      children_[i]->addFilePrefix(prefix); 
   }
}
 
/*
* Run all children in sequence, using depth-first recursion. 
*/
int CompositeTestRunner::run() 
{
   for (unsigned int i = 0; i < children_.size(); ++i) {
      children_[i]->run(); 
   }
   report();
   return nFailure();
}
 
// Preprocessor macros
 
#define TEST_COMPOSITE_BEGIN(CompositeClass) \
   class CompositeClass : public CompositeTestRunner  { public: \
      CompositeClass () {
 
#define TEST_COMPOSITE_ADD_UNIT(UnitTestClass) \
         addChild(new TEST_RUNNER(UnitTestClass)); 
 
#define TEST_COMPOSITE_ADD_CHILD(TestRunner, Prefix) \
         addChild(new TestRunner, Prefix);
 
#define TEST_COMPOSITE_END } };
 
#endif