TestingProgram.H

Go to the documentation of this file.

#ifndef __TESTING_PROGRAM_H__
#define __TESTING_PROGRAM_H__

#include "Profiler.H"
#include "Global.H"
#include "ComLine.H"
#include "COMM.H"
#include <cmath>

namespace ix { namespace test {
    class program_command_line : public ix::util::ComLineObject
    {
    public:
      program_command_line(): ix::util::ComLineObject()
      {};
      program_command_line(const char *args[])
        : ix::util::ComLineObject(args)
      {};
      virtual void Initialize(){
        AddOption('h',"help");
        AddOption('l',"list");
        AddOption('v',"verblevel",1,"level");
        AddOption('o',"output",2,"filename");
        AddOption('f',"file",2,"filename");
        AddOption('n',"name",2,"TestName");
        AddOption('d',"debuglevel",1,"level");
        AddOption('p',"enable-profiling",1,"level");
        AddHelp('h',"Print out long version of help and exit.");
        AddHelp('l',"List the available tests and exit.");
        AddHelp('o',"Set the output file to <filename>. (default = stdout)");
        std::ostringstream Ostr;
        Ostr << "Set the test list file to <filename>. (no default).\n\t\t"
             << "The test list file should be a text file with one test\n\t\t"
             << "name per line.";
        AddHelp('f',Ostr.str());
        AddHelp("name","Run test by name. (no default)");
        Ostr.str("");
        Ostr << "Command-line interface for a general testing program.";
        _description.assign(Ostr.str());
        AddHelp('d',"Set the debugging level for the program.(default=1)");
        AddHelp('p',std::string("Enable profiling. Profiling level > 1 enables")+
                std::string(" profiling\n\t\tbarriers. (default=1)"));
        AddHelp('v',std::string("Set the verbosity level for the program.")+
                std::string(" Anything\n\t\tlarger than 2 is debugging level.")+
                std::string("\n\t\tExamples:\n\t\t\t-v (defaults to 1)\n\t\t\t")+
                std::string("-v 0 (silence)\n\t\t\t--verblevel=2")+
                std::string(" (high verbosity)"));
      };
    };

    typedef program_command_line CommandLineType;
    typedef ix::profiler::ProfilerObj ProfilerType;
    typedef ix::global::GlobalObj<std::string,std::string,ProfilerType > Global;
    typedef ix::global::Program<Global,CommandLineType> ProgramType;
  
    template<typename TestObjectType>
    class program : public ProgramType
    {
    protected:
      std::string outFileName;
      std::string testName;
      std::string listFileName;
      TestObjectType testObject;
      typename TestObjectType::Results testResult;
    public:
      program(int narg,char **args) : ProgramType(narg,args){};
      program(Global &inglob) : ProgramType(inglob){};
      program(CommandLineType &incom) : ProgramType(incom){};
      program(CommandLineType &incom,Global &inglob) :
        ProgramType(incom,inglob){};
      virtual int Initialize(){
        if(ProgramType::Initialize()){
          ErrOut("Failed to initialize.\n");
          ErrOut(CommandLine().ErrorReport()+std::string("\n"));
          ErrOut("Use -h,--help for usage help.\n\n");
          ErrOut(CommandLine().ShortUsage()+std::string("\n"));
          return(1);
        }
        int setexit = 0;
        if(!CommandLine().GetOption('h').empty()){
          StdOut(CommandLine().LongUsage());
          setexit = 1;
        }
        if(!CommandLine().GetOption('l').empty()){
          std::ostringstream outStream;
          outStream << "Available tests are:" << std::endl;
          testObject.ListTests(outStream);
          StdOut(outStream.str());
          setexit = 1;
        }
        if(setexit)
          return(1);
        // Verbosity level processing intent:
        // 0 - be silent
        // 1 - normal verbosity
        // 2 - increased verbosity
        // 3 - debug mode engaged (debug stream engaged for root process)
        // 4+ - debug mode (with debugging logged on all processors)
        std::string sverb(CommandLine().GetOption('v'));
        if(!sverb.empty()){
          if(sverb == ".true.")
            SetVerbLevel(1);
          else {
            std::istringstream Istr(sverb);
            int verbLevel;
            Istr >> verbLevel;
            SetVerbLevel(verbLevel);
            if(verbLevel > 1){
              SetDebugStream(ErrStream());
              SetDebugLevel(verbLevel - 1);
            }
          }
        }
        // Process profiling control
        std::string sprof(CommandLine().GetOption('p'));
        if(!sprof.empty()){
          if(sprof == ".true.")
            Profiling(true);
          else {
            std::istringstream Istr(sprof);
            int profLevel;
            Istr >> profLevel;
            if(profLevel == 0)
              Profiling(false);
            if(profLevel >= 1){
              Profiling(true);
            }
          }
        }
        // Process profiling control
        std::string sdebug(CommandLine().GetOption('d'));
        if(!sdebug.empty()){
          if(sdebug == ".true.")
            SetDebugLevel(1);
          else {
            std::istringstream Istr(sdebug);
            int debugLevel;
            Istr >> debugLevel;
            if(debugLevel >= 1)
              SetDebugLevel(debugLevel);
          }
        }
        outFileName  = CommandLine().GetOption('o');
        testName     = CommandLine().GetOption('n');
        listFileName = CommandLine().GetOption('l');
        return(0);
      }

      virtual int Run(){
        FunctionEntry("Run");
        // If the user specified a name, then run only the named test
        if(!testName.empty()){
          // This call runs a test by name
          FunctionEntry(testName);
          testObject.RunTest(testName,testResult);
          FunctionExit(testName);
        } else if(!listFileName.empty()){
          std::ifstream listInf;
          listInf.open(listFileName.c_str());
          if(!listInf){
            std::ostringstream errStream;
            errStream << "Error: Could not open list of tests in file "
                      << listFileName << "." << std::endl;
            ErrOut(errStream.str());
            FunctionExit("Run");
            return(1);
          }
          std::string testName;
          while(std::getline(listInf,testName)){
            FunctionEntry(testName);
            testObject.RunTest(testName,testResult);
            FunctionExit(testName);
          }
          listInf.close();
        }
        else {
          // This call runs all the tests implemented in the testing object
          FunctionEntry("AllTests");
          testObject.Process(testResult);
          FunctionExit("AllTests");
        }
        FunctionExit("Run");
        return(0);
      };

      virtual int Finalize(){
        std::ostringstream outStream;
        outStream << testResult << std::endl;
        if(!outFileName.empty()){
          std::ofstream Ouf;
          Ouf.open(outFileName.c_str());
          if(!Ouf){
            std::ostringstream errStream;
            errStream << "Error: Could not open output file, "
                      << outFileName << " for test ouput."
                      << std::endl;
            ErrOut(errStream.str());
            return(1);
          }
          Ouf << outStream.str();
          Ouf.close();
        } else {
          StdOut(outStream.str());
        }
        std::ostringstream profileStream;
        Report(profileStream);
        if(Profiling())
          StdOut(profileStream.str(),1);
        return(0);
      };
      TestObjectType &TestObject(){return(testObject);};
      virtual ~program(){};
    };
  }
}
#endif