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