edm::test::TestProcessor Class Reference

#include <TestProcessor.h>

Public Types
using	Config = TestProcessorConfig

Public Member Functions
std::string const &	labelOfTestModule () const
void	setEventNumber (edm::EventNumber_t)
void	setLuminosityBlockNumber (edm::LuminosityBlockNumber_t)
void	setRunNumber (edm::RunNumber_t)
template<typename... T>
edm::test::Event	test (T &&...iArgs)
void	testBeginAndEndJobOnly ()
template<typename... T>
edm::test::LuminosityBlock	testBeginLuminosityBlock (edm::LuminosityBlockNumber_t iNum, T &&...iArgs)
template<typename... T>
edm::test::Run	testBeginRun (edm::RunNumber_t iNum, T &&...iArgs)
template<typename... T>
edm::test::LuminosityBlock	testEndLuminosityBlock (T &&...iArgs)
template<typename... T>
edm::test::Run	testEndRun (T &&...iArgs)
void	testLuminosityBlockWithNoEvents ()
	TestProcessor (Config const &iConfig, ServiceToken iToken=ServiceToken())
void	testRunWithNoLuminosityBlocks ()
	~TestProcessor ()(false)

Private Member Functions
void	beginJob ()
void	beginLuminosityBlock ()
void	beginRun ()
void	endJob ()
std::shared_ptr< LuminosityBlockPrincipal >	endLuminosityBlock ()
std::shared_ptr< RunPrincipal >	endRun ()
void	event ()
const TestProcessor &	operator= (const TestProcessor &)=delete
template<typename T >
void	put (std::pair< edm::EDPutTokenT< T >, std::unique_ptr< T >> &&iPut)
template<typename T >
void	put (std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&iPut)
void	put (unsigned int, std::unique_ptr< WrapperBase >)
void	setupProcessing ()
void	teardownProcessing ()
template<typename T , typename... U>
edm::test::LuminosityBlock	testBeginLuminosityBlockImpl (edm::LuminosityBlockNumber_t iNum, std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&iPut, U &&...iArgs)
edm::test::LuminosityBlock	testBeginLuminosityBlockImpl (edm::LuminosityBlockNumber_t)
template<typename T , typename... U>
edm::test::Run	testBeginRunImpl (edm::RunNumber_t iNum, std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&iPut, U &&...iArgs)
edm::test::Run	testBeginRunImpl (edm::RunNumber_t)
template<typename T , typename... U>
edm::test::LuminosityBlock	testEndLuminosityBlockImpl (std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&iPut, U &&...iArgs)
edm::test::LuminosityBlock	testEndLuminosityBlockImpl ()
template<typename T , typename... U>
edm::test::LuminosityBlock	testEndRunImpl (std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&iPut, U &&...iArgs)
edm::test::Run	testEndRunImpl ()
template<typename T , typename... U>
edm::test::Event	testImpl (std::pair< edm::EDPutTokenT< T >, std::unique_ptr< T >> &&iPut, U &&...iArgs)
template<typename T , typename... U>
edm::test::Event	testImpl (std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&iPut, U &&...iArgs)
edm::test::Event	testImpl ()
	TestProcessor (const TestProcessor &)=delete

Private Attributes
std::unique_ptr< ExceptionToActionTable const >	act_table_
std::shared_ptr< ActivityRegistry >	actReg_
bool	beginJobCalled_ = false
bool	beginLumiCalled_ = false
bool	beginRunCalled_ = false
std::shared_ptr< BranchIDListHelper >	branchIDListHelper_
std::vector< std::pair< edm::BranchDescription, std::unique_ptr< WrapperBase > > >	dataProducts_
std::shared_ptr< EventSetupTestHelper >	esHelper_
std::shared_ptr< eventsetup::EventSetupProvider >	esp_
std::unique_ptr< eventsetup::EventSetupsController >	espController_
EventNumber_t	eventNumber_ = 1
std::unique_ptr< HistoryAppender >	historyAppender_
std::string	labelOfTestModule_
LuminosityBlockNumber_t	lumiNumber_ = 1
std::shared_ptr< LuminosityBlockPrincipal >	lumiPrincipal_
std::shared_ptr< ModuleRegistry >	moduleRegistry_
PreallocationConfiguration	preallocations_
std::shared_ptr< ProductRegistry >	preg_
PrincipalCache	principalCache_
std::shared_ptr< ProcessConfiguration const >	processConfiguration_
ProcessContext	processContext_
ProcessHistoryRegistry	processHistoryRegistry_
RunNumber_t	runNumber_ = 1
std::unique_ptr< Schedule >	schedule_
ServiceToken	serviceToken_
std::shared_ptr< ThinnedAssociationsHelper >	thinnedAssociationsHelper_

Detailed Description

Definition at line 154 of file TestProcessor.h.

Member Typedef Documentation

using edm::test::TestProcessor::Config = TestProcessorConfig

Definition at line 156 of file TestProcessor.h.

Constructor & Destructor Documentation

TestProcessor::TestProcessor	(	Config const &	iConfig,
		ServiceToken	iToken = ServiceToken()
	)

Definition at line 84 of file TestProcessor.cc.

References edm::ScheduleItems::act_table_, act_table_, edm::ScheduleItems::actReg_, actReg_, edm::ScheduleItems::addCPRandTNS(), edm::ScheduleItems::branchIDListHelper(), branchIDListHelper_, trackingPlots::common, dataProducts_, edm::ProcessHistory::emplace_back(), esHelper_, esp_, espController_, edm::test::TestProcessorConfig::esProduceEntries(), edm::test::TestProcessorConfig::extraProcesses(), historyAppender_, edm::ParameterSet::id(), edm::InEvent, edm::BranchDescription::init(), edm::ScheduleItems::initMisc(), edm::ScheduleItems::initSchedule(), edm::ScheduleItems::initServices(), edm::PrincipalCache::insert(), mps_monitormerge::items, edm::serviceregistry::kOverlapIsError, labelOfTestModule_, eostools::move(), jets_cff::nThreads, edm::PreallocationConfiguration::numberOfLuminosityBlocks(), edm::PreallocationConfiguration::numberOfStreams(), cmsPerfStripChart::operate(), AlCaHLTBitMon_ParallelJobs::p, PyBind11ProcessDesc::parameterSet(), preallocations_, edm::ScheduleItems::preg(), preg_, principalCache_, edm::ScheduleItems::processConfiguration(), processConfiguration_, processContext_, processHistoryRegistry_, modifiedElectrons_cfi::processName, edm::test::TestProcessorConfig::produceEntries(), edm::test::TestProcessorConfig::pythonConfiguration(), edm::ParameterSet::registerIt(), edm::ProcessHistoryRegistry::registerProcessHistory(), schedule_, serviceToken_, edm::PrincipalCache::setNumberOfConcurrentPrincipals(), edm::ProcessContext::setProcessConfiguration(), edm::PrincipalCache::setProcessHistoryRegistry(), AlCaHLTBitMon_QueryRunRegistry::string, edm::ScheduleItems::thinnedAssociationsHelper(), thinnedAssociationsHelper_, mitigatedMETSequence_cff::U, edm::validateTopLevelParameterSets(), and xstr.

        : espController_(std::make_unique<eventsetup::EventSetupsController>()),
          historyAppender_(std::make_unique<HistoryAppender>()),
          moduleRegistry_(std::make_shared<ModuleRegistry>()) {
      //Setup various singletons
      (void)oneTimeInitialization();

      ProcessDescImpl desc(iConfig.pythonConfiguration());

      auto psetPtr = desc.parameterSet();

      validateTopLevelParameterSets(psetPtr.get());

      labelOfTestModule_ = psetPtr->getParameter<std::string>("@moduleToTest");

      auto procDesc = desc.processDesc();
      // Now do general initialization
      ScheduleItems items;

      //initialize the services
      auto& serviceSets = procDesc->getServicesPSets();
      ServiceToken token = items.initServices(serviceSets, *psetPtr, iToken, serviceregistry::kOverlapIsError, true);
      serviceToken_ = items.addCPRandTNS(*psetPtr, token);

      //make the services available
      ServiceRegistry::Operate operate(serviceToken_);

      // intialize miscellaneous items
      std::shared_ptr<CommonParams> common(items.initMisc(*psetPtr));

      // intialize the event setup provider
      esp_ = espController_->makeProvider(*psetPtr, items.actReg_.get());

      if (not iConfig.esProduceEntries().empty()) {
        esHelper_ = std::make_unique<EventSetupTestHelper>(iConfig.esProduceEntries());
        esp_->add(std::dynamic_pointer_cast<eventsetup::DataProxyProvider>(esHelper_));
        esp_->add(std::dynamic_pointer_cast<EventSetupRecordIntervalFinder>(esHelper_));
      }

      auto nThreads = 1U;
      auto nStreams = 1U;
      auto nConcurrentLumis = 1U;
      auto nConcurrentRuns = 1U;
      preallocations_ = PreallocationConfiguration{nThreads, nStreams, nConcurrentLumis, nConcurrentRuns};

      preg_ = items.preg();
      processConfiguration_ = items.processConfiguration();

      edm::ParameterSet emptyPSet;
      emptyPSet.registerIt();
      auto psetid = emptyPSet.id();

      ProcessHistory oldHistory;
      for (auto const& p : iConfig.extraProcesses()) {
        oldHistory.emplace_back(p, psetid, xstr(PROJECT_VERSION), "0");
        processHistoryRegistry_.registerProcessHistory(oldHistory);
      }

      //setup the products we will be adding to the event
      for (auto const& produce : iConfig.produceEntries()) {
        auto processName = produce.processName_;
        if (processName.empty()) {
          processName = processConfiguration_->processName();
        }
        edm::TypeWithDict twd(produce.type_.typeInfo());
        edm::BranchDescription product(edm::InEvent,
                                       produce.moduleLabel_,
                                       processName,
                                       twd.userClassName(),
                                       twd.friendlyClassName(),
                                       produce.instanceLabel_,
                                       "",
                                       psetid,
                                       twd,
                                       true  //force this to come from 'source'
        );
        product.init();
        dataProducts_.emplace_back(product, std::unique_ptr<WrapperBase>());
        preg_->addProduct(product);
      }

      schedule_ = items.initSchedule(*psetPtr, false, preallocations_, &processContext_);
      // set the data members
      act_table_ = std::move(items.act_table_);
      actReg_ = items.actReg_;
      branchIDListHelper_ = items.branchIDListHelper();
      thinnedAssociationsHelper_ = items.thinnedAssociationsHelper();
      processContext_.setProcessConfiguration(processConfiguration_.get());
      principalCache_.setProcessHistoryRegistry(processHistoryRegistry_);

      principalCache_.setNumberOfConcurrentPrincipals(preallocations_);

      preg_->setFrozen();
      for (unsigned int index = 0; index < preallocations_.numberOfStreams(); ++index) {
        // Reusable event principal
        auto ep = std::make_shared<EventPrincipal>(preg_,
                                                   branchIDListHelper_,
                                                   thinnedAssociationsHelper_,
                                                   *processConfiguration_,
                                                   historyAppender_.get(),
                                                   index);
        principalCache_.insert(std::move(ep));
      }

      for (unsigned int index = 0; index < preallocations_.numberOfLuminosityBlocks(); ++index) {
        auto lp =
            std::make_unique<LuminosityBlockPrincipal>(preg_, *processConfiguration_, historyAppender_.get(), index);
        principalCache_.insert(std::move(lp));
      }
    }

TestProcessor::~TestProcessor

(

)

Definition at line 195 of file TestProcessor.cc.

References teardownProcessing().

{ teardownProcessing(); }

edm::test::TestProcessor::TestProcessor ( const TestProcessor &  )

privatedelete

Member Function Documentation

void TestProcessor::beginJob ( void  )

private

Definition at line 328 of file TestProcessor.cc.

References actReg_, beginJobCalled_, esp_, mps_fire::i, edm::PreallocationConfiguration::numberOfLuminosityBlocks(), edm::PreallocationConfiguration::numberOfRuns(), edm::PreallocationConfiguration::numberOfStreams(), edm::PreallocationConfiguration::numberOfThreads(), cmsPerfStripChart::operate(), preallocations_, preg_, processConfiguration_, processContext_, schedule_, and serviceToken_.

Referenced by setupProcessing(), testBeginLuminosityBlockImpl(), testBeginRunImpl(), testEndLuminosityBlockImpl(), and testEndRunImpl().

                                 {
      ServiceRegistry::Operate operate(serviceToken_);

      service::SystemBounds bounds(preallocations_.numberOfStreams(),
                                   preallocations_.numberOfLuminosityBlocks(),
                                   preallocations_.numberOfRuns(),
                                   preallocations_.numberOfThreads());
      actReg_->preallocateSignal_(bounds);
      schedule_->convertCurrentProcessAlias(processConfiguration_->processName());
      PathsAndConsumesOfModules pathsAndConsumesOfModules;

      //The code assumes only modules make data in the current process
      // Since the test os also allowed to do so, it can lead to problems.
      //pathsAndConsumesOfModules.initialize(schedule_.get(), preg_);

      //NOTE: this may throw
      //checkForModuleDependencyCorrectness(pathsAndConsumesOfModules, false);
      actReg_->preBeginJobSignal_(pathsAndConsumesOfModules, processContext_);

      schedule_->beginJob(*preg_, esp_->recordsToProxyIndices());
      actReg_->postBeginJobSignal_();

      for (unsigned int i = 0; i < preallocations_.numberOfStreams(); ++i) {
        schedule_->beginStream(i);
      }
      beginJobCalled_ = true;
    }

void TestProcessor::beginLuminosityBlock ( )

private

Definition at line 405 of file TestProcessor.cc.

References printConversionInfo::aux, beginLumiCalled_, esp_, espController_, eventNumber_, edm::PrincipalCache::getAvailableLumiPrincipalPtr(), lumiNumber_, lumiPrincipal_, edm::make_empty_waiting_task(), edm::PreallocationConfiguration::numberOfStreams(), preallocations_, principalCache_, runNumber_, edm::PrincipalCache::runPrincipalPtr(), schedule_, and serviceToken_.

Referenced by setupProcessing(), testBeginLuminosityBlockImpl(), and testEndLuminosityBlockImpl().

                                             {
      LuminosityBlockAuxiliary aux(runNumber_, lumiNumber_, Timestamp(), Timestamp());
      lumiPrincipal_ = principalCache_.getAvailableLumiPrincipalPtr();
      lumiPrincipal_->clearPrincipal();
      assert(lumiPrincipal_);
      lumiPrincipal_->setAux(aux);

      lumiPrincipal_->setRunPrincipal(principalCache_.runPrincipalPtr());

      IOVSyncValue ts(EventID(runNumber_, lumiNumber_, eventNumber_), lumiPrincipal_->beginTime());
      espController_->eventSetupForInstance(ts);

      auto const& es = esp_->eventSetup();

      std::vector<edm::SubProcess> emptyList;
      {
        typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionGlobalBegin> Traits;
        auto globalWaitTask = make_empty_waiting_task();
        globalWaitTask->increment_ref_count();
        beginGlobalTransitionAsync<Traits>(
            WaitingTaskHolder(globalWaitTask.get()), *schedule_, *lumiPrincipal_, ts, es, serviceToken_, emptyList);
        globalWaitTask->wait_for_all();
        if (globalWaitTask->exceptionPtr() != nullptr) {
          std::rethrow_exception(*(globalWaitTask->exceptionPtr()));
        }
      }
      {
        //To wait, the ref count has to be 1+#streams
        auto streamLoopWaitTask = make_empty_waiting_task();
        streamLoopWaitTask->increment_ref_count();

        typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionStreamBegin> Traits;

        beginStreamsTransitionAsync<Traits>(streamLoopWaitTask.get(),
                                            *schedule_,
                                            preallocations_.numberOfStreams(),
                                            *lumiPrincipal_,
                                            ts,
                                            es,
                                            serviceToken_,
                                            emptyList);

        streamLoopWaitTask->wait_for_all();
        if (streamLoopWaitTask->exceptionPtr() != nullptr) {
          std::rethrow_exception(*(streamLoopWaitTask->exceptionPtr()));
        }
      }
      beginLumiCalled_ = true;
    }

void TestProcessor::beginRun ( )

private

Definition at line 356 of file TestProcessor.cc.

References printConversionInfo::aux, beginRunCalled_, edm::RunPrincipal::beginTime(), esp_, espController_, historyAppender_, edm::PrincipalCache::insert(), edm::make_empty_waiting_task(), edm::PreallocationConfiguration::numberOfStreams(), preallocations_, preg_, principalCache_, processConfiguration_, edm::RunPrincipal::run(), runNumber_, edm::PrincipalCache::runPrincipal(), schedule_, and serviceToken_.

Referenced by setupProcessing(), testBeginLuminosityBlockImpl(), testBeginRunImpl(), testEndLuminosityBlockImpl(), and testEndRunImpl().

                                 {
      ProcessHistoryID phid;
      auto aux = std::make_shared<RunAuxiliary>(runNumber_, Timestamp(), Timestamp());
      auto rp = std::make_shared<RunPrincipal>(aux, preg_, *processConfiguration_, historyAppender_.get(), 0);

      principalCache_.insert(rp);
      RunPrincipal& runPrincipal = principalCache_.runPrincipal(phid, runNumber_);

      IOVSyncValue ts(EventID(runPrincipal.run(), 0, 0), runPrincipal.beginTime());
      espController_->eventSetupForInstance(ts);

      auto const& es = esp_->eventSetup();

      std::vector<edm::SubProcess> emptyList;
      {
        typedef OccurrenceTraits<RunPrincipal, BranchActionGlobalBegin> Traits;
        auto globalWaitTask = make_empty_waiting_task();
        globalWaitTask->increment_ref_count();
        beginGlobalTransitionAsync<Traits>(
            WaitingTaskHolder(globalWaitTask.get()), *schedule_, runPrincipal, ts, es, serviceToken_, emptyList);
        globalWaitTask->wait_for_all();
        if (globalWaitTask->exceptionPtr() != nullptr) {
          std::rethrow_exception(*(globalWaitTask->exceptionPtr()));
        }
      }
      {
        //To wait, the ref count has to be 1+#streams
        auto streamLoopWaitTask = make_empty_waiting_task();
        streamLoopWaitTask->increment_ref_count();

        typedef OccurrenceTraits<RunPrincipal, BranchActionStreamBegin> Traits;

        beginStreamsTransitionAsync<Traits>(streamLoopWaitTask.get(),
                                            *schedule_,
                                            preallocations_.numberOfStreams(),
                                            runPrincipal,
                                            ts,
                                            es,
                                            serviceToken_,
                                            emptyList);

        streamLoopWaitTask->wait_for_all();
        if (streamLoopWaitTask->exceptionPtr() != nullptr) {
          std::rethrow_exception(*(streamLoopWaitTask->exceptionPtr()));
        }
      }
      beginRunCalled_ = true;
    }

void TestProcessor::endJob ( void  )

private

Definition at line 613 of file TestProcessor.cc.

References actReg_, EnergyCorrector::c, edm::ExceptionCollector::call(), edm::ExceptionCollector::hasThrown(), mps_fire::i, edm::PreallocationConfiguration::numberOfStreams(), cmsPerfStripChart::operate(), preallocations_, edm::ExceptionCollector::rethrow(), schedule_, and serviceToken_.

Referenced by teardownProcessing().

                               {
      // Collects exceptions, so we don't throw before all operations are performed.
      ExceptionCollector c(
          "Multiple exceptions were thrown while executing endJob. An exception message follows for each.\n");

      //make the services available
      ServiceRegistry::Operate operate(serviceToken_);

      //NOTE: this really should go elsewhere in the future
      for (unsigned int i = 0; i < preallocations_.numberOfStreams(); ++i) {
        c.call([this, i]() { this->schedule_->endStream(i); });
      }
      auto actReg = actReg_.get();
      c.call([actReg]() { actReg->preEndJobSignal_(); });
      schedule_->endJob(c);
      c.call([actReg]() { actReg->postEndJobSignal_(); });
      if (c.hasThrown()) {
        c.rethrow();
      }
    }

std::shared_ptr< LuminosityBlockPrincipal > TestProcessor::endLuminosityBlock ( )

private

Definition at line 493 of file TestProcessor.cc.

References beginLumiCalled_, esp_, espController_, eventNumber_, lumiNumber_, lumiPrincipal_, edm::make_empty_waiting_task(), edm::PreallocationConfiguration::numberOfStreams(), preallocations_, runNumber_, schedule_, and serviceToken_.

Referenced by setLuminosityBlockNumber(), setRunNumber(), teardownProcessing(), testBeginLuminosityBlockImpl(), and testEndLuminosityBlockImpl().

                                                                              {
      auto lumiPrincipal = lumiPrincipal_;
      if (beginLumiCalled_) {
        beginLumiCalled_ = false;
        lumiPrincipal_.reset();

        IOVSyncValue ts(EventID(runNumber_, lumiNumber_, eventNumber_), lumiPrincipal->endTime());
        espController_->eventSetupForInstance(ts);

        auto const& es = esp_->eventSetup();

        std::vector<edm::SubProcess> emptyList;

        //To wait, the ref count has to be 1+#streams
        {
          auto streamLoopWaitTask = make_empty_waiting_task();
          streamLoopWaitTask->increment_ref_count();

          using Traits = OccurrenceTraits<LuminosityBlockPrincipal, BranchActionStreamEnd>;

          endStreamsTransitionAsync<Traits>(WaitingTaskHolder(streamLoopWaitTask.get()),
                                            *schedule_,
                                            preallocations_.numberOfStreams(),
                                            *lumiPrincipal,
                                            ts,
                                            es,
                                            serviceToken_,
                                            emptyList,
                                            false);

          streamLoopWaitTask->wait_for_all();
          if (streamLoopWaitTask->exceptionPtr() != nullptr) {
            std::rethrow_exception(*(streamLoopWaitTask->exceptionPtr()));
          }
        }
        {
          auto globalWaitTask = make_empty_waiting_task();
          globalWaitTask->increment_ref_count();

          typedef OccurrenceTraits<LuminosityBlockPrincipal, BranchActionGlobalEnd> Traits;
          endGlobalTransitionAsync<Traits>(WaitingTaskHolder(globalWaitTask.get()),
                                           *schedule_,
                                           *lumiPrincipal,
                                           ts,
                                           es,
                                           serviceToken_,
                                           emptyList,
                                           false);
          globalWaitTask->wait_for_all();
          if (globalWaitTask->exceptionPtr() != nullptr) {
            std::rethrow_exception(*(globalWaitTask->exceptionPtr()));
          }
        }
      }
      return lumiPrincipal;
    }

std::shared_ptr< edm::RunPrincipal > TestProcessor::endRun ( )

private

Definition at line 550 of file TestProcessor.cc.

References beginRunCalled_, edm::PrincipalCache::deleteRun(), edm::RunPrincipal::endTime(), esp_, espController_, edm::make_empty_waiting_task(), edm::EventID::maxEventNumber(), edm::LuminosityBlockID::maxLuminosityBlockNumber(), edm::PreallocationConfiguration::numberOfStreams(), preallocations_, principalCache_, edm::RunPrincipal::run(), runNumber_, edm::PrincipalCache::runPrincipalPtr(), schedule_, and serviceToken_.

Referenced by setRunNumber(), teardownProcessing(), testBeginRunImpl(), and testEndRunImpl().

                                                         {
      std::shared_ptr<RunPrincipal> rp;
      if (beginRunCalled_) {
        beginRunCalled_ = false;
        ProcessHistoryID phid;
        rp = principalCache_.runPrincipalPtr(phid, runNumber_);
        RunPrincipal& runPrincipal = *rp;

        IOVSyncValue ts(
            EventID(runPrincipal.run(), LuminosityBlockID::maxLuminosityBlockNumber(), EventID::maxEventNumber()),
            runPrincipal.endTime());
        espController_->eventSetupForInstance(ts);

        auto const& es = esp_->eventSetup();

        std::vector<edm::SubProcess> emptyList;

        //To wait, the ref count has to be 1+#streams
        {
          auto streamLoopWaitTask = make_empty_waiting_task();
          streamLoopWaitTask->increment_ref_count();

          using Traits = OccurrenceTraits<RunPrincipal, BranchActionStreamEnd>;

          endStreamsTransitionAsync<Traits>(WaitingTaskHolder(streamLoopWaitTask.get()),
                                            *schedule_,
                                            preallocations_.numberOfStreams(),
                                            runPrincipal,
                                            ts,
                                            es,
                                            serviceToken_,
                                            emptyList,
                                            false);

          streamLoopWaitTask->wait_for_all();
          if (streamLoopWaitTask->exceptionPtr() != nullptr) {
            std::rethrow_exception(*(streamLoopWaitTask->exceptionPtr()));
          }
        }
        {
          auto globalWaitTask = make_empty_waiting_task();
          globalWaitTask->increment_ref_count();

          typedef OccurrenceTraits<RunPrincipal, BranchActionGlobalEnd> Traits;
          endGlobalTransitionAsync<Traits>(WaitingTaskHolder(globalWaitTask.get()),
                                           *schedule_,
                                           runPrincipal,
                                           ts,
                                           es,
                                           serviceToken_,
                                           emptyList,
                                           false);
          globalWaitTask->wait_for_all();
          if (globalWaitTask->exceptionPtr() != nullptr) {
            std::rethrow_exception(*(globalWaitTask->exceptionPtr()));
          }
        }

        principalCache_.deleteRun(phid, runNumber_);
      }
      return rp;
    }

void TestProcessor::event ( )

private

Definition at line 455 of file TestProcessor.cc.

References dataProducts_, esp_, eventNumber_, edm::PrincipalCache::eventPrincipal(), lumiNumber_, lumiPrincipal_, edm::make_empty_waiting_task(), eostools::move(), cmsPerfStripChart::operate(), AlCaHLTBitMon_ParallelJobs::p, principalCache_, processHistoryRegistry_, alignCSCRings::r, runNumber_, schedule_, and serviceToken_.

Referenced by testImpl().

                              {
      auto pep = &(principalCache_.eventPrincipal(0));

      //this resets the EventPrincipal (if it had been used before)
      pep->clearEventPrincipal();
      pep->fillEventPrincipal(
          edm::EventAuxiliary(EventID(runNumber_, lumiNumber_, eventNumber_), "", Timestamp(), false),
          processHistoryRegistry_,
          nullptr);
      assert(lumiPrincipal_.get() != nullptr);
      pep->setLuminosityBlockPrincipal(lumiPrincipal_.get());

      for (auto& p : dataProducts_) {
        if (p.second) {
          pep->put(p.first, std::move(p.second), ProductProvenance(p.first.branchID()));
        } else {
          //The data product was not set so we need to
          // tell the ProductResolver not to wait
          auto r = pep->getProductResolver(p.first.branchID());
          r->putProduct(std::unique_ptr<WrapperBase>());
        }
      }

      ServiceRegistry::Operate operate(serviceToken_);

      auto waitTask = make_empty_waiting_task();
      waitTask->increment_ref_count();

      schedule_->processOneEventAsync(
          edm::WaitingTaskHolder(waitTask.get()), 0, *pep, esp_->eventSetup(), serviceToken_);

      waitTask->wait_for_all();
      if (waitTask->exceptionPtr() != nullptr) {
        std::rethrow_exception(*(waitTask->exceptionPtr()));
      }
      ++eventNumber_;
    }

std::string const& edm::test::TestProcessor::labelOfTestModule ( ) const

inline

Definition at line 214 of file TestProcessor.h.

References mitigatedMETSequence_cff::U.

{ return labelOfTestModule_; }

const TestProcessor& edm::test::TestProcessor::operator= ( const TestProcessor &  )

privatedelete

template<typename T >

void edm::test::TestProcessor::put ( std::pair< edm::EDPutTokenT< T >, std::unique_ptr< T >> &&  iPut )

inlineprivate

Definition at line 234 of file TestProcessor.h.

References eostools::move(), and put().

                                                                    {
        put(iPut.first.index(), std::make_unique<edm::Wrapper<T>>(std::move(iPut.second)));
      }

template<typename T >

void edm::test::TestProcessor::put ( std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&  iPut )

inlineprivate

Definition at line 239 of file TestProcessor.h.

References eostools::move(), put(), and mitigatedMETSequence_cff::U.

                                                                        {
        dynamic_cast<TestDataProxy<T>*>(esHelper_->getProxy(iPut.first.index()).get())->setData(std::move(iPut.second));
      }

void TestProcessor::put ( unsigned int  index, std::unique_ptr< WrapperBase >  iWrapper  )

private

Definition at line 200 of file TestProcessor.cc.

References dataProducts_, Exception, and eostools::move().

                                                                                   {
      if (index >= dataProducts_.size()) {
        throw cms::Exception("LogicError") << "Products must be declared to the TestProcessor::Config object\n"
                                              "with a call to the function \'produces\' BEFORE passing the\n"
                                              "TestProcessor::Config object to the TestProcessor constructor";
      }
      dataProducts_[index].second = std::move(iWrapper);
    }

void TestProcessor::setEventNumber

(

edm::EventNumber_t

iEv

)

Definition at line 646 of file TestProcessor.cc.

References eventNumber_.

{ eventNumber_ = iEv; }

void TestProcessor::setLuminosityBlockNumber

(

edm::LuminosityBlockNumber_t

iLumi

)

Definition at line 641 of file TestProcessor.cc.

References endLuminosityBlock(), and lumiNumber_.

                                                                                 {
      endLuminosityBlock();
      lumiNumber_ = iLumi;
    }

void TestProcessor::setRunNumber

(

edm::RunNumber_t

iRun

)

Definition at line 634 of file TestProcessor.cc.

References beginRunCalled_, endLuminosityBlock(), endRun(), and runNumber_.

                                                        {
      if (beginRunCalled_) {
        endLuminosityBlock();
        endRun();
      }
      runNumber_ = iRun;
    }

void TestProcessor::setupProcessing ( )

private

Definition at line 302 of file TestProcessor.cc.

References beginJob(), beginJobCalled_, beginLumiCalled_, beginLuminosityBlock(), beginRun(), and beginRunCalled_.

Referenced by testImpl().

                                        {
      if (not beginJobCalled_) {
        beginJob();
      }
      if (not beginRunCalled_) {
        beginRun();
      }
      if (not beginLumiCalled_) {
        beginLuminosityBlock();
      }
    }

void TestProcessor::teardownProcessing ( )

private

Definition at line 314 of file TestProcessor.cc.

References beginJobCalled_, beginLumiCalled_, beginRunCalled_, endJob(), endLuminosityBlock(), and endRun().

Referenced by ~TestProcessor().

                                           {
      if (beginLumiCalled_) {
        endLuminosityBlock();
        beginLumiCalled_ = false;
      }
      if (beginRunCalled_) {
        endRun();
        beginRunCalled_ = false;
      }
      if (beginJobCalled_) {
        endJob();
      }
    }

template<typename... T>

edm::test::Event edm::test::TestProcessor::test ( T &&...  iArgs )

inline

Run the test. The function arguments are the data products to be added to the Event for this particular test.

Definition at line 165 of file TestProcessor.h.

Referenced by edmIntegrityCheck.IntegrityCheck::report(), edmIntegrityCheck.IntegrityCheck::structured(), and TEST_CASE().

                                      {
        return testImpl(std::forward<T>(iArgs)...);
      }

void edm::test::TestProcessor::testBeginAndEndJobOnly ( )

inline

Run only beginJob and endJob. Once this is used, you should not attempt to run any further tests. This simulates a problem happening early in the job which causes processing not to proceed.

Definition at line 190 of file TestProcessor.h.

References bk::beginJob().

Referenced by TEST_CASE().

                                    {
        beginJob();
        endJob();
      }

template<typename... T>

edm::test::LuminosityBlock edm::test::TestProcessor::testBeginLuminosityBlock ( edm::LuminosityBlockNumber_t  iNum, T &&...  iArgs  )

inline

Definition at line 170 of file TestProcessor.h.

                                                                                                     {
        return testBeginLuminosityBlockImpl(iNum, std::forward<T>(iArgs)...);
      }

template<typename T , typename... U>

edm::test::LuminosityBlock edm::test::TestProcessor::testBeginLuminosityBlockImpl ( edm::LuminosityBlockNumber_t  iNum, std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&  iPut, U &&...  iArgs  )

inlineprivate

Definition at line 248 of file TestProcessor.h.

References eostools::move(), put(), and mitigatedMETSequence_cff::U.

                        {
        put(std::move(iPut));
        return testBeginLuminosityBlockImpl(iNum, std::forward<U>(iArgs)...);
      }

edm::test::LuminosityBlock TestProcessor::testBeginLuminosityBlockImpl ( edm::LuminosityBlockNumber_t  iNum )

private

Definition at line 223 of file TestProcessor.cc.

References beginJob(), beginJobCalled_, beginLumiCalled_, beginLuminosityBlock(), beginRun(), beginRunCalled_, endLuminosityBlock(), esHelper_, labelOfTestModule_, lumiNumber_, lumiPrincipal_, and processConfiguration_.

                                                                                                      {
      if (not beginJobCalled_) {
        beginJob();
      }
      if (not beginRunCalled_) {
        beginRun();
      }
      if (beginLumiCalled_) {
        endLuminosityBlock();
        assert(lumiNumber_ != iNum);
      }
      lumiNumber_ = iNum;
      beginLuminosityBlock();

      if (esHelper_) {
        //We want each test to have its own ES data products
        esHelper_->resetAllProxies();
      }

      return edm::test::LuminosityBlock(lumiPrincipal_, labelOfTestModule_, processConfiguration_->processName());
    }

template<typename... T>

edm::test::Run edm::test::TestProcessor::testBeginRun ( edm::RunNumber_t  iNum, T &&...  iArgs  )

inline

Definition at line 179 of file TestProcessor.h.

                                                                 {
        return testBeginRunImpl(iNum, std::forward<T>(iArgs)...);
      }

template<typename T , typename... U>

edm::test::Run edm::test::TestProcessor::testBeginRunImpl ( edm::RunNumber_t  iNum, std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&  iPut, U &&...  iArgs  )

inlineprivate

Definition at line 266 of file TestProcessor.h.

References eostools::move(), put(), and mitigatedMETSequence_cff::U.

                                                    {
        put(std::move(iPut));
        return testBeginRunImpl(iNum, std::forward<U>(iArgs)...);
      }

edm::test::Run TestProcessor::testBeginRunImpl ( edm::RunNumber_t  iNum )

private

Definition at line 265 of file TestProcessor.cc.

References beginJob(), beginJobCalled_, beginRun(), beginRunCalled_, endRun(), esHelper_, labelOfTestModule_, principalCache_, processConfiguration_, runNumber_, and edm::PrincipalCache::runPrincipalPtr().

                                                                  {
      if (not beginJobCalled_) {
        beginJob();
      }

      if (beginRunCalled_) {
        assert(runNumber_ != iNum);
        endRun();
      }
      runNumber_ = iNum;
      beginRun();

      if (esHelper_) {
        //We want each test to have its own ES data products
        esHelper_->resetAllProxies();
      }

      return edm::test::Run(
          principalCache_.runPrincipalPtr(), labelOfTestModule_, processConfiguration_->processName());
    }

template<typename... T>

edm::test::LuminosityBlock edm::test::TestProcessor::testEndLuminosityBlock ( T &&...  iArgs )

inline

Definition at line 174 of file TestProcessor.h.

                                                                  {
        return testEndLuminosityBlockImpl(std::forward<T>(iArgs)...);
      }

template<typename T , typename... U>

edm::test::LuminosityBlock edm::test::TestProcessor::testEndLuminosityBlockImpl ( std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&  iPut, U &&...  iArgs  )

inlineprivate

Definition at line 258 of file TestProcessor.h.

References eostools::move(), put(), and mitigatedMETSequence_cff::U.

                                                                                 {
        put(std::move(iPut));
        return testEndLuminosityBlockImpl(std::forward<U>(iArgs)...);
      }

edm::test::LuminosityBlock TestProcessor::testEndLuminosityBlockImpl ( )

private

Definition at line 245 of file TestProcessor.cc.

References beginJob(), beginJobCalled_, beginLumiCalled_, beginLuminosityBlock(), beginRun(), beginRunCalled_, endLuminosityBlock(), esHelper_, labelOfTestModule_, eostools::move(), and processConfiguration_.

                                                                     {
      if (not beginJobCalled_) {
        beginJob();
      }
      if (not beginRunCalled_) {
        beginRun();
      }
      if (not beginLumiCalled_) {
        beginLuminosityBlock();
      }
      auto lumi = endLuminosityBlock();

      if (esHelper_) {
        //We want each test to have its own ES data products
        esHelper_->resetAllProxies();
      }

      return edm::test::LuminosityBlock(std::move(lumi), labelOfTestModule_, processConfiguration_->processName());
    }

template<typename... T>

edm::test::Run edm::test::TestProcessor::testEndRun ( T &&...  iArgs )

inline

Definition at line 183 of file TestProcessor.h.

                                          {
        return testEndRunImpl(std::forward<T>(iArgs)...);
      }

template<typename T , typename... U>

edm::test::LuminosityBlock edm::test::TestProcessor::testEndRunImpl ( std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&  iPut, U &&...  iArgs  )

inlineprivate

Definition at line 274 of file TestProcessor.h.

References bk::beginJob(), Ecal2004TBTDCRanges_v1_cff::endRun, event(), eostools::move(), and put().

                                                              {
        put(std::move(iPut));
        return testEndRunImpl(std::forward<U>(iArgs)...);
      }

edm::test::Run TestProcessor::testEndRunImpl ( )

private

Definition at line 285 of file TestProcessor.cc.

References beginJob(), beginJobCalled_, beginRun(), beginRunCalled_, endRun(), esHelper_, labelOfTestModule_, and processConfiguration_.

                                             {
      if (not beginJobCalled_) {
        beginJob();
      }
      if (not beginRunCalled_) {
        beginRun();
      }
      auto rp = endRun();

      if (esHelper_) {
        //We want each test to have its own ES data products
        esHelper_->resetAllProxies();
      }

      return edm::test::Run(rp, labelOfTestModule_, processConfiguration_->processName());
    }

template<typename T , typename... U>

edm::test::Event edm::test::TestProcessor::testImpl ( std::pair< edm::EDPutTokenT< T >, std::unique_ptr< T >> &&  iPut, U &&...  iArgs  )

inlineprivate

Definition at line 222 of file TestProcessor.h.

References eostools::move(), put(), and mitigatedMETSequence_cff::U.

                                                                                               {
        put(std::move(iPut));
        return testImpl(std::forward<U>(iArgs)...);
      }

template<typename T , typename... U>

edm::test::Event edm::test::TestProcessor::testImpl ( std::pair< edm::test::ESPutTokenT< T >, std::unique_ptr< T >> &&  iPut, U &&...  iArgs  )

inlineprivate

Definition at line 228 of file TestProcessor.h.

References eostools::move(), and put().

                                                                                                   {
        put(std::move(iPut));
        return testImpl(std::forward<U>(iArgs)...);
      }

edm::test::Event TestProcessor::testImpl ( )

private

Definition at line 209 of file TestProcessor.cc.

References esHelper_, event(), edm::PrincipalCache::eventPrincipal(), labelOfTestModule_, principalCache_, processConfiguration_, mps_fire::result, schedule_, and setupProcessing().

                                         {
      setupProcessing();
      event();

      bool result = schedule_->totalEventsPassed() > 0;
      schedule_->clearCounters();
      if (esHelper_) {
        //We want each test to have its own ES data products
        esHelper_->resetAllProxies();
      }
      return edm::test::Event(
          principalCache_.eventPrincipal(0), labelOfTestModule_, processConfiguration_->processName(), result);
    }

void edm::test::TestProcessor::testLuminosityBlockWithNoEvents ( )

inline

Definition at line 202 of file TestProcessor.h.

References bk::beginJob(), and Ecal2004TBTDCRanges_v1_cff::endRun.

Referenced by TEST_CASE().

                                             {
        beginJob();
        beginRun();
        beginLuminosityBlock();
        endLuminosityBlock();
        endRun();
        endJob();
      }

void edm::test::TestProcessor::testRunWithNoLuminosityBlocks ( )

inline

Definition at line 195 of file TestProcessor.h.

References bk::beginJob(), and Ecal2004TBTDCRanges_v1_cff::endRun.

Referenced by TEST_CASE().

                                           {
        beginJob();
        beginRun();
        endRun();
        endJob();
      }

Member Data Documentation

std::unique_ptr<ExceptionToActionTable const> edm::test::TestProcessor::act_table_

private

Definition at line 303 of file TestProcessor.h.

Referenced by TestProcessor().

std::shared_ptr<ActivityRegistry> edm::test::TestProcessor::actReg_

private

Definition at line 294 of file TestProcessor.h.

Referenced by beginJob(), endJob(), and TestProcessor().

bool edm::test::TestProcessor::beginJobCalled_ = false

private

Definition at line 322 of file TestProcessor.h.

Referenced by beginJob(), setupProcessing(), teardownProcessing(), testBeginLuminosityBlockImpl(), testBeginRunImpl(), testEndLuminosityBlockImpl(), and testEndRunImpl().

bool edm::test::TestProcessor::beginLumiCalled_ = false

private

Definition at line 324 of file TestProcessor.h.

Referenced by beginLuminosityBlock(), endLuminosityBlock(), setupProcessing(), teardownProcessing(), testBeginLuminosityBlockImpl(), and testEndLuminosityBlockImpl().

bool edm::test::TestProcessor::beginRunCalled_ = false

private

Definition at line 323 of file TestProcessor.h.

Referenced by beginRun(), endRun(), setRunNumber(), setupProcessing(), teardownProcessing(), testBeginLuminosityBlockImpl(), testBeginRunImpl(), testEndLuminosityBlockImpl(), and testEndRunImpl().

std::shared_ptr<BranchIDListHelper> edm::test::TestProcessor::branchIDListHelper_

private

Definition at line 296 of file TestProcessor.h.

Referenced by TestProcessor().

std::vector<std::pair<edm::BranchDescription, std::unique_ptr<WrapperBase> > > edm::test::TestProcessor::dataProducts_

private

Definition at line 317 of file TestProcessor.h.

Referenced by event(), put(), and TestProcessor().

std::shared_ptr<EventSetupTestHelper> edm::test::TestProcessor::esHelper_

private

Definition at line 301 of file TestProcessor.h.

Referenced by testBeginLuminosityBlockImpl(), testBeginRunImpl(), testEndLuminosityBlockImpl(), testEndRunImpl(), testImpl(), and TestProcessor().

std::shared_ptr<eventsetup::EventSetupProvider> edm::test::TestProcessor::esp_

private

Definition at line 300 of file TestProcessor.h.

Referenced by beginJob(), beginLuminosityBlock(), beginRun(), endLuminosityBlock(), endRun(), event(), and TestProcessor().

std::unique_ptr<eventsetup::EventSetupsController> edm::test::TestProcessor::espController_

private

Definition at line 299 of file TestProcessor.h.

Referenced by beginLuminosityBlock(), beginRun(), endLuminosityBlock(), endRun(), and TestProcessor().

EventNumber_t edm::test::TestProcessor::eventNumber_ = 1

private

Definition at line 321 of file TestProcessor.h.

Referenced by beginLuminosityBlock(), endLuminosityBlock(), event(), and setEventNumber().

std::unique_ptr<HistoryAppender> edm::test::TestProcessor::historyAppender_

private

Definition at line 308 of file TestProcessor.h.

Referenced by beginRun(), and TestProcessor().

std::string edm::test::TestProcessor::labelOfTestModule_

private

Definition at line 293 of file TestProcessor.h.

Referenced by testBeginLuminosityBlockImpl(), testBeginRunImpl(), testEndLuminosityBlockImpl(), testEndRunImpl(), testImpl(), and TestProcessor().

LuminosityBlockNumber_t edm::test::TestProcessor::lumiNumber_ = 1

private

Definition at line 320 of file TestProcessor.h.

Referenced by beginLuminosityBlock(), endLuminosityBlock(), event(), setLuminosityBlockNumber(), and testBeginLuminosityBlockImpl().

std::shared_ptr<LuminosityBlockPrincipal> edm::test::TestProcessor::lumiPrincipal_

private

Definition at line 315 of file TestProcessor.h.

Referenced by beginLuminosityBlock(), endLuminosityBlock(), event(), and testBeginLuminosityBlockImpl().

std::shared_ptr<ModuleRegistry> edm::test::TestProcessor::moduleRegistry_

private

Definition at line 313 of file TestProcessor.h.

PreallocationConfiguration edm::test::TestProcessor::preallocations_

private

Definition at line 311 of file TestProcessor.h.

Referenced by beginJob(), beginLuminosityBlock(), beginRun(), endJob(), endLuminosityBlock(), endRun(), and TestProcessor().

std::shared_ptr<ProductRegistry> edm::test::TestProcessor::preg_

private

Definition at line 295 of file TestProcessor.h.

Referenced by beginJob(), beginRun(), and TestProcessor().

PrincipalCache edm::test::TestProcessor::principalCache_

private

Definition at line 310 of file TestProcessor.h.

Referenced by beginLuminosityBlock(), beginRun(), endRun(), event(), testBeginRunImpl(), testImpl(), and TestProcessor().

std::shared_ptr<ProcessConfiguration const> edm::test::TestProcessor::processConfiguration_

private

Definition at line 304 of file TestProcessor.h.

Referenced by beginJob(), beginRun(), testBeginLuminosityBlockImpl(), testBeginRunImpl(), testEndLuminosityBlockImpl(), testEndRunImpl(), testImpl(), and TestProcessor().

ProcessContext edm::test::TestProcessor::processContext_

private

Definition at line 305 of file TestProcessor.h.

Referenced by beginJob(), and TestProcessor().

ProcessHistoryRegistry edm::test::TestProcessor::processHistoryRegistry_

private

Definition at line 307 of file TestProcessor.h.

Referenced by event(), and TestProcessor().

RunNumber_t edm::test::TestProcessor::runNumber_ = 1

private

Definition at line 319 of file TestProcessor.h.

Referenced by beginLuminosityBlock(), beginRun(), endLuminosityBlock(), endRun(), event(), setRunNumber(), and testBeginRunImpl().

std::unique_ptr<Schedule> edm::test::TestProcessor::schedule_

private

Definition at line 314 of file TestProcessor.h.

Referenced by Config.Process::_insertPaths(), Config.Process::_replaceInSchedule(), beginJob(), beginLuminosityBlock(), beginRun(), Config.Process::dumpPython(), endJob(), endLuminosityBlock(), endRun(), event(), Config.Process::prune(), Config.Process::resolve(), testImpl(), and TestProcessor().

ServiceToken edm::test::TestProcessor::serviceToken_

private

Definition at line 298 of file TestProcessor.h.

Referenced by beginJob(), beginLuminosityBlock(), beginRun(), endJob(), endLuminosityBlock(), endRun(), event(), and TestProcessor().

std::shared_ptr<ThinnedAssociationsHelper> edm::test::TestProcessor::thinnedAssociationsHelper_

private

Definition at line 297 of file TestProcessor.h.

Referenced by TestProcessor().