File indexing completed on 2023-03-17 11:02:36
0001
0002
0003
0004
0005
0006
0007
0008
0009 #include <iostream>
0010 #include "cppunit/extensions/HelperMacros.h"
0011 #include <memory>
0012 #include "FWCore/Utilities/interface/GetPassID.h"
0013 #include "FWCore/Version/interface/GetReleaseVersion.h"
0014
0015 #include "FWCore/Framework/interface/SignallingProductRegistry.h"
0016 #include "FWCore/Framework/interface/ConstProductRegistry.h"
0017 #include "FWCore/Framework/interface/PreallocationConfiguration.h"
0018
0019 #include "FWCore/Framework/interface/global/EDProducer.h"
0020 #include "FWCore/Framework/interface/ExceptionActions.h"
0021 #include "DataFormats/Provenance/interface/ProductRegistry.h"
0022 #include "DataFormats/Provenance/interface/ProcessConfiguration.h"
0023 #include "FWCore/Framework/interface/maker/WorkerMaker.h"
0024 #include "FWCore/Framework/interface/maker/MakeModuleParams.h"
0025 #include "FWCore/Framework/interface/maker/WorkerT.h"
0026
0027 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0028
0029 #include "FWCore/ServiceRegistry/interface/ServiceRegistry.h"
0030 #include "FWCore/Utilities/interface/TypeID.h"
0031
0032 class testEDProducerProductRegistryCallback : public CppUnit::TestFixture {
0033 CPPUNIT_TEST_SUITE(testEDProducerProductRegistryCallback);
0034
0035 CPPUNIT_TEST_EXCEPTION(testCircularRef, cms::Exception);
0036 CPPUNIT_TEST_EXCEPTION(testCircularRef2, cms::Exception);
0037 CPPUNIT_TEST(testTwoListeners);
0038
0039 CPPUNIT_TEST_SUITE_END();
0040
0041 public:
0042 void setUp() {}
0043 void tearDown() {}
0044 void testCircularRef();
0045 void testCircularRef2();
0046 void testTwoListeners();
0047 };
0048
0049
0050 CPPUNIT_TEST_SUITE_REGISTRATION(testEDProducerProductRegistryCallback);
0051
0052 using namespace edm;
0053
0054 namespace {
0055 class TestMod : public global::EDProducer<> {
0056 public:
0057 explicit TestMod(ParameterSet const& p);
0058
0059 void produce(StreamID, Event& e, EventSetup const&) const override;
0060
0061 void listen(BranchDescription const&);
0062 };
0063
0064 TestMod::TestMod(ParameterSet const&) { produces<int>(); }
0065
0066 void TestMod::produce(StreamID, Event&, EventSetup const&) const {}
0067
0068 class ListenMod : public global::EDProducer<> {
0069 public:
0070 explicit ListenMod(ParameterSet const&);
0071 void produce(StreamID, Event& e, EventSetup const&) const override;
0072 void listen(BranchDescription const&);
0073 };
0074
0075 ListenMod::ListenMod(ParameterSet const&) {
0076 callWhenNewProductsRegistered(
0077 [this](BranchDescription const& branchDescription) { this->listen(branchDescription); });
0078 }
0079 void ListenMod::produce(StreamID, Event&, EventSetup const&) const {}
0080
0081 void ListenMod::listen(BranchDescription const& iDesc) {
0082 edm::TypeID intType(typeid(int));
0083
0084 if (iDesc.friendlyClassName() == intType.friendlyClassName()) {
0085 produces<int>(iDesc.moduleLabel() + "-" + iDesc.productInstanceName());
0086
0087 }
0088 }
0089
0090 class ListenFloatMod : public global::EDProducer<> {
0091 public:
0092 explicit ListenFloatMod(ParameterSet const&);
0093 void produce(StreamID, Event& e, EventSetup const&) const;
0094 void listen(BranchDescription const&);
0095 };
0096
0097 ListenFloatMod::ListenFloatMod(ParameterSet const&) {
0098 callWhenNewProductsRegistered(
0099 [this](BranchDescription const& branchDescription) { this->listen(branchDescription); });
0100 }
0101 void ListenFloatMod::produce(StreamID, Event&, EventSetup const&) const {}
0102
0103 void ListenFloatMod::listen(BranchDescription const& iDesc) {
0104 edm::TypeID intType(typeid(int));
0105
0106 if (iDesc.friendlyClassName() == intType.friendlyClassName()) {
0107 produces<float>(iDesc.moduleLabel() + "-" + iDesc.productInstanceName());
0108
0109 }
0110 }
0111 }
0112
0113 void testEDProducerProductRegistryCallback::testCircularRef() {
0114 using namespace edm;
0115
0116 SignallingProductRegistry preg;
0117
0118
0119 auto cReg = std::make_unique<ConstProductRegistry>(preg);
0120 ServiceToken token = ServiceRegistry::createContaining(std::move(cReg));
0121 ServiceRegistry::Operate startServices(token);
0122
0123 std::unique_ptr<Maker> f = std::make_unique<WorkerMaker<TestMod>>();
0124
0125 ParameterSet p1;
0126 p1.addParameter("@module_type", std::string("TestMod"));
0127 p1.addParameter("@module_label", std::string("t1"));
0128 p1.addParameter("@module_edm_type", std::string("EDProducer"));
0129 p1.registerIt();
0130
0131 ParameterSet p2;
0132 p2.addParameter("@module_type", std::string("TestMod"));
0133 p2.addParameter("@module_label", std::string("t2"));
0134 p2.addParameter("@module_edm_type", std::string("EDProducer"));
0135 p2.registerIt();
0136
0137 edm::ExceptionToActionTable table;
0138 edm::PreallocationConfiguration prealloc;
0139
0140 edm::ParameterSet dummyProcessPset;
0141 dummyProcessPset.registerIt();
0142 auto pc =
0143 std::make_shared<ProcessConfiguration>("PROD", dummyProcessPset.id(), edm::getReleaseVersion(), edm::getPassID());
0144
0145 edm::MakeModuleParams params1(&p1, preg, &prealloc, pc);
0146 edm::MakeModuleParams params2(&p2, preg, &prealloc, pc);
0147
0148 std::unique_ptr<Maker> lM = std::make_unique<WorkerMaker<ListenMod>>();
0149 ParameterSet l1;
0150 l1.addParameter("@module_type", std::string("ListenMod"));
0151 l1.addParameter("@module_label", std::string("l1"));
0152 l1.addParameter("@module_edm_type", std::string("EDProducer"));
0153 l1.registerIt();
0154
0155 ParameterSet l2;
0156 l2.addParameter("@module_type", std::string("ListenMod"));
0157 l2.addParameter("@module_label", std::string("l2"));
0158 l2.addParameter("@module_edm_type", std::string("EDProducer"));
0159 l2.registerIt();
0160
0161 edm::MakeModuleParams paramsl1(&l1, preg, &prealloc, pc);
0162 edm::MakeModuleParams paramsl2(&l2, preg, &prealloc, pc);
0163
0164 signalslot::Signal<void(const ModuleDescription&)> aSignal;
0165
0166 auto m1 = f->makeModule(params1, aSignal, aSignal);
0167 std::unique_ptr<Worker> w1 = m1->makeWorker(&table);
0168 auto ml1 = lM->makeModule(paramsl1, aSignal, aSignal);
0169 std::unique_ptr<Worker> wl1 = ml1->makeWorker(&table);
0170 auto ml2 = lM->makeModule(paramsl2, aSignal, aSignal);
0171 std::unique_ptr<Worker> wl2 = ml2->makeWorker(&table);
0172 auto m2 = f->makeModule(params2, aSignal, aSignal);
0173 std::unique_ptr<Worker> w2 = m2->makeWorker(&table);
0174
0175
0176
0177
0178
0179
0180
0181
0182
0183
0184
0185
0186
0187 CPPUNIT_ASSERT(10 == preg.size());
0188 }
0189
0190 void testEDProducerProductRegistryCallback::testCircularRef2() {
0191 using namespace edm;
0192
0193 SignallingProductRegistry preg;
0194
0195
0196 auto cReg = std::make_unique<ConstProductRegistry>(preg);
0197 ServiceToken token = ServiceRegistry::createContaining(std::move(cReg));
0198 ServiceRegistry::Operate startServices(token);
0199
0200 std::unique_ptr<Maker> f = std::make_unique<WorkerMaker<TestMod>>();
0201
0202 ParameterSet p1;
0203 p1.addParameter("@module_type", std::string("TestMod"));
0204 p1.addParameter("@module_label", std::string("t1"));
0205 p1.addParameter("@module_edm_type", std::string("EDProducer"));
0206 p1.registerIt();
0207
0208 ParameterSet p2;
0209 p2.addParameter("@module_type", std::string("TestMod"));
0210 p2.addParameter("@module_label", std::string("t2"));
0211 p2.addParameter("@module_edm_type", std::string("EDProducer"));
0212 p2.registerIt();
0213
0214 edm::ExceptionToActionTable table;
0215 edm::PreallocationConfiguration prealloc;
0216
0217 edm::ParameterSet dummyProcessPset;
0218 dummyProcessPset.registerIt();
0219 auto pc =
0220 std::make_shared<ProcessConfiguration>("PROD", dummyProcessPset.id(), edm::getReleaseVersion(), edm::getPassID());
0221
0222 edm::MakeModuleParams params1(&p1, preg, &prealloc, pc);
0223 edm::MakeModuleParams params2(&p2, preg, &prealloc, pc);
0224
0225 std::unique_ptr<Maker> lM = std::make_unique<WorkerMaker<ListenMod>>();
0226 ParameterSet l1;
0227 l1.addParameter("@module_type", std::string("ListenMod"));
0228 l1.addParameter("@module_label", std::string("l1"));
0229 l1.addParameter("@module_edm_type", std::string("EDProducer"));
0230 l1.registerIt();
0231
0232 ParameterSet l2;
0233 l2.addParameter("@module_type", std::string("ListenMod"));
0234 l2.addParameter("@module_label", std::string("l2"));
0235 l2.addParameter("@module_edm_type", std::string("EDProducer"));
0236 l2.registerIt();
0237
0238 edm::MakeModuleParams paramsl1(&l1, preg, &prealloc, pc);
0239 edm::MakeModuleParams paramsl2(&l2, preg, &prealloc, pc);
0240
0241 signalslot::Signal<void(const ModuleDescription&)> aSignal;
0242 auto ml1 = lM->makeModule(paramsl1, aSignal, aSignal);
0243 std::unique_ptr<Worker> wl1 = ml1->makeWorker(&table);
0244 auto ml2 = lM->makeModule(paramsl2, aSignal, aSignal);
0245 std::unique_ptr<Worker> wl2 = ml2->makeWorker(&table);
0246 auto m1 = f->makeModule(params1, aSignal, aSignal);
0247 std::unique_ptr<Worker> w1 = m1->makeWorker(&table);
0248 auto m2 = f->makeModule(params2, aSignal, aSignal);
0249 std::unique_ptr<Worker> w2 = m2->makeWorker(&table);
0250
0251
0252
0253
0254
0255
0256
0257
0258
0259
0260
0261
0262
0263 CPPUNIT_ASSERT(10 == preg.size());
0264 }
0265
0266 void testEDProducerProductRegistryCallback::testTwoListeners() {
0267 using namespace edm;
0268
0269 SignallingProductRegistry preg;
0270
0271
0272 auto cReg = std::make_unique<ConstProductRegistry>(preg);
0273 ServiceToken token = ServiceRegistry::createContaining(std::move(cReg));
0274 ServiceRegistry::Operate startServices(token);
0275
0276 std::unique_ptr<Maker> f = std::make_unique<WorkerMaker<TestMod>>();
0277
0278 ParameterSet p1;
0279 p1.addParameter("@module_type", std::string("TestMod"));
0280 p1.addParameter("@module_label", std::string("t1"));
0281 p1.addParameter("@module_edm_type", std::string("EDProducer"));
0282 p1.registerIt();
0283
0284 ParameterSet p2;
0285 p2.addParameter("@module_type", std::string("TestMod"));
0286 p2.addParameter("@module_label", std::string("t2"));
0287 p2.addParameter("@module_edm_type", std::string("EDProducer"));
0288 p2.registerIt();
0289
0290 edm::ExceptionToActionTable table;
0291 edm::PreallocationConfiguration prealloc;
0292
0293 edm::ParameterSet dummyProcessPset;
0294 dummyProcessPset.registerIt();
0295 auto pc =
0296 std::make_shared<ProcessConfiguration>("PROD", dummyProcessPset.id(), edm::getReleaseVersion(), edm::getPassID());
0297
0298 edm::MakeModuleParams params1(&p1, preg, &prealloc, pc);
0299 edm::MakeModuleParams params2(&p2, preg, &prealloc, pc);
0300
0301 std::unique_ptr<Maker> lM = std::make_unique<WorkerMaker<ListenMod>>();
0302 ParameterSet l1;
0303 l1.addParameter("@module_type", std::string("ListenMod"));
0304 l1.addParameter("@module_label", std::string("l1"));
0305 l1.addParameter("@module_edm_type", std::string("EDProducer"));
0306 l1.registerIt();
0307
0308 std::unique_ptr<Maker> lFM = std::make_unique<WorkerMaker<ListenFloatMod>>();
0309 ParameterSet l2;
0310 l2.addParameter("@module_type", std::string("ListenMod"));
0311 l2.addParameter("@module_label", std::string("l2"));
0312 l2.addParameter("@module_edm_type", std::string("EDProducer"));
0313 l2.registerIt();
0314
0315 edm::MakeModuleParams paramsl1(&l1, preg, &prealloc, pc);
0316 edm::MakeModuleParams paramsl2(&l2, preg, &prealloc, pc);
0317
0318 signalslot::Signal<void(const ModuleDescription&)> aSignal;
0319 auto m1 = f->makeModule(params1, aSignal, aSignal);
0320 std::unique_ptr<Worker> w1 = m1->makeWorker(&table);
0321 auto ml1 = lM->makeModule(paramsl1, aSignal, aSignal);
0322 std::unique_ptr<Worker> wl1 = ml1->makeWorker(&table);
0323 auto ml2 = lFM->makeModule(paramsl2, aSignal, aSignal);
0324 std::unique_ptr<Worker> wl2 = ml2->makeWorker(&table);
0325 auto m2 = f->makeModule(params2, aSignal, aSignal);
0326 std::unique_ptr<Worker> w2 = m2->makeWorker(&table);
0327
0328
0329
0330
0331
0332
0333
0334
0335
0336
0337
0338 CPPUNIT_ASSERT(8 == preg.size());
0339 }