JTest_t.hh

Go to the documentation of this file.

#ifndef __JTEST_T__
#define __JTEST_T__

#include <istream>
#include <ostream>

#include "Jeep/JProperties.hh"

#include <TROOT.h>
#include <TObject.h>
#include <TH1.h>
#include <TH2.h>
#include <TH3.h>

/**
 * \author rgruiz
 */
  
/**
 * Class dedicated to standardize the title of the graphical objects produced by the JTest_t() derived classes.
 */
class JResultTitle:
  public JProperties
{
public:
  /**
   * Default constructor
   */
  JResultTitle():
    name      (" "),
    parameter (" "),
    passed    (" "),
    value     (-9999.0)
  {
    this->setEndOfLine(":");
    this->insert(gmake_property(name));
    this->insert(gmake_property(parameter));
    this->insert(gmake_property(value));
    this->insert(gmake_property(passed));
  };
  
  /**
   * Constructor
   *
   * \param Name Test name
   * \param Parameter Name of the parameter used to decide if the test passes.
   * \param Value Value of the parameter used to decide if the test passes.
   * \param Passed True if the test passes, false if it fails.
   */
  JResultTitle(std::string Name, std::string Parameter, bool Passed, double Value):
    name      (Name),
    parameter (Parameter),
    value     (Value)
  {
    this->setEndOfLine(":");
    passed = Passed ? "TRUE" : "FALSE";
    
    this->insert(gmake_property(name));
    this->insert(gmake_property(parameter));
    this->insert(gmake_property(value));
    this->insert(gmake_property(passed));
  }

  /**
   * Returns a standard string to be used as title of a graphical root object.
   */
  std::string getTitle(){
    return MAKE_STRING(*this);
  }

  std::string   name;      /*!< Test name.                                       */
  std::string   parameter; /*!< Name of the parameter used to evaluate the test. */
  std::string   passed;    /*!< Human readable version of "passed".              */
  double        value;     /*!< Value of the parameter used to evaluate the test.*/
};

/**
 * Class dedicated to standardize the title of the graphical objects produced by the JTest_t() derived classes.
 */
class JResultMessage
{
public:
  /**
   * Default constructor
   */
  JResultMessage():
    testName    (" "),
    nameA       (" "),
    nameB       (" "),
    parameter   (" "),
    value       (-9999.0),
    threshold   (-9999.0),
    passed      (false)
  {};

  /**
   * Constructor
   *
   * \param testName Test name
   * \param nameA Name of the first histogram.
   * \param nameB Name of the second histogram.
   * \param parameter Name of the parameter used for the test.
   * \param threshold Threshold value for the tested parameter.
   * \param value Value of the tested parameter.
   * \param passed true if the test is passed.
   */
  JResultMessage(std::string testName, std::string nameA, std::string nameB, std::string parameter, double value, double threshold, bool passed):
    testName    (testName),
    nameA       (nameA),
    nameB       (nameB),
    parameter   (parameter),
    value       (value),
    threshold   (threshold),
    passed      (passed)
  {
    passed_h = passed ? "PASSED" : "FAILED";
  };

  /**
   * Read test parameters from input.
   *
   * \param  in            input stream
   * \return               input stream
   */
  std::istream& read(std::istream& in) {
    in >>
      testName  >>
      nameA     >>
      nameB     >>
      parameter >>
      value     >>
      threshold >>
      passed_h;    
    passed = (passed_h == "PASSED") ? 1 : 0;
    return in;
  };

  /**
   * Returns a standard string to be used as title of a graphical root object.
   */
  std::string getMessage(){
    return MAKE_STRING(testName  << " " <<
                       nameA     << " " <<
                       nameB     << " " <<
                       parameter << " " <<
                       value     << " " <<
                       threshold << " " <<
                       passed_h);
  }

  std::string   testName;   /*!< Test name.                                   */
  std::string   nameA;      /*!< Name of the first histogram.                 */
  std::string   nameB;      /*!< Name of the second histogram.                */
  std::string   parameter;  /*!< Parameter evaluated by the test".            */
  double        value;      /*!< Value of the parameter evaluated by the test.*/
  double        threshold;  /*!< Threshold to evaluate the parameter.         */
  bool          passed;     /*!< True if the test passed.                     */
  std::string   passed_h;   /*!< Human readable version of passed.            */
};

/**
 * Structure containing the result of the test. It contains a bool and a message to print
 */
struct JTestResult{

  JTestResult(){
    passed             = false;
    message            = "0";
    obj                = NULL;
    testName           = "";           
    histogramA         = "";
    histogramB         = "";
    fileA              = "";
    fileB              = "";
    parameterName      = "";
    parameterValue     = 0.0;
    parameterThreshold = 0.0;
    passed             = false;           
    passed_h           = "";
  }

  JTestResult(std::string test, std::string hA, std::string hB, std::string fA, std::string fB, std::string parameter, double value, double threshold, TObject* o, bool pass):
    testName            (test),
    histogramA          (hA),
    histogramB          (hB),
    fileA               (fA),
    fileB               (fB),
    parameterName       (parameter),
    parameterValue      (value),
    parameterThreshold  (threshold),
    obj                 (o),
    passed              (pass)
  {
    passed_h = passed ? "PASSED" : "FAILED";
  }

  std::string print(std::string separator) const {
    return MAKE_STRING(testName                                                         << separator <<
                       fileA     .substr (fileA.rfind ('/') + 1 , fileA.npos)           <<
                       histogramA.substr (histogramA.rfind (':') + 1 , histogramA.npos) << separator <<
                       fileB     .substr (fileB.rfind ('/') + 1 , fileB.npos)           << 
                       histogramB.substr (histogramB.rfind (':') + 1 , histogramB.npos) << separator <<
                       parameterName                                                    << separator <<
                       parameterValue                                                   << separator <<
                       parameterThreshold                                               << separator <<
                       passed_h);
  }
  
  std::string printASCII() const {
    return MAKE_STRING(testName                                                         << ";" <<
                       fileA     .substr (fileA.rfind ('/') + 1 , fileA.npos)           <<
                       histogramA.substr (histogramA.rfind (':') + 1 , histogramA.npos) << ";" <<
                       fileB     .substr (fileB.rfind ('/') + 1 , fileB.npos)           << 
                       histogramB.substr (histogramB.rfind (':') + 1 , histogramB.npos) << ";" <<
                       parameterName                                                    << ";" <<
                       parameterValue                                                   << ";" <<
                       parameterThreshold                                               << ";" <<
                       passed);
  }
  
  std::string testName;           /*!< Test name                                */
  std::string histogramA;         /*!< Name of histogram A                      */
  std::string histogramB;         /*!< Name of histogram B                      */ 
  std::string fileA;              /*!< Name of file A                           */
  std::string fileB;              /*!< Name of file B                           */
  std::string parameterName;      /*!< Name of the tested parameter             */
  double      parameterValue;     /*!< Value of the tested parameter            */
  double      parameterThreshold; /*!< Threshold for the tested parameter       */
  TObject*    obj;                /*!< Graphical output summarising the test.   */
  bool        passed;             /*!< Test result. True if test passed.        */
  std::string passed_h;           /*!< Human readable version of passed         */
  std::string message;            /*!< Human readable message with test result. */
};

/**
 * Interface to read input and write output for TObject tests.\n
 * This is an abstract class from which the different tests are derived.\n
 * All tests have in common the methods from this interface.\n
 * For each test, the parameters are passed through an istream, and parsed by the read() method.\n
 * For each test, the different results are stored in the results buffer.\n
 * The write() method is used to print a message with the result of the test.\n
 * The save() method is used to save a graphical output with the test results into a .root file.\n
 * The clear() method clears the results buffer.
 * For a list of available tests see JTestDictionary()
 */
class JTest_t
{ 
  
public:

  std::vector<JTestResult> results; /*!< Buffer to store results of multiple tests.*/
 
  /**
   * Read test parameters from input.
   *
   * \param  in            input stream
   * \return               input stream
   */
  virtual std::istream& read (std::istream& in) = 0;

  /**
   * Write test result to output.
   *
   * \param  out           output stream
   * \param  delimiter     field delimiter
   * \param  failures  If true, write only failures.
   * \return               output stream
   */
  virtual std::ostream& write(std::ostream& out, std::string delimiter = " ", bool failures = false) const = 0;

  /**
   * Tests compatibility between two TObjects.
   * 
   * \param o1 First object
   * \param o2 Second object
   */
  virtual void test(TObject* o1, TObject* o2) = 0;

  /**
   * Writes the test result to root file
   * \param f A ROOT file 
   * \param path Path in root file.
   * \param failures  If true, write only failures.
   */
  virtual void save(TFile* f , std::string path, bool failures = false) = 0;
  
  /**
   * Clear results
   */
  virtual void clear() = 0;
  
  /**
   * Get test name.
   */
  virtual std::string getName() = 0;

  /**
   * Get test parameter.
   */
  virtual std::string getParameter() = 0;
  
}; 
  
#endif