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); 
   }
}

/*
* 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