#include <UnitTest.h>

Collaboration diagram for EL::UnitTest:

Public Member Functions
	UnitTest (const std::string &val_name, std::string base_path="")
	effects: standard constructor guarantee: storng failures: out of memory II More...

int	run (const Driver &driver) const
	effects: perform a unit test with the given driver returns: EXIT_SUCCESS on success, EXIT_FAILURE on failure guarantee: basic failures: unit test failures requires: !sample.empty() More...

Public Attributes
std::string	name
	description: the name of the unit test More...

std::string	base_path
	description: the base path for the data files More...

bool	scanNEvents {false}
	whether to scan for number of events More...

bool	gridInput {false}
	whether to use the inputs from the grid dataset More...

bool	cleanup
	description: whether we clean up the submit directory afterwards More...

bool	testOutput
	description: whether to test creating output n-tuples More...

std::string	location
	description: the location for the unit test More...

SH::DiskOutput *	outputDisk
	description: the output disk More...

bool	testFileExecute
	whether to test the fileExecute method More...

Detailed Description

Definition at line 16 of file PhysicsAnalysis/D3PDTools/EventLoopTest/EventLoopTest/UnitTest.h.

Constructor & Destructor Documentation

◆ UnitTest()

EL::UnitTest::UnitTest	(	const std::string &	val_name,
		std::string	base_path = `""`
	)

effects: standard constructor guarantee: storng failures: out of memory II

Definition at line 43 of file PhysicsAnalysis/D3PDTools/EventLoopTest/Root/UnitTest.cxx.

     : name (val_name), base_path (val_base_path), cleanup (true), testOutput (true), outputDisk (0),
       testFileExecute (true)
   {
     if (base_path.empty())
       base_path = "$ROOTCOREBIN/data/EventLoop/";
   }

Member Function Documentation

◆ run()

int EL::UnitTest::run ( const Driver & driver ) const

effects: perform a unit test with the given driver returns: EXIT_SUCCESS on success, EXIT_FAILURE on failure guarantee: basic failures: unit test failures requires: !sample.empty()

Definition at line 54 of file PhysicsAnalysis/D3PDTools/EventLoopTest/Root/UnitTest.cxx.

   {
     std::vector<std::string> files;
     std::vector<TH1*> histos;
  
     for (unsigned iter = 0, end = 3; iter != end; ++ iter)
     {
       std::ostringstream path;
       path << base_path << "test_ntuple" << iter << ".root";
       TString input = path.str();
       gSystem->ExpandPathName (input);
       files.push_back (input.Data());
       std::unique_ptr<TFile> file (TFile::Open (input.Data(), "READ"));
       RCU_ASSERT_SOFT (file.get() != 0);
       TH1 *hist = dynamic_cast<TH1*>(file->Get ("hist_n"));
       RCU_ASSERT_SOFT (hist != 0);
       histos.push_back(hist);
       hist->SetDirectory (0);
     };
     std::string tree ("physics");
  
  
     SH::SampleHandler samples;
  
     std::vector<std::unique_ptr<SH::Sample> > mysamples;
     if (gridInput)
     {
       std::unique_ptr<SH::SampleGrid> mysample;
       mysample.reset (new SH::SampleGrid ("user.krumnack:user.krumnack.EventLoopTest.2019-03-25.dataset0"));
       mysample->meta()->setString (SH::MetaFields::gridName, "user.krumnack:user.krumnack.EventLoopTest.2019-03-25.dataset0");
       mysample->meta()->setString (SH::MetaFields::gridFilter, SH::MetaFields::gridFilter_default);
       mysamples.push_back (std::move (mysample));
       mysample.reset (new SH::SampleGrid ("user.krumnack:user.krumnack.EventLoopTest.2019-03-25.dataset1"));
       mysample->meta()->setString (SH::MetaFields::gridName, "user.krumnack:user.krumnack.EventLoopTest.2019-03-25.dataset1");
       mysample->meta()->setString (SH::MetaFields::gridFilter, SH::MetaFields::gridFilter_default);
       mysamples.push_back (std::move (mysample));
     } else
     {
       std::unique_ptr<SH::SampleLocal> mysample;
       mysample.reset (new SH::SampleLocal ("dataset0"));
       mysample->add (files[0]);
       mysamples.push_back (std::move (mysample));
       mysample.reset (new SH::SampleLocal ("dataset1"));
       mysample->add (files[1]);
       mysample->add (files[2]);
       mysamples.push_back (std::move (mysample));
     }
     {
       TH1 *hist = 0;
       hist = dynamic_cast<TH1*>(histos[0]->Clone ("hist"));
       mysamples[0]->meta()->addReplace (hist);
  
       hist = dynamic_cast<TH1*>(histos[1]->Clone ("hist"));
       hist->Add (histos[2]);
       mysamples[1]->meta()->addReplace (hist);
     }
     for (auto& mysample : mysamples)
       samples.add (mysample.release());
  
     samples.setMetaString (SH::MetaFields::treeName, tree);
  
     samples.print ();
  
     for (unsigned iter = 0, end = histos.size(); iter != end; ++ iter)
       delete histos[iter];
  
     RCU_ASSERT (samples.size() > 0);
  
     if (scanNEvents)
       SH::scanNEvents (samples);
  
     TString submitDir;
     if (location.empty())
     {
       submitDir = "EventLoopTest-" + name;
     } else submitDir = location;
     gSystem->ExpandPathName (submitDir);
  
     try
     {
       UnitTestAlg alg;
       alg.makeOutput = testOutput;
  
       EL::Job job;
       // job.options()->setDouble (Job::optD3PDPerfStats, 1);
       job.options()->setDouble ("jobOpt", 42);
       // job.options()->setDouble (Job::optPerfTree, 1);
       // job.options()->setDouble (EL::Job::optCacheSize, 10*1024*1024);
       // job.options()->setDouble (Job::optPrintPerFileStats, 1);
       {
     SH::SampleHandler sh = samples;
     sh.setMetaString ("mymeta", "test");
     job.sampleHandler (sh);
       }
       job.algsAdd (new UnitTestAlg (alg));
       bool outputDone = outputDisk == 0;
       for (Job::outputMIter outputStream = job.outputBegin(),
          end = job.outputEnd(); outputStream != end; ++ outputStream)
       {
     if (!outputDone)
     {
       outputStream->output (outputDisk);
       outputDone = true;
     }
       }
  
       if (!cleanup)
     ANA_MSG_INFO ("placing temporary files in: " << submitDir);
       job.options()->setString (Job::optSubmitDirMode, "unique");
       std::string output = driver.submit (job, submitDir.Data());
  
       for (std::size_t iter = 0, end = samples.size(); iter != end; ++ iter)
       {
         ANA_MSG_INFO ("looking at sample " << samples[iter]->name());
     TH1 *ref_hist = dynamic_cast<TH1*>(samples[iter]->meta()->get ("hist"));
     if (ref_hist != 0)
     {
       SH::SampleHandler sh;
       sh.load ((output + "/hist").c_str());
       SH::SamplePtr sample = sh.get (samples[iter]->name());
       if (sample.empty())
         RCU_THROW_MSG ("could not find histogram sample " + samples[iter]->name());
  
       if (testFileExecute)
       {
         TH1 *file_executes = dynamic_cast<TH1*>(sample->readHist ("file_executes"));
         RCU_ASSERT_SOFT (file_executes != 0);
             ANA_MSG_INFO ("file executes: " << file_executes->GetEntries() << " " << samples[iter]->makeFileList().size());
         RCU_ASSERT_SOFT (file_executes->GetEntries() == samples[iter]->makeFileList().size());
       }
  
       TH1 *hist = dynamic_cast<TH1*>(sample->readHist ("el_n"));
       if (samples[iter]->getNumEntries() == 0)
       {
         RCU_ASSERT_SOFT (hist == 0);
       } else
       {
         RCU_ASSERT_SOFT (dynamic_cast<TH1*>(sample->readHist ("el_n2")));
         RCU_ASSERT_SOFT (dynamic_cast<TList*>(sample->readHist ("alpha")));
         RCU_ASSERT_SOFT (sample->readHist ("beta/dir/hist"));
         if (hist == 0)
           RCU_THROW_MSG ("didn't find histogram el_n in sample " + sample->name());
         if (hist->GetNbinsX() != ref_hist->GetNbinsX())
           RCU_THROW_MSG ("bin missmatch between histograms");
         for (int bin = 0, end = hist->GetNbinsX()+2; bin != end; ++ bin)
         {
           if (hist->GetBinContent (bin) != ref_hist->GetBinContent (bin))
           {
         std::ostringstream str;
         str << "bin content missmatch in bin " << bin
             << " found " << hist->GetBinContent (bin)
             << " expected " << ref_hist->GetBinContent (bin);
         RCU_THROW_MSG (str.str());
           }
         }
       }
       TH1 *count = dynamic_cast<TH1*>(sample->readHist ("EventLoop_EventCount"));
       if (samples[iter]->getNumEntries() > 0 && count == 0)
         RCU_THROW_MSG ("didn't find histogram EventLoop_EventCount");
     }
     if (testOutput && samples[iter]->getNumEntries() > 0)
     {
       SH::SampleHandler sh;
       sh.load ((output + "/output-out").c_str());
       SH::Sample *const sample = sh.get (samples[iter]->name());
       if (!sample)
         RCU_THROW_MSG ("output dataset not found for " + samples[iter]->name());
       sample->meta()->setString (SH::MetaFields::treeName, "tree");
       if (ref_hist && samples[iter]->getNumEntries() != ref_hist->GetEntries())
       {
         std::ostringstream str;
         str << "tree entries missmatch found " << samples[iter]->getNumEntries()
         << " expected " << ref_hist->GetEntries();
         RCU_THROW_MSG (str.str());
       }
     }
       }
       if (cleanup)
     gSystem->Exec (("rm -rf " + output).c_str());
       return EXIT_SUCCESS;
     } catch (std::exception& e)
     {
       std::cout << "exception caught in unit test: " << e.what() << std::endl;
       return EXIT_FAILURE;
     } catch (std::string& e)
     {
       std::cout << "exception caught in unit test: " << e << std::endl;
       return EXIT_FAILURE;
     } catch (...)
     {
       std::cout << "unknown exception caught in unit test" << std::endl;
       return EXIT_FAILURE;
     }
   }