UnitTest.h

#ifndef UNIT_TEST_H
#define UNIT_TEST_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 "TestException.h"
 
#include <stdio.h>
#include <fstream>
#include <string>
#ifdef TEST_MPI
#include <mpi.h>
#endif
 
class UnitTest
{
 
public:
 
   UnitTest();
 
   virtual ~UnitTest();
 
   virtual void setUp();
 
   virtual void tearDown();
 
   void setVerbose(int verbose);
 
   void setFilePrefix(const std::string& prefix);
 
   const std::string& filePrefix();
 
   bool isIoProcessor() const;
 
   #ifdef TEST_MPI
   void setCommunicator(MPI::Intracomm& communicator);
 
   int mpiRank();
 
   bool hasCommunicator();
 
   MPI::Intracomm& communicator();
   #endif
 
protected:
 
   void printMethod(const char* methodName);
 
   void printEndl();
 
   virtual void endMarker();
 
   void openInputFile(const std::string& name, std::ifstream& in) const;
 
   void openOutputFile(const std::string& name, std::ofstream& out) const;
 
   FILE* openFile(const std::string& name, const char* mode) const;
 
   int verbose() const;
 
   static bool eq(int s1, int s2);
 
   static bool eq(double s1, double s2);
 
private:
 
   std::string  filePrefix_;
 
   #ifdef TEST_MPI
   MPI::Intracomm* communicatorPtr_;
 
   int  mpiRank_;
   #endif
 
   int  verbose_;
 
   bool isIoProcessor_;
 
};
 
/*
* Constructor
*/
UnitTest::UnitTest() :
   #ifdef TEST_MPI      
   communicatorPtr_(0),
   mpiRank_(-1),
   #endif
   verbose_(0),
   isIoProcessor_(true)
{
   #ifdef TEST_MPI
   // Set the communicator to COMM_WORLD by default.
   setCommunicator(MPI::COMM_WORLD);
   #endif
}
 
/*
* Destructor.
*/
UnitTest::~UnitTest() 
{}
 
/*
* Set up before each test method (empty default implementation).
*/
void UnitTest::setUp()
{}
 
/*
* Tear down after each test method (empty default implementation).
*/
void UnitTest::tearDown()
{}
 
/*
* Set verbosity level.
*
* \param verbose verbosity level (0 = silent).
*/
void UnitTest::setVerbose(int verbose)
{  verbose_ = verbose; }
 
/*
* Set file prefix.
*/
void UnitTest::setFilePrefix(const std::string& prefix)
{  filePrefix_  = prefix; }
 
/*
* Get file prefix string
*/
const std::string& UnitTest::filePrefix()
{  return filePrefix_; }
 
/*
* Should this processor read and write to file?
*/
bool UnitTest::isIoProcessor() const
{  return isIoProcessor_; } 
 
#ifdef TEST_MPI
/*
* Set the MPI communicator.
*/
void UnitTest::setCommunicator(MPI::Intracomm& communicator)
{  
   communicatorPtr_ = &communicator; 
   mpiRank_ = communicator.Get_rank();
   if (mpiRank_ == 0) {
      isIoProcessor_ = true; 
   } else {
      isIoProcessor_ = false; 
   }
}
 
/*
* Return rank of this processor in communicator.
*/
int UnitTest::mpiRank()
{  return mpiRank_; } 
 
/*
* Does this test have a communicator?
*/
bool UnitTest::hasCommunicator()
{  return bool(communicatorPtr_ != 0); }
 
/*
* Return the communicator by reference.
*/
MPI::Intracomm& UnitTest::communicator()
{  return *communicatorPtr_; }
#endif
 
/*
* Write name of a class method, iff ioProcessor.
*/
void UnitTest::printMethod(const char* methodName)
{  if (isIoProcessor()) {
      std::cout << std::endl;
      std::cout << std::string(methodName) << std::flush; 
   }
}
 
/*
* Write carriage return, iff isIoProcessor.
*/
void UnitTest::printEndl()
{  if (isIoProcessor()) std::cout << std::endl; } 
 
/*
* Print a line of hashes, iff isIoProcessor.
*/
void UnitTest::endMarker()
{
   if (isIoProcessor()) {
      std::cout << std::endl;
      std::cout << "----------------------------------------------------";
      std::cout << std::endl << std::endl;
   }
}
 
/*
* Open input file.
*/
void 
UnitTest::openInputFile(const std::string& name, std::ifstream& in) 
const
{   
   std::string filename = filePrefix_;
   filename += name;
   in.open(filename.c_str());
   if (in.fail()) {
      std::cout << std::endl;
      std::cout << "Failure to open input file " 
                << filename << std::endl;
      TEST_THROW("Failure to open file");
   }
}
 
/*
* Open output file stream.
*/
void 
UnitTest::openOutputFile(const std::string& name, std::ofstream& out) 
const
{   
   std::string filename = filePrefix_;
   filename += name;
   out.open(filename.c_str());
   if (out.fail()) {
      std::cout << std::endl;
      std::cout << "Failure to open output file " 
                << filename << std::endl;
      TEST_THROW("Failure to open file");
   }
}
 
/*
* Open C file handle.
*/
FILE*
UnitTest::openFile(const std::string& name, const char* mode) 
const
{   
   std::string filename = filePrefix_;
   filename += name;
   FILE* fp = fopen(filename.c_str(), mode);
   if (fp == NULL) {
      std::cout << std::endl;
      std::cout << "Failure of fopen to open file " 
                << filename << std::endl;
      TEST_THROW("Failure to open file");
   }
   return fp;
}
 
/*
* Return integer verbosity level  (0 == silent).
*/
inline int UnitTest::verbose() const
{  return verbose_; }
 
/*
* Return true if two integers are equal (static).
*/
inline bool UnitTest::eq(int s1, int s2)
{  return (s1 == s2); }
 
/*
* Return true if two double precision floats are equal (static).
*/
bool UnitTest::eq(double s1, double s2)
{
   double epsilon = 1.0E-10; 
   return ( fabs(s1-s2) < epsilon ); 
}
 
#endif