Testing.H

Go to the documentation of this file.

#ifndef __TESTING_H__
#define __TESTING_H__

#include "Parameters.H"

namespace ix {

  namespace test {

    class results : public util::Parameters
    {
    public:
    
      template <typename ValueType>
      void AddResult(const std::string &name,const ValueType &result)
        {
          util::ParamType p;
          p.Key(name);
          std::ostringstream Ostr;
          Ostr << result;
          p.Value(Ostr.str());
          this->push_back(p);
        }
    
      template<typename ValueType>
      void UpdateResult(const std::string &name,const ValueType &result)
        {
          std::ostringstream Ostr;
          Ostr << result;
          results::iterator _thisit = this->begin();
          while(_thisit != this->end()){
            if(_thisit->first == name){
              _thisit->second = Ostr.str();
              return;
            }
            _thisit++;
          }
          return(AddResult<ValueType>(name,result));
        }
    };
  
    template<typename ResultsType = results>
    class manager
    {
    public:
      typedef ResultsType Results;
      typedef void (manager::*TestFunctionType)(ResultsType &);
      typedef std::map<std::string,TestFunctionType> FunctionMapType;
      virtual void Prologue(){};
      virtual void Process(Results &results){
        Prologue();
        typename FunctionMapType::iterator testFunctionMapIterator = testFunctionMap.begin();
        while(testFunctionMapIterator != testFunctionMap.end()){
          TestFunctionType TestFunction = testFunctionMapIterator++->second;
          (this->*TestFunction)(results);
        }
        Epilogue();
      };
      virtual void ProcessTests(std::list<std::string> &names,Results &results){
        Prologue();
        std::list<std::string>::iterator nameIterator = names.begin();
        while(nameIterator != names.end())
          RunTest(*nameIterator++,results);
        Epilogue();
      };
      virtual void RunTest(const std::string &name,Results &results){
        typename FunctionMapType::iterator testFunctionMapIterator = testFunctionMap.find(name);
        if(testFunctionMapIterator != testFunctionMap.end()){
          Prologue();
          TestFunctionType TestFunction = testFunctionMapIterator->second;
          (this->*TestFunction)(results);
          Epilogue();
        }
      };
      virtual void Epilogue(){};
      virtual void AddTest(const std::string &testName,TestFunctionType TestFunc){
        testFunctionMap[testName] = TestFunc;
      };
      FunctionMapType &FunctionMap(){return(testFunctionMap);};
      virtual void ListTests(std::ostream &outStream){
        typename FunctionMapType::iterator testFunctionMapIterator = testFunctionMap.begin();
        while(testFunctionMapIterator != testFunctionMap.end())
          outStream << testFunctionMapIterator++->first << std::endl;
      };
      virtual ~manager(){}; 
    protected:
      FunctionMapType testFunctionMap;
    };
  };
};
#endif