TVldValidate.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////
// $Id: TVldValidate.cxx,v 1.1 2011/01/18 05:49:20 finch Exp $
//
// TVldValidate
//
// TVldValidate is a test harness for Validity package
//
// Author:  R. Hatcher 2001.01.03
//
////////////////////////////////////////////////////////////////////////////

#include "TVldValidate.hxx"

#include "TVldContext.hxx"
#include "TVldRange.hxx"

#include "TFile.h"
#include "TSystem.h"

#include <TSK_DBI_Log.hxx>
#include <MsgFormat.h>
using std::endl;
#include <MsgFormat.h>

#include <iomanip>
#include <map>

ClassImp(TVldValidate)

//______________________________________________________________________________
TVldValidate::TVldValidate()
{
   // Default constructor



}

//______________________________________________________________________________
TVldValidate::~TVldValidate()
{
   // delete all the owned sub-objects

}

//______________________________________________________________________________
Bool_t TVldValidate::RunAllTests()
{
   Int_t fail  = 0;
   Int_t tests = 0;

   tests++;
   if (!TestTimeStamp()) fail++;

   tests++;
   if (!TestContext()) fail++;

   tests++;
   if (!TestRange()) fail++;

   tests++;
   if (!TestFileIO()) fail++;

   SK_DBI_Info(  "VldValidate::RunAllTests had " << fail
      << " failures in " << tests << " tests"
      << "  " << endl);

   return (!fail);

}

//______________________________________________________________________________
Bool_t TVldValidate::TestTimeStamp(void)
{
   // Test TVldTimeStamp behaviour

   cout << "Test TVldTimeStamp" << endl << endl;

   Int_t fail = 0;
   Int_t tests = 0;

   cout << "default ctor:    " << flush;
   TVldTimeStamp defctor;
   defctor.Print("");

   SK_DBI_Info(  " Test output to MSG service: " << defctor << "  " << endl);

   time_t nowtime;
   time(&nowtime);
   long int nsec = 12345;

   struct timespec nowts;
   nowts.tv_sec  = nowtime;
   nowts.tv_nsec = nsec;

   SK_DBI_Info(  " original timespec:  {" << nowtime << "," << nsec << "} " << "  ");

   TVldTimeStamp vldnow(nowts);
   // do these as separate       // reuses a common buffer space
      SK_DBI_Log( " vldnow as timespec: " << vldnow.AsString("2") << "  ");
   SK_DBI_Info(  " vldnow default AsString: " << vldnow.AsString("") << "  ");
   SK_DBI_Info(  " vldnow local   AsString: " << vldnow.AsString("l") << "  ");

   struct timespec thents = vldnow.GetTimeSpec();

   SK_DBI_Info(  " recovered timespec: {" << thents.tv_sec << "," << thents.tv_nsec << "} " << "  ");

   tests++;
   if (nowts.tv_sec != thents.tv_sec || nowts.tv_nsec != thents.tv_nsec) fail++;


   // test various ctor's
   // all should map to Jan 04 2001, 01:26:03 GMT
   time_t   mytime = 978571563;
   Long_t   arbitrary = 123456; // fake nsec part

   timespec mytimespec = {mytime,arbitrary};
   TVldTimeStamp vtr(mytime,arbitrary);
   TVldTimeStamp vtsr(mytimespec);

   Int_t    year  = 2001;
   Int_t    month = 1;
   Int_t    day   = 4;
   Int_t    hour  = 1;
   Int_t    min   = 26;
   Int_t    sec   = 3;
   Int_t    secOffset = vtr.GetZoneOffset();

   TVldTimeStamp vl1(year,month,day,hour,min,sec,arbitrary);
   TVldTimeStamp vl2(year,month,day,hour,min,sec,arbitrary,kFALSE,-secOffset);
   TVldTimeStamp vl3(year,month,day,hour-8,min,sec,arbitrary,kTRUE,8*60*60);
   TVldTimeStamp vl4(year,month,day-1,hour+16,min,sec,arbitrary,kTRUE,8*60*60);
// this will only give correct results in PST zone
   TVldTimeStamp vlpst(year,month,day,hour-8,min,sec,arbitrary,kFALSE);

   TVldTimeStamp vly1(year-1900,month,day,hour,min,sec,arbitrary);
   TVldTimeStamp vly2(year-2000,month,day,hour,min,sec,arbitrary);

   Int_t    date = year*10000 + month*100 + day;
   Int_t    time = hour*10000 + min*100 + sec;

   TVldTimeStamp vs1(date,time,arbitrary);
   TVldTimeStamp vs2(date,time,arbitrary,kFALSE,-secOffset);
// these next two aren't a smart way of dealing with local time
   TVldTimeStamp vs3(date-1,time+160000,arbitrary,kTRUE,8*60*60);
   TVldTimeStamp vs4(date,time-80000,arbitrary,kTRUE,8*60*60);
// the next two will only give correct results in PST zone
   TVldTimeStamp vspst1(date,time-80000,arbitrary,kFALSE);
   TVldTimeStamp vspst2(date-1,time+160000,arbitrary,kFALSE);
   TVldTimeStamp vsy1(date-19000000,time,arbitrary);
   TVldTimeStamp vsy2(date-20000000,time,arbitrary);

   SK_DBI_Info(  " current TimeOffset is " << vtr.GetZoneOffset() << "  ");

   SK_DBI_Info( "  ");
   SK_DBI_Info( " std (vtr) " << vtr.AsString()  << "  ");

   TString byhand = "Thu, 04 Jan 2001 01:26:03 +0000 (GMT) +   123456 nsec";
   TString byclass = vtr.AsString();
   tests++;
   if (byhand != byclass) {
      SK_DBI_Info( " strings don't match!" << "  ");
      fail++;
   }
   else {
      SK_DBI_Info( " strings match as they should " << "  ");
   }

   tests++;   if (!CompareTimeStamps(" vtsr     ",vtsr,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vl1      ",vl1,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vl2      ",vl2,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vl3      ",vl3,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vl4      ",vl4,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vly1     ",vly1,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vly2     ",vly2,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vs1      ",vs1,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vs2      ",vs2,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vs3      ",vs3,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vs4      ",vs4,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vsy1     ",vsy1,vtr)) fail++;
   tests++;   if (!CompareTimeStamps(" vsy2     ",vsy2,vtr)) fail++;

   if (secOffset == 28800) {
      tests++;   if (!CompareTimeStamps(" vlpst    ",vlpst,vtr)) fail++;
      tests++;   if (!CompareTimeStamps(" vspst1   ",vspst1,vtr)) fail++;
      tests++;   if (!CompareTimeStamps(" vspst2   ",vspst2,vtr)) fail++;
   }

   SK_DBI_Info( " next test expects to be a mismatch" << "  ");
   CompareTimeStamps(" now is unlikely to match arbitrary time ",vldnow,vtr);

   SK_DBI_Info( " Alternative formats" << "  ");
   SK_DBI_Info( " \"\"       " << vtr.AsString("")   << "  ");
   SK_DBI_Info( " \"l\"      " << vtr.AsString("l")  << "  ");
   SK_DBI_Info( " \"c\"      " << vtr.AsString("c")  << "  ");
   SK_DBI_Info( " \"lc\"     " << vtr.AsString("lc") << "  ");
   SK_DBI_Info( " \"2\"      " << vtr.AsString("2")  << "  ");

   tests++; if (vtr.GetDate() != date) fail++;
   tests++; if (vtr.GetTime() != time) fail++;

   MsgFormat i6("%6d");

   SK_DBI_Info(  "  GMT    GetDate: " << vtr.GetDate()
      << "   GetTime: " << i6(vtr.GetTime()) << "  ");
   SK_DBI_Info(  "  local  GetDate: " << vtr.GetDate(kFALSE)
      << "   GetTime: " << i6(vtr.GetTime(kFALSE)) << "  ");

   SK_DBI_Info(  "VldValidate::TestTimeStamp had " << fail
      << " failures in " << tests << " tests"
      << "  " << endl);

   return (!fail);

}

//______________________________________________________________________________
Bool_t TVldValidate::CompareTimeStamps(const char *label,
                                      TVldTimeStamp& test, TVldTimeStamp& std)
{
   if (test == std) {
      SK_DBI_Info( "    exact match " << "  ");
      return kTRUE;
   }
   else {
      SK_DBI_Info( " ** mismatch ** " << "  ");
      SK_DBI_Info( "            " << test.AsString() << "  ");
      SK_DBI_Info( "            " << std.AsString() << "  ");
      return kFALSE;
   }
}

//______________________________________________________________________________
Bool_t TVldValidate::TestContext(void)
{
   // Test TVldContext

   cout << "Test TVldContext" << endl << endl;

   Int_t fail = 0;

   map<TVldContext,long> vldc_map;
   long int entry = 0;

   TVldContext defctor;
   SK_DBI_Info( "VldContext default ctor: "
                         << defctor.AsString("") << "  ");
   vldc_map[defctor] = entry++;
//   gSystem->Sleep(2000); // sleep for 2 sec so timestamp advances

   TVldContext defctor2;
   vldc_map[defctor2] = entry++;
//   gSystem->Sleep(2000); // sleep for 2 sec so timestamp advances

   // for the same timestamp try different combinations of detector & simflag
   // in the expected order that it will sort
   // (detector primary over simflag --> detector in outer loop)
   SK_DBI_Info(  "VldContext test map<TVldContext,long>" << "  ");
   TVldTimeStamp now;
   for (Int_t ibit_det = 0; ibit_det<3; ibit_det++) {
      DbiDetector::Detector_t det =
         (DbiDetector::Detector_t) (1<<ibit_det);
      for (Int_t ibit_sim = 0; ibit_sim<4; ibit_sim++) {
         DbiSimFlag::SimFlag_t sim = (DbiSimFlag::SimFlag_t) (1<<ibit_sim);

         TVldContext vldc(det,sim,now);
//         MSG("Vld",Msg::kInfo)
//            << " entry " << setw(2) << entry << " : "
//            << vldc.AsString()
//            << endl;
         vldc_map[vldc] = entry++;

      }
   }
   typedef map<TVldContext,long>::const_iterator vcl_itr;
   int expect = 0;
   bool pass  = true;
   for (vcl_itr p = vldc_map.begin(); p != vldc_map.end(); ++p, ++expect) {
      TVldContext ac = p->first;
      long       al = p->second;
      if (al != expect) pass = false;
      SK_DBI_Info(  "   " << setw(2) << expect << " ? " << setw(2) << al << " : "
         << ac.AsString()
         << "  ");
   }
   if (!pass) fail++;


   SK_DBI_Info(  " Test output to MSG service: " << defctor << "  ");

   SK_DBI_Info(  "VldValidate::TestContext had " << fail << " failures "
      << "  " << endl);

   return (!fail);
}

//______________________________________________________________________________
Bool_t TVldValidate::TestRange(void)
{
   // Test TVldRange

   cout << "Test TVldRange" << endl << endl;

   Int_t fail = 0;

   cout << "default ctor:          ";
   TVldRange defctor;
   defctor.Print("");

   SK_DBI_Info(  " Test output to MSG service: " << defctor << "  ");

   SK_DBI_Info(  "VldValidate::TestRange had " << fail << " failures "
      << "  " << endl);

   return (!fail);

}

//______________________________________________________________________________
Bool_t TVldValidate::TestFileIO(void)
{
   // Test write/read Validity objects to/from a file

   cout << "Test file IO" << endl << endl;

//   UInt_t sleep_msec = 2000;

   // ****************** OUTPUT *******************************

   TFile fout("vld_io.root","RECREATE");

   TVldTimeStamp out_ts;
   TVldContext   out_c;
   TVldRange     out_r;

//VldTimeStamp not derived from TObject
//   out_ts.Write();
   out_c.Write();
   out_r.Write();

   fout.ls();
   fout.Close();

   // ****************** Pause *******************************

   SK_DBI_Info( "  " << endl);
//   gSystem->Sleep(sleep_msec);
   TVldContext pause_c;

   // ****************** INPUT *******************************

   TFile fin("vld_io.root","READ");
   fin.ls();

//   TVldTimeStamp *in_ts = dynamic_cast<VldTimeStamp*>(fin.Get("VldTimeStamp"));
   TVldContext *in_c = dynamic_cast<TVldContext*>(fin.Get("VldContext"));

   fin.Close();

   // ****************** Comparison *******************************

   SK_DBI_Info( "  " << endl);

//   gSystem->Sleep(sleep_msec);
   TVldContext final_c;

//   out_ts.Print();
//   in_ts->Print();

   SK_DBI_Info( " wrote  TVldContext: " << out_c << "  ");
   SK_DBI_Info( " interm TVldContext: " << pause_c << "  ");
   SK_DBI_Info( " read   TVldContext: " << (*in_c) << "  ");
   SK_DBI_Info( " final  TVldContext: " << final_c << "  ");

   Int_t fail = 0;

//   cout << "default ctor:          ";
//   TVldRange defctor;
//   defctor.Print("");


   SK_DBI_Info(  "VldValidate::TestRange had " << fail << " failures "
      << "  " << endl);

   return (!fail);

}

//______________________________________________________________________________