TestRunner.h

#ifndef TEST_RUNNER_H
#define 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 <string>
#include <iostream>
 
#ifdef TEST_MPI
#include <mpi.h>
#endif
 
class TestRunner
{
 
public:
 
   TestRunner();
 
   virtual ~TestRunner();
 
   virtual int run() = 0;
 
   void recordFailure();
 
   void recordSuccess();
 
   void setParent(TestRunner& parent);
 
   TestRunner& parent();
 
   bool hasParent() const;
 
   int nSuccess() const;
 
   int nFailure() const;
 
   void report() const;
 
   bool isIoProcessor() const;
 
   #ifdef TEST_MPI
   int mpiRank() const;
 
   int mpiSize() const;
   #endif
 
   virtual void addFilePrefix(const std::string& prefix);
 
   const std::string& filePrefix() const;
 
protected:
 
   std::string  filePrefix_;
 
private:
 
   TestRunner* parentPtr_;
 
   int  nSuccess_;
 
   int  nFailure_;
 
   bool  isIoProcessor_;
 
   #ifdef TEST_MPI
   int  mpiRank_;
 
   int  mpiSize_;
   #endif
 
};
 
// Inline methods
 
/*
* Set another TestRunner as the parent.
*/
inline void TestRunner::setParent(TestRunner& parent)
{  parentPtr_ = &parent; }
 
/*
* Return the parent object, if any.
*/
inline TestRunner& TestRunner::parent()
{  return *parentPtr_; }
 
/*
* Does this object have a parent?
*/
inline bool TestRunner::hasParent() const
{  return (parentPtr_ != 0); }
 
/*
* Return number of successful tests run.
*/
inline int TestRunner::nSuccess() const
{  return nSuccess_; }
 
/*
* Return number of failed tests run.
*/
inline int TestRunner::nFailure() const
{  return nFailure_; }
 
/*
* Return file prefix by const reference.
*/
inline 
const std::string& TestRunner::filePrefix() const
{  return filePrefix_; }
 
/*
* Is this an Io processor? (always true without MPI)
*/
inline bool TestRunner::isIoProcessor() const
{  return isIoProcessor_; }
 
#ifdef TEST_MPI
inline int TestRunner::mpiRank() const
{  return mpiRank_; }
 
inline int TestRunner::mpiSize() const
{  return mpiSize_; } 
#endif
 
// Non-inline methods
 
/*
* Constructor.
*/
TestRunner::TestRunner()
 : parentPtr_(0),
   nSuccess_(0),
   nFailure_(0),
   isIoProcessor_(0)
   #ifdef TEST_MPI
   ,mpiRank_(0),
   mpiSize_(0)
   #endif
{
    #ifndef TEST_MPI
    isIoProcessor_ = true; 
    #else
    mpiRank_ = MPI::COMM_WORLD.Get_rank();
    mpiSize_ = MPI::COMM_WORLD.Get_size();
    if (mpiRank_ == 0) {
       isIoProcessor_ = true; 
    } else {
       isIoProcessor_ = false; 
    }
    #endif
}
 
/*
* Destructor.
*/
TestRunner::~TestRunner()
{}
 
/*
* Increment counter for failed tests, and that of parent (if any).
*/
void TestRunner::recordFailure() 
{
   if (isIoProcessor()) {
      ++nFailure_;
      if (hasParent()) {
         parent().recordFailure();
      }
   }
}
 
/*
* Increment counter for successful tests, and that of parent (if any).
*/
void TestRunner::recordSuccess()
{
   if (isIoProcessor()) {
      ++nSuccess_;
      if (hasParent()) {
         parent().recordSuccess();
      }
   }
}
 
/*
* If this object has no parent, report success and failure counters.
*/
void TestRunner::report() const
{ 
   if (!hasParent() && isIoProcessor()) {
      std::cout << std::endl;
      std::cout << nSuccess_ << "  successful tests  " << std::endl;
      std::cout << nFailure_ << "  failed tests  "    << std::endl;
      std::cout << std::endl;
   }
}
 
/*
* Prepend argument prefix to existing filePrefix (virtual).
*/
void TestRunner::addFilePrefix(const std::string& prefix) 
{
   std::string newPrefix = prefix;
   newPrefix += filePrefix_;
   filePrefix_ = newPrefix;
}
 
#endif