Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2025-01-14 02:38:44

0001 /*
0002  *  stream_filter_test.cppunit.cc
0003  *  EDMProto
0004  *
0005  *  Created by Chris Jones on 2/8/2013.
0006  */
0007 #include <iostream>
0008 #include <atomic>
0009 #include <vector>
0010 #include <map>
0011 #include <functional>
0012 #include "oneapi/tbb/global_control.h"
0013 #include "FWCore/Framework/interface/maker/Worker.h"
0014 #include "FWCore/Framework/interface/maker/WorkerT.h"
0015 #include "FWCore/Framework/interface/maker/ModuleHolder.h"
0016 #include "FWCore/Framework/interface/PreallocationConfiguration.h"
0017 #include "FWCore/Framework/interface/TransitionInfoTypes.h"
0018 #include "FWCore/Framework/interface/stream/EDFilter.h"
0019 #include "FWCore/Framework/interface/stream/EDProducerAdaptor.h"
0020 #include "FWCore/Framework/interface/OccurrenceTraits.h"
0021 #include "FWCore/Framework/interface/ProductResolversFactory.h"
0022 #include "DataFormats/Provenance/interface/ProductRegistry.h"
0023 #include "DataFormats/Provenance/interface/BranchIDListHelper.h"
0024 #include "DataFormats/Provenance/interface/ThinnedAssociationsHelper.h"
0025 #include "FWCore/Framework/interface/HistoryAppender.h"
0026 #include "FWCore/ServiceRegistry/interface/GlobalContext.h"
0027 #include "FWCore/ServiceRegistry/interface/ParentContext.h"
0028 #include "FWCore/ServiceRegistry/interface/StreamContext.h"
0029 #include "FWCore/Concurrency/interface/FinalWaitingTask.h"
0030 #include "FWCore/Utilities/interface/GlobalIdentifier.h"
0031 
0032 #include "FWCore/Utilities/interface/Exception.h"
0033 
0034 #include "cppunit/extensions/HelperMacros.h"
0035 
0036 namespace {
0037   struct ShadowStreamID {
0038     constexpr ShadowStreamID() : value(0) {}
0039     unsigned int value;
0040   };
0041 
0042   union IDUnion {
0043     IDUnion() : m_shadow() {}
0044     ShadowStreamID m_shadow;
0045     edm::StreamID m_id;
0046   };
0047 }  // namespace
0048 static edm::StreamID makeID() {
0049   IDUnion u;
0050   assert(u.m_id.value() == 0);
0051   return u.m_id;
0052 }
0053 static const edm::StreamID s_streamID0 = makeID();
0054 
0055 class testStreamFilter : public CppUnit::TestFixture {
0056   CPPUNIT_TEST_SUITE(testStreamFilter);
0057 
0058   CPPUNIT_TEST(basicTest);
0059   CPPUNIT_TEST(globalTest);
0060   CPPUNIT_TEST(runTest);
0061   CPPUNIT_TEST(runSummaryTest);
0062   CPPUNIT_TEST(lumiTest);
0063   CPPUNIT_TEST(lumiSummaryTest);
0064   CPPUNIT_TEST(beginRunProdTest);
0065   CPPUNIT_TEST(beginLumiProdTest);
0066   CPPUNIT_TEST(endRunProdTest);
0067   CPPUNIT_TEST(endLumiProdTest);
0068   CPPUNIT_TEST(endRunSummaryProdTest);
0069   CPPUNIT_TEST(endLumiSummaryProdTest);
0070 
0071   CPPUNIT_TEST_SUITE_END();
0072 
0073 public:
0074   testStreamFilter();
0075 
0076   void setUp() {}
0077   void tearDown() {}
0078 
0079   void basicTest();
0080   void globalTest();
0081   void runTest();
0082   void runSummaryTest();
0083   void lumiTest();
0084   void lumiSummaryTest();
0085   void beginRunProdTest();
0086   void beginLumiProdTest();
0087   void endRunProdTest();
0088   void endLumiProdTest();
0089   void endRunSummaryProdTest();
0090   void endLumiSummaryProdTest();
0091 
0092   enum class Trans {
0093     kBeginJob,                    //0
0094     kBeginStream,                 //1
0095     kGlobalBeginRun,              //2
0096     kStreamBeginRun,              //3
0097     kGlobalBeginLuminosityBlock,  //4
0098     kStreamBeginLuminosityBlock,  //5
0099     kEvent,                       //6
0100     kStreamEndLuminosityBlock,    //7
0101     kGlobalEndLuminosityBlock,    //8
0102     kStreamEndRun,                //9
0103     kGlobalEndRun,                //10
0104     kEndStream,                   //11
0105     kEndJob                       //12
0106   };
0107 
0108   typedef std::vector<Trans> Expectations;
0109 
0110 private:
0111   std::map<Trans, std::function<void(edm::Worker*)>> m_transToFunc;
0112 
0113   edm::ProcessConfiguration m_procConfig;
0114   std::shared_ptr<edm::ProductRegistry> m_prodReg;
0115   std::shared_ptr<edm::BranchIDListHelper> m_idHelper;
0116   std::shared_ptr<edm::ThinnedAssociationsHelper> m_associationsHelper;
0117   std::unique_ptr<edm::EventPrincipal> m_ep;
0118   edm::HistoryAppender historyAppender_;
0119   std::shared_ptr<edm::LuminosityBlockPrincipal> m_lbp;
0120   std::shared_ptr<edm::RunPrincipal> m_rp;
0121   std::shared_ptr<edm::ActivityRegistry>
0122       m_actReg;  // We do not use propagate_const because the registry itself is mutable.
0123   edm::EventSetupImpl* m_es = nullptr;
0124   edm::ModuleDescription m_desc = {"Dummy", "dummy"};
0125 
0126   template <typename T, typename U>
0127   void testTransitions(std::shared_ptr<U> iMod, Expectations const& iExpect);
0128 
0129   template <typename Traits, typename Info>
0130   void doWork(edm::Worker* iBase, Info const& info, edm::ParentContext const& iContext) {
0131     oneapi::tbb::task_group group;
0132     edm::FinalWaitingTask task{group};
0133     edm::ServiceToken token;
0134     iBase->doWorkAsync<Traits>(edm::WaitingTaskHolder(group, &task), info, token, s_streamID0, iContext, nullptr);
0135     task.wait();
0136   }
0137 
0138   template <typename T>
0139   void runTest(Expectations const& iExpect);
0140 
0141   class BasicProd : public edm::stream::EDFilter<> {
0142   public:
0143     static unsigned int m_count;
0144 
0145     BasicProd(edm::ParameterSet const&) {}
0146 
0147     bool filter(edm::Event&, edm::EventSetup const&) override {
0148       ++m_count;
0149       return true;
0150     }
0151   };
0152 
0153   class GlobalProd : public edm::stream::EDFilter<edm::GlobalCache<int>> {
0154   public:
0155     static unsigned int m_count;
0156 
0157     static std::unique_ptr<int> initializeGlobalCache(edm::ParameterSet const&) { return std::make_unique<int>(1); }
0158     GlobalProd(edm::ParameterSet const&, const int* iGlobal) { CPPUNIT_ASSERT(*iGlobal == 1); }
0159 
0160     bool filter(edm::Event&, edm::EventSetup const&) override {
0161       ++m_count;
0162       return true;
0163     }
0164 
0165     static void globalEndJob(int* iGlobal) {
0166       CPPUNIT_ASSERT(1 == *iGlobal);
0167       ++m_count;
0168     }
0169   };
0170   class GlobalProdWithBeginJob : public edm::stream::EDFilter<edm::GlobalCache<int>> {
0171   public:
0172     static unsigned int m_count;
0173 
0174     static std::unique_ptr<int> initializeGlobalCache(edm::ParameterSet const&) { return std::make_unique<int>(1); }
0175     GlobalProdWithBeginJob(edm::ParameterSet const&, const int* iGlobal) { CPPUNIT_ASSERT(*iGlobal == 1); }
0176 
0177     static void globalBeginJob(int* iGlobal) {
0178       CPPUNIT_ASSERT(1 == *iGlobal);
0179       *iGlobal = 2;
0180       ++m_count;
0181     }
0182 
0183     void beginStream(edm::StreamID) override {
0184       int* iGlobal = const_cast<int*>(globalCache());
0185       CPPUNIT_ASSERT(2 == *iGlobal);
0186       *iGlobal = 3;
0187       ++m_count;
0188     }
0189 
0190     bool filter(edm::Event&, edm::EventSetup const&) override {
0191       ++m_count;
0192       return true;
0193     }
0194 
0195     static void globalEndJob(int* iGlobal) {
0196       CPPUNIT_ASSERT(3 == *iGlobal);
0197       ++m_count;
0198     }
0199   };
0200   class RunProd : public edm::stream::EDFilter<edm::RunCache<int>> {
0201   public:
0202     static unsigned int m_count;
0203     RunProd(edm::ParameterSet const&) {}
0204     bool filter(edm::Event&, edm::EventSetup const&) override {
0205       ++m_count;
0206       return true;
0207     }
0208 
0209     static std::shared_ptr<int> globalBeginRun(edm::Run const&, edm::EventSetup const&, GlobalCache const*) {
0210       ++m_count;
0211       return std::shared_ptr<int>{};
0212     }
0213 
0214     static void globalEndRun(edm::Run const&, edm::EventSetup const&, RunProd::RunContext const*) { ++m_count; }
0215   };
0216 
0217   class LumiProd : public edm::stream::EDFilter<edm::LuminosityBlockCache<int>> {
0218   public:
0219     static unsigned int m_count;
0220     LumiProd(edm::ParameterSet const&) {}
0221     bool filter(edm::Event&, edm::EventSetup const&) override {
0222       ++m_count;
0223       return true;
0224     }
0225 
0226     static std::shared_ptr<int> globalBeginLuminosityBlock(edm::LuminosityBlock const&,
0227                                                            edm::EventSetup const&,
0228                                                            RunContext const*) {
0229       ++m_count;
0230       return std::shared_ptr<int>{};
0231     }
0232 
0233     static void globalEndLuminosityBlock(edm::LuminosityBlock const&,
0234                                          edm::EventSetup const&,
0235                                          LuminosityBlockContext const*) {
0236       ++m_count;
0237     }
0238   };
0239 
0240   class RunSummaryProd : public edm::stream::EDFilter<edm::RunSummaryCache<int>> {
0241   public:
0242     static unsigned int m_count;
0243     RunSummaryProd(edm::ParameterSet const&) {}
0244     bool filter(edm::Event&, edm::EventSetup const&) override {
0245       ++m_count;
0246       return true;
0247     }
0248 
0249     static std::shared_ptr<int> globalBeginRunSummary(edm::Run const&, edm::EventSetup const&, GlobalCache const*) {
0250       ++m_count;
0251       return std::shared_ptr<int>{};
0252     }
0253 
0254     void endRunSummary(edm::Run const&, edm::EventSetup const&, int*) const override { ++m_count; }
0255 
0256     static void globalEndRunSummary(edm::Run const&, edm::EventSetup const&, RunContext const*, int*) { ++m_count; }
0257   };
0258 
0259   class LumiSummaryProd : public edm::stream::EDFilter<edm::LuminosityBlockSummaryCache<int>> {
0260   public:
0261     static unsigned int m_count;
0262     LumiSummaryProd(edm::ParameterSet const&) {}
0263     bool filter(edm::Event&, edm::EventSetup const&) override {
0264       ++m_count;
0265       return true;
0266     }
0267 
0268     static std::shared_ptr<int> globalBeginLuminosityBlockSummary(edm::LuminosityBlock const&,
0269                                                                   edm::EventSetup const&,
0270                                                                   LuminosityBlockContext const*) {
0271       ++m_count;
0272       return std::shared_ptr<int>{};
0273     }
0274 
0275     void endLuminosityBlockSummary(edm::LuminosityBlock const&, edm::EventSetup const&, int*) const override {
0276       ++m_count;
0277     }
0278 
0279     static void globalEndLuminosityBlockSummary(edm::LuminosityBlock const&,
0280                                                 edm::EventSetup const&,
0281                                                 LuminosityBlockContext const*,
0282                                                 int*) {
0283       ++m_count;
0284     }
0285   };
0286 
0287   class BeginRunProd : public edm::stream::EDFilter<edm::BeginRunProducer> {
0288   public:
0289     static unsigned int m_count;
0290     BeginRunProd(edm::ParameterSet const&) {}
0291 
0292     bool filter(edm::Event&, edm::EventSetup const&) override {
0293       ++m_count;
0294       return true;
0295     }
0296 
0297     static void globalBeginRunProduce(edm::Run&, edm::EventSetup const&, RunContext const*) { ++m_count; }
0298   };
0299 
0300   class BeginLumiProd : public edm::stream::EDFilter<edm::BeginLuminosityBlockProducer> {
0301   public:
0302     static unsigned int m_count;
0303     BeginLumiProd(edm::ParameterSet const&) {}
0304 
0305     bool filter(edm::Event&, edm::EventSetup const&) override {
0306       ++m_count;
0307       return true;
0308     }
0309 
0310     static void globalBeginLuminosityBlockProduce(edm::LuminosityBlock&,
0311                                                   edm::EventSetup const&,
0312                                                   LuminosityBlockContext const*) {
0313       ++m_count;
0314     }
0315   };
0316 
0317   class EndRunProd : public edm::stream::EDFilter<edm::EndRunProducer> {
0318   public:
0319     static unsigned int m_count;
0320     EndRunProd(edm::ParameterSet const&) {}
0321 
0322     bool filter(edm::Event&, edm::EventSetup const&) override {
0323       ++m_count;
0324       return true;
0325     }
0326 
0327     static void globalEndRunProduce(edm::Run&, edm::EventSetup const&, RunContext const*) { ++m_count; }
0328   };
0329 
0330   class EndLumiProd : public edm::stream::EDFilter<edm::EndLuminosityBlockProducer> {
0331   public:
0332     static unsigned int m_count;
0333     EndLumiProd(edm::ParameterSet const&) {}
0334 
0335     bool filter(edm::Event&, edm::EventSetup const&) override {
0336       ++m_count;
0337       return true;
0338     }
0339 
0340     static void globalEndLuminosityBlockProduce(edm::LuminosityBlock&,
0341                                                 edm::EventSetup const&,
0342                                                 LuminosityBlockContext const*) {
0343       ++m_count;
0344     }
0345   };
0346 
0347   class EndRunSummaryProd : public edm::stream::EDFilter<edm::EndRunProducer, edm::RunSummaryCache<int>> {
0348   public:
0349     static unsigned int m_count;
0350     static bool m_globalEndRunSummaryCalled;
0351     EndRunSummaryProd(edm::ParameterSet const&) {}
0352 
0353     bool filter(edm::Event&, edm::EventSetup const&) override {
0354       ++m_count;
0355       return true;
0356     }
0357 
0358     static std::shared_ptr<int> globalBeginRunSummary(edm::Run const&, edm::EventSetup const&, RunContext const*) {
0359       ++m_count;
0360       return std::shared_ptr<int>{};
0361     }
0362 
0363     void endRunSummary(edm::Run const&, edm::EventSetup const&, int*) const override { ++m_count; }
0364 
0365     static void globalEndRunSummary(edm::Run const&, edm::EventSetup const&, RunContext const*, int*) {
0366       ++m_count;
0367       CPPUNIT_ASSERT(m_globalEndRunSummaryCalled == false);
0368       m_globalEndRunSummaryCalled = true;
0369     }
0370 
0371     static void globalEndRunProduce(edm::Run&, edm::EventSetup const&, RunContext const*, int const*) {
0372       ++m_count;
0373       CPPUNIT_ASSERT(m_globalEndRunSummaryCalled == true);
0374       m_globalEndRunSummaryCalled = false;
0375     }
0376   };
0377 
0378   class EndLumiSummaryProd
0379       : public edm::stream::EDFilter<edm::EndLuminosityBlockProducer, edm::LuminosityBlockSummaryCache<int>> {
0380   public:
0381     static unsigned int m_count;
0382     static bool m_globalEndLuminosityBlockSummaryCalled;
0383     EndLumiSummaryProd(edm::ParameterSet const&) {}
0384 
0385     bool filter(edm::Event&, edm::EventSetup const&) override {
0386       ++m_count;
0387       return true;
0388     }
0389 
0390     static std::shared_ptr<int> globalBeginLuminosityBlockSummary(edm::LuminosityBlock const&,
0391                                                                   edm::EventSetup const&,
0392                                                                   LuminosityBlockContext const*) {
0393       ++m_count;
0394       return std::shared_ptr<int>{};
0395     }
0396 
0397     void endLuminosityBlockSummary(edm::LuminosityBlock const&, edm::EventSetup const&, int*) const override {
0398       ++m_count;
0399     }
0400 
0401     static void globalEndLuminosityBlockSummary(edm::LuminosityBlock const&,
0402                                                 edm::EventSetup const&,
0403                                                 LuminosityBlockContext const*,
0404                                                 int*) {
0405       ++m_count;
0406       CPPUNIT_ASSERT(m_globalEndLuminosityBlockSummaryCalled == false);
0407       m_globalEndLuminosityBlockSummaryCalled = true;
0408     }
0409 
0410     static void globalEndLuminosityBlockProduce(edm::LuminosityBlock&,
0411                                                 edm::EventSetup const&,
0412                                                 LuminosityBlockContext const*,
0413                                                 int const*) {
0414       ++m_count;
0415       CPPUNIT_ASSERT(m_globalEndLuminosityBlockSummaryCalled == true);
0416       m_globalEndLuminosityBlockSummaryCalled = false;
0417     }
0418   };
0419 };
0420 unsigned int testStreamFilter::BasicProd::m_count = 0;
0421 unsigned int testStreamFilter::GlobalProd::m_count = 0;
0422 unsigned int testStreamFilter::GlobalProdWithBeginJob::m_count = 0;
0423 unsigned int testStreamFilter::RunProd::m_count = 0;
0424 unsigned int testStreamFilter::LumiProd::m_count = 0;
0425 unsigned int testStreamFilter::RunSummaryProd::m_count = 0;
0426 unsigned int testStreamFilter::LumiSummaryProd::m_count = 0;
0427 unsigned int testStreamFilter::BeginRunProd::m_count = 0;
0428 unsigned int testStreamFilter::EndRunProd::m_count = 0;
0429 unsigned int testStreamFilter::BeginLumiProd::m_count = 0;
0430 unsigned int testStreamFilter::EndLumiProd::m_count = 0;
0431 unsigned int testStreamFilter::EndRunSummaryProd::m_count = 0;
0432 bool testStreamFilter::EndRunSummaryProd::m_globalEndRunSummaryCalled = false;
0433 unsigned int testStreamFilter::EndLumiSummaryProd::m_count = 0;
0434 bool testStreamFilter::EndLumiSummaryProd::m_globalEndLuminosityBlockSummaryCalled = false;
0435 ///registration of the test so that the runner can find it
0436 CPPUNIT_TEST_SUITE_REGISTRATION(testStreamFilter);
0437 
0438 testStreamFilter::testStreamFilter()
0439     : m_prodReg(new edm::ProductRegistry{}),
0440       m_idHelper(new edm::BranchIDListHelper{}),
0441       m_associationsHelper(new edm::ThinnedAssociationsHelper{}),
0442       m_ep() {
0443   //Setup the principals
0444   m_prodReg->setFrozen();
0445   m_idHelper->updateFromRegistry(*m_prodReg);
0446   edm::EventID eventID = edm::EventID::firstValidEvent();
0447 
0448   std::string uuid = edm::createGlobalIdentifier();
0449   edm::Timestamp now(1234567UL);
0450   m_rp.reset(
0451       new edm::RunPrincipal(m_prodReg, edm::productResolversFactory::makePrimary, m_procConfig, &historyAppender_, 0));
0452   m_rp->setAux(edm::RunAuxiliary(eventID.run(), now, now));
0453   auto lumiAux = std::make_shared<edm::LuminosityBlockAuxiliary>(m_rp->run(), 1, now, now);
0454   m_lbp.reset(new edm::LuminosityBlockPrincipal(
0455       m_prodReg, edm::productResolversFactory::makePrimary, m_procConfig, &historyAppender_, 0));
0456   m_lbp->setAux(*lumiAux);
0457   m_lbp->setRunPrincipal(m_rp);
0458   edm::EventAuxiliary eventAux(eventID, uuid, now, true);
0459 
0460   //Only an EventProcessor or SubProcess is allowed to create a StreamID but I need one
0461   ShadowStreamID shadowID;
0462   shadowID.value = 0;
0463   edm::StreamID* pID = reinterpret_cast<edm::StreamID*>(&shadowID);
0464   assert(pID->value() == 0);
0465 
0466   m_ep.reset(new edm::EventPrincipal(m_prodReg,
0467                                      edm::productResolversFactory::makePrimary,
0468                                      m_idHelper,
0469                                      m_associationsHelper,
0470                                      m_procConfig,
0471                                      nullptr,
0472                                      *pID));
0473   m_ep->fillEventPrincipal(eventAux, nullptr);
0474   m_ep->setLuminosityBlockPrincipal(m_lbp.get());
0475   m_actReg.reset(new edm::ActivityRegistry);
0476 
0477   //For each transition, bind a lambda which will call the proper method of the Worker
0478   m_transToFunc[Trans::kBeginJob] = [](edm::Worker* iBase) {
0479     edm::GlobalContext globalContext(edm::GlobalContext::Transition::kBeginJob, nullptr);
0480     iBase->beginJob(globalContext);
0481   };
0482   m_transToFunc[Trans::kBeginStream] = [](edm::Worker* iBase) {
0483     edm::StreamContext streamContext(s_streamID0, nullptr);
0484     iBase->beginStream(s_streamID0, streamContext);
0485   };
0486 
0487   m_transToFunc[Trans::kGlobalBeginRun] = [this](edm::Worker* iBase) {
0488     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionGlobalBegin> Traits;
0489     edm::GlobalContext gc(edm::GlobalContext::Transition::kBeginRun, nullptr);
0490     edm::ParentContext parentContext(&gc);
0491     iBase->setActivityRegistry(m_actReg);
0492     edm::RunTransitionInfo info(*m_rp, *m_es);
0493     doWork<Traits>(iBase, info, parentContext);
0494   };
0495   m_transToFunc[Trans::kStreamBeginRun] = [this](edm::Worker* iBase) {
0496     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionStreamBegin> Traits;
0497     edm::StreamContext streamContext(s_streamID0, nullptr);
0498     edm::ParentContext parentContext(&streamContext);
0499     iBase->setActivityRegistry(m_actReg);
0500     edm::RunTransitionInfo info(*m_rp, *m_es);
0501     doWork<Traits>(iBase, info, parentContext);
0502   };
0503 
0504   m_transToFunc[Trans::kGlobalBeginLuminosityBlock] = [this](edm::Worker* iBase) {
0505     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionGlobalBegin> Traits;
0506     edm::GlobalContext gc(edm::GlobalContext::Transition::kBeginLuminosityBlock, nullptr);
0507     edm::ParentContext parentContext(&gc);
0508     iBase->setActivityRegistry(m_actReg);
0509     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0510     doWork<Traits>(iBase, info, parentContext);
0511   };
0512   m_transToFunc[Trans::kStreamBeginLuminosityBlock] = [this](edm::Worker* iBase) {
0513     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionStreamBegin> Traits;
0514     edm::StreamContext streamContext(s_streamID0, nullptr);
0515     edm::ParentContext parentContext(&streamContext);
0516     iBase->setActivityRegistry(m_actReg);
0517     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0518     doWork<Traits>(iBase, info, parentContext);
0519   };
0520 
0521   m_transToFunc[Trans::kEvent] = [this](edm::Worker* iBase) {
0522     typedef edm::OccurrenceTraits<edm::EventPrincipal, edm::BranchActionStreamBegin> Traits;
0523     edm::StreamContext streamContext(s_streamID0, nullptr);
0524     edm::ParentContext parentContext(&streamContext);
0525     iBase->setActivityRegistry(m_actReg);
0526     edm::EventTransitionInfo info(*m_ep, *m_es);
0527     doWork<Traits>(iBase, info, parentContext);
0528   };
0529 
0530   m_transToFunc[Trans::kStreamEndLuminosityBlock] = [this](edm::Worker* iBase) {
0531     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionStreamEnd> Traits;
0532     edm::StreamContext streamContext(s_streamID0, nullptr);
0533     edm::ParentContext parentContext(&streamContext);
0534     iBase->setActivityRegistry(m_actReg);
0535     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0536     doWork<Traits>(iBase, info, parentContext);
0537   };
0538   m_transToFunc[Trans::kGlobalEndLuminosityBlock] = [this](edm::Worker* iBase) {
0539     typedef edm::OccurrenceTraits<edm::LuminosityBlockPrincipal, edm::BranchActionGlobalEnd> Traits;
0540     edm::GlobalContext gc(edm::GlobalContext::Transition::kEndLuminosityBlock, nullptr);
0541     edm::ParentContext parentContext(&gc);
0542     iBase->setActivityRegistry(m_actReg);
0543     edm::LumiTransitionInfo info(*m_lbp, *m_es);
0544     doWork<Traits>(iBase, info, parentContext);
0545   };
0546 
0547   m_transToFunc[Trans::kStreamEndRun] = [this](edm::Worker* iBase) {
0548     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionStreamEnd> Traits;
0549     edm::StreamContext streamContext(s_streamID0, nullptr);
0550     edm::ParentContext parentContext(&streamContext);
0551     iBase->setActivityRegistry(m_actReg);
0552     edm::RunTransitionInfo info(*m_rp, *m_es);
0553     doWork<Traits>(iBase, info, parentContext);
0554   };
0555   m_transToFunc[Trans::kGlobalEndRun] = [this](edm::Worker* iBase) {
0556     typedef edm::OccurrenceTraits<edm::RunPrincipal, edm::BranchActionGlobalEnd> Traits;
0557     edm::GlobalContext gc(edm::GlobalContext::Transition::kEndRun, nullptr);
0558     edm::ParentContext parentContext(&gc);
0559     iBase->setActivityRegistry(m_actReg);
0560     edm::RunTransitionInfo info(*m_rp, *m_es);
0561     doWork<Traits>(iBase, info, parentContext);
0562   };
0563 
0564   m_transToFunc[Trans::kEndStream] = [](edm::Worker* iBase) {
0565     edm::StreamContext streamContext(s_streamID0, nullptr);
0566     iBase->endStream(s_streamID0, streamContext);
0567   };
0568   m_transToFunc[Trans::kEndJob] = [](edm::Worker* iBase) {
0569     edm::GlobalContext globalContext(edm::GlobalContext::Transition::kEndJob, nullptr);
0570     iBase->endJob(globalContext);
0571   };
0572 }
0573 
0574 namespace {
0575   template <typename T>
0576   std::shared_ptr<edm::stream::EDFilterAdaptorBase> createModule() {
0577     edm::ParameterSet pset;
0578     std::shared_ptr<edm::stream::EDFilterAdaptorBase> retValue =
0579         std::make_shared<edm::stream::EDFilterAdaptor<T>>(pset);
0580     edm::maker::ModuleHolderT<edm::stream::EDFilterAdaptorBase> h(retValue, nullptr);
0581     h.preallocate(edm::PreallocationConfiguration{});
0582     return retValue;
0583   }
0584   template <typename T>
0585   void testTransition(edm::Worker* iWorker,
0586                       testStreamFilter::Trans iTrans,
0587                       testStreamFilter::Expectations const& iExpect,
0588                       std::function<void(edm::Worker*)> iFunc) {
0589     assert(0 == T::m_count);
0590     iFunc(iWorker);
0591     auto count = std::count(iExpect.begin(), iExpect.end(), iTrans);
0592     if (count != T::m_count) {
0593       std::cout << "For trans " << static_cast<std::underlying_type<testStreamFilter::Trans>::type>(iTrans)
0594                 << " expected " << count << " and got " << T::m_count << std::endl;
0595     }
0596     CPPUNIT_ASSERT(T::m_count == count);
0597     T::m_count = 0;
0598     iWorker->reset();
0599   }
0600 }  // namespace
0601 
0602 template <typename T, typename U>
0603 void testStreamFilter::testTransitions(std::shared_ptr<U> iMod, Expectations const& iExpect) {
0604   oneapi::tbb::global_control control(oneapi::tbb::global_control::max_allowed_parallelism, 1);
0605 
0606   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wBeginJobEndJob{iMod, m_desc, nullptr};
0607   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wBeginStreamEndStream{iMod, m_desc, nullptr};
0608   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wGlobalLumi{iMod, m_desc, nullptr};
0609   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wStreamLumi{iMod, m_desc, nullptr};
0610   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wGlobalRun{iMod, m_desc, nullptr};
0611   edm::WorkerT<edm::stream::EDFilterAdaptorBase> wStreamRun{iMod, m_desc, nullptr};
0612   for (auto& keyVal : m_transToFunc) {
0613     edm::Worker* worker = &wBeginJobEndJob;
0614     if (keyVal.first == Trans::kBeginStream || keyVal.first == Trans::kEndStream) {
0615       worker = &wBeginStreamEndStream;
0616     } else if (keyVal.first == Trans::kStreamBeginLuminosityBlock || keyVal.first == Trans::kStreamEndLuminosityBlock) {
0617       worker = &wStreamLumi;
0618     } else if (keyVal.first == Trans::kGlobalBeginLuminosityBlock || keyVal.first == Trans::kGlobalEndLuminosityBlock) {
0619       worker = &wGlobalLumi;
0620     } else if (keyVal.first == Trans::kStreamBeginRun || keyVal.first == Trans::kStreamEndRun) {
0621       worker = &wStreamRun;
0622     } else if (keyVal.first == Trans::kGlobalBeginRun || keyVal.first == Trans::kGlobalEndRun) {
0623       worker = &wGlobalRun;
0624     }
0625     testTransition<T>(worker, keyVal.first, iExpect, keyVal.second);
0626   }
0627 }
0628 template <typename T>
0629 void testStreamFilter::runTest(Expectations const& iExpect) {
0630   auto mod = createModule<T>();
0631   CPPUNIT_ASSERT(0 == T::m_count);
0632   testTransitions<T>(mod, iExpect);
0633 }
0634 
0635 void testStreamFilter::basicTest() { runTest<BasicProd>({Trans::kEvent}); }
0636 
0637 void testStreamFilter::globalTest() {
0638   runTest<GlobalProd>({Trans::kEvent, Trans::kEndJob});
0639   runTest<GlobalProdWithBeginJob>({Trans::kBeginJob, Trans::kBeginStream, Trans::kEvent, Trans::kEndJob});
0640 }
0641 
0642 void testStreamFilter::runTest() { runTest<RunProd>({Trans::kGlobalBeginRun, Trans::kEvent, Trans::kGlobalEndRun}); }
0643 
0644 void testStreamFilter::runSummaryTest() {
0645   runTest<RunSummaryProd>({Trans::kGlobalBeginRun, Trans::kEvent, Trans::kStreamEndRun, Trans::kGlobalEndRun});
0646 }
0647 
0648 void testStreamFilter::lumiTest() {
0649   runTest<LumiProd>({Trans::kGlobalBeginLuminosityBlock, Trans::kEvent, Trans::kGlobalEndLuminosityBlock});
0650 }
0651 
0652 void testStreamFilter::lumiSummaryTest() {
0653   runTest<LumiSummaryProd>({Trans::kGlobalBeginLuminosityBlock,
0654                             Trans::kEvent,
0655                             Trans::kStreamEndLuminosityBlock,
0656                             Trans::kGlobalEndLuminosityBlock});
0657 }
0658 
0659 void testStreamFilter::beginRunProdTest() { runTest<BeginRunProd>({Trans::kGlobalBeginRun, Trans::kEvent}); }
0660 
0661 void testStreamFilter::beginLumiProdTest() {
0662   runTest<BeginLumiProd>({Trans::kGlobalBeginLuminosityBlock, Trans::kEvent});
0663 }
0664 
0665 void testStreamFilter::endRunProdTest() { runTest<EndRunProd>({Trans::kGlobalEndRun, Trans::kEvent}); }
0666 
0667 void testStreamFilter::endLumiProdTest() { runTest<EndLumiProd>({Trans::kGlobalEndLuminosityBlock, Trans::kEvent}); }
0668 
0669 void testStreamFilter::endRunSummaryProdTest() {
0670   runTest<EndRunSummaryProd>(
0671       {Trans::kGlobalEndRun, Trans::kEvent, Trans::kGlobalBeginRun, Trans::kStreamEndRun, Trans::kGlobalEndRun});
0672 }
0673 
0674 void testStreamFilter::endLumiSummaryProdTest() {
0675   runTest<EndLumiSummaryProd>({Trans::kGlobalEndLuminosityBlock,
0676                                Trans::kEvent,
0677                                Trans::kGlobalBeginLuminosityBlock,
0678                                Trans::kStreamEndLuminosityBlock,
0679                                Trans::kGlobalEndLuminosityBlock});
0680 }