#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
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()

Public Attributes
std::string	name
	description: the name of the unit test
std::string	base_path
	description: the base path for the data files
bool	scanNEvents {false}
	whether to scan for number of events
bool	gridInput {false}
	whether to use the inputs from the grid dataset
bool	cleanup
	description: whether we clean up the submit directory afterwards
bool	testOutput
	description: whether to test creating output n-tuples
std::string	location
	description: the location for the unit test
SH::DiskOutput *	outputDisk
	description: the output disk
bool	testFileExecute
	whether to test the fileExecute method

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;
    }
  }