File indexing completed on 2024-04-06 12:12:19
0001
0002
0003
0004
0005
0006
0007
0008
0009 #include <atomic>
0010 #include <iostream>
0011 #include <memory>
0012 #include <tuple>
0013 #include <vector>
0014
0015 #include "DataFormats/Provenance/interface/BranchDescription.h"
0016 #include "DataFormats/TestObjects/interface/ToyProducts.h"
0017 #include "FWCore/Framework/interface/CacheHandle.h"
0018 #include "FWCore/Framework/interface/Event.h"
0019 #include "FWCore/Framework/interface/LuminosityBlock.h"
0020 #include "FWCore/Framework/interface/MakerMacros.h"
0021 #include "FWCore/Framework/interface/moduleAbilities.h"
0022 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0023 #include "FWCore/Framework/interface/ProcessBlock.h"
0024 #include "FWCore/Framework/interface/Run.h"
0025 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0026 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0027 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0028 #include "FWCore/Utilities/interface/BranchType.h"
0029 #include "FWCore/Utilities/interface/EDMException.h"
0030 #include "FWCore/Utilities/interface/EDGetToken.h"
0031 #include "FWCore/Utilities/interface/InputTag.h"
0032
0033 namespace edmtest {
0034 namespace one {
0035
0036 class SharedResourcesAnalyzer : public edm::one::EDAnalyzer<edm::one::SharedResources> {
0037 public:
0038 explicit SharedResourcesAnalyzer(edm::ParameterSet const& p) : trans_(p.getParameter<int>("transitions")) {
0039 usesResource("foo");
0040 callWhenNewProductsRegistered([](edm::BranchDescription const& desc) {
0041 std::cout << "one::SharedResourcesAnalyzer " << desc.moduleLabel() << std::endl;
0042 });
0043 }
0044 const unsigned int trans_;
0045 unsigned int m_count = 0;
0046
0047 void analyze(edm::Event const&, edm::EventSetup const&) override { ++m_count; }
0048
0049 ~SharedResourcesAnalyzer() {
0050 if (m_count != trans_) {
0051 throw cms::Exception("transitions")
0052 << "SharedResourcesAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0053 }
0054 }
0055 };
0056
0057 class WatchRunsAnalyzer : public edm::one::EDAnalyzer<edm::one::WatchRuns> {
0058 public:
0059 explicit WatchRunsAnalyzer(edm::ParameterSet const& p) : trans_(p.getParameter<int>("transitions")) {}
0060 bool br = false;
0061 bool er = false;
0062 const unsigned int trans_;
0063 unsigned int m_count = 0;
0064
0065 void analyze(edm::Event const&, edm::EventSetup const&) override {
0066 ++m_count;
0067 if (!br || er) {
0068 throw cms::Exception("out of sequence") << " produce before beginRun or after endRun";
0069 }
0070 }
0071
0072 void beginRun(edm::Run const&, edm::EventSetup const&) override {
0073 ++m_count;
0074 if (br) {
0075 throw cms::Exception("out of sequence") << " beginRun seen multiple times";
0076 }
0077 br = true;
0078 er = false;
0079 }
0080
0081 void endRun(edm::Run const&, edm::EventSetup const&) override {
0082 ++m_count;
0083 if (!br) {
0084 throw cms::Exception("out of sequence") << " endRun before beginRun";
0085 }
0086 br = false;
0087 er = true;
0088 }
0089
0090 ~WatchRunsAnalyzer() {
0091 if (m_count != trans_) {
0092 throw cms::Exception("transitions")
0093 << "WatchRunsAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0094 }
0095 }
0096 };
0097
0098 class WatchLumiBlocksAnalyzer : public edm::one::EDAnalyzer<edm::one::WatchLuminosityBlocks> {
0099 public:
0100 explicit WatchLumiBlocksAnalyzer(edm::ParameterSet const& p) : trans_(p.getParameter<int>("transitions")) {
0101
0102 auto const& tag = p.getParameter<edm::InputTag>("moduleLabel");
0103 if (not tag.label().empty()) {
0104 consumes<unsigned int, edm::InLumi>(tag);
0105 }
0106 }
0107 const unsigned int trans_;
0108 bool bl = false;
0109 bool el = false;
0110 unsigned int m_count = 0;
0111
0112 void analyze(edm::Event const&, edm::EventSetup const&) override {
0113 ++m_count;
0114 if (!bl || el) {
0115 throw cms::Exception("out of sequence") << " produce before beginLumiBlock or after endLumiBlock";
0116 }
0117 }
0118
0119 void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override {
0120 ++m_count;
0121 if (bl) {
0122 throw cms::Exception("out of sequence") << " beginLumiBlock seen mutiple times";
0123 }
0124 bl = true;
0125 el = false;
0126 }
0127
0128 void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override {
0129 ++m_count;
0130 if (!bl) {
0131 throw cms::Exception("out of sequence") << " endLumiBlock before beginLumiBlock";
0132 }
0133 bl = false;
0134 el = true;
0135 }
0136
0137 ~WatchLumiBlocksAnalyzer() {
0138 if (m_count != trans_) {
0139 throw cms::Exception("transitions")
0140 << "WatchLumiBlocksAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0141 }
0142 }
0143 };
0144
0145 namespace an {
0146 struct Cache {
0147 bool begin = true;
0148 bool end = false;
0149 };
0150 }
0151 class RunCacheAnalyzer : public edm::one::EDAnalyzer<edm::RunCache<an::Cache>> {
0152 public:
0153 explicit RunCacheAnalyzer(edm::ParameterSet const& p) : trans_(p.getParameter<int>("transitions")) {}
0154 const unsigned int trans_;
0155 mutable std::atomic<unsigned int> m_count = 0;
0156
0157 void analyze(edm::Event const& iEvent, edm::EventSetup const&) override {
0158 ++m_count;
0159 auto c = runCache(iEvent.getRun().index());
0160 if (nullptr == c) {
0161 throw cms::Exception("Missing cache") << " no cache in analyze";
0162 }
0163
0164 if (!c->begin || c->end) {
0165 throw cms::Exception("out of sequence") << " produce before beginRun or after endRun";
0166 }
0167 }
0168
0169 std::shared_ptr<an::Cache> globalBeginRun(edm::Run const&, edm::EventSetup const&) const final {
0170 ++m_count;
0171 return std::make_shared<an::Cache>();
0172 }
0173
0174 void globalEndRun(edm::Run const& iRun, edm::EventSetup const&) final {
0175 ++m_count;
0176 auto c = runCache(iRun.index());
0177 if (nullptr == c) {
0178 throw cms::Exception("Missing cache") << " no cache in globalEndRun";
0179 }
0180 if (!c->begin) {
0181 throw cms::Exception("out of sequence") << " endRun before beginRun";
0182 }
0183 c->begin = false;
0184 c->end = true;
0185 }
0186
0187 ~RunCacheAnalyzer() {
0188 if (m_count != trans_) {
0189 throw cms::Exception("transitions")
0190 << "WatchRunsAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0191 }
0192 }
0193 };
0194
0195 class LumiBlockCacheAnalyzer : public edm::one::EDAnalyzer<edm::LuminosityBlockCache<an::Cache>> {
0196 public:
0197 explicit LumiBlockCacheAnalyzer(edm::ParameterSet const& p) : trans_(p.getParameter<int>("transitions")) {}
0198 const unsigned int trans_;
0199 mutable std::atomic<unsigned int> m_count = 0;
0200
0201 void analyze(edm::Event const& iEvent, edm::EventSetup const&) override {
0202 ++m_count;
0203
0204 auto c = luminosityBlockCache(iEvent.getLuminosityBlock().index());
0205 if (nullptr == c) {
0206 throw cms::Exception("Missing cache") << " no cache in analyze";
0207 }
0208
0209 if (!c->begin || c->end) {
0210 throw cms::Exception("out of sequence") << " produce before beginLumiBlock or after endLumiBlock";
0211 }
0212 }
0213
0214 std::shared_ptr<an::Cache> globalBeginLuminosityBlock(edm::LuminosityBlock const&,
0215 edm::EventSetup const&) const final {
0216 ++m_count;
0217 return std::make_shared<an::Cache>();
0218 }
0219
0220 void globalEndLuminosityBlock(edm::LuminosityBlock const& iLumi, edm::EventSetup const&) override {
0221 ++m_count;
0222 auto c = luminosityBlockCache(iLumi.index());
0223 if (!c->begin) {
0224 throw cms::Exception("out of sequence") << " endLumiBlock before beginLumiBlock";
0225 }
0226 c->begin = false;
0227 c->end = true;
0228 }
0229
0230 ~LumiBlockCacheAnalyzer() {
0231 if (m_count != trans_) {
0232 throw cms::Exception("transitions")
0233 << "WatchLumiBlocksAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0234 }
0235 }
0236 };
0237
0238 class ProcessBlockIntAnalyzer : public edm::one::EDAnalyzer<edm::WatchProcessBlock> {
0239 public:
0240 explicit ProcessBlockIntAnalyzer(edm::ParameterSet const& pset) : trans_(pset.getParameter<int>("transitions")) {
0241 {
0242 auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlock");
0243 if (not tag.label().empty()) {
0244 getTokenBegin_ = consumes<unsigned int, edm::InProcess>(tag);
0245 }
0246 }
0247 {
0248 auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlock");
0249 if (not tag.label().empty()) {
0250 getTokenEnd_ = consumes<unsigned int, edm::InProcess>(tag);
0251 }
0252 }
0253 }
0254
0255 void beginProcessBlock(edm::ProcessBlock const& processBlock) override {
0256 if (m_count != 0) {
0257 throw cms::Exception("transitions")
0258 << "ProcessBlockIntAnalyzer::begin transitions " << m_count << " but it was supposed to be " << 0;
0259 }
0260 ++m_count;
0261
0262 const unsigned int valueToGet = 11;
0263 if (not getTokenBegin_.isUninitialized()) {
0264 if (processBlock.get(getTokenBegin_) != valueToGet) {
0265 throw cms::Exception("BadValue")
0266 << "expected " << valueToGet << " but got " << processBlock.get(getTokenBegin_);
0267 }
0268 }
0269 }
0270
0271 void analyze(edm::Event const&, edm::EventSetup const&) override {
0272 if (m_count < 1u) {
0273 throw cms::Exception("out of sequence") << "analyze before beginProcessBlock " << m_count;
0274 }
0275 ++m_count;
0276 }
0277
0278 void endProcessBlock(edm::ProcessBlock const& processBlock) override {
0279 ++m_count;
0280 if (m_count != trans_) {
0281 throw cms::Exception("transitions")
0282 << "ProcessBlockIntAnalyzer::end transitions " << m_count << " but it was supposed to be " << trans_;
0283 }
0284
0285 {
0286 const unsigned int valueToGet = 11;
0287 if (not getTokenBegin_.isUninitialized()) {
0288 if (processBlock.get(getTokenBegin_) != valueToGet) {
0289 throw cms::Exception("BadValue")
0290 << "expected " << valueToGet << " but got " << processBlock.get(getTokenBegin_);
0291 }
0292 }
0293 }
0294 {
0295 const unsigned int valueToGet = 21;
0296 if (not getTokenEnd_.isUninitialized()) {
0297 if (processBlock.get(getTokenEnd_) != valueToGet) {
0298 throw cms::Exception("BadValue")
0299 << "expected " << valueToGet << " but got " << processBlock.get(getTokenEnd_);
0300 }
0301 }
0302 }
0303 }
0304
0305 ~ProcessBlockIntAnalyzer() {
0306 if (m_count != trans_) {
0307 throw cms::Exception("transitions")
0308 << "ProcessBlockIntAnalyzer transitions " << m_count << " but it was supposed to be " << trans_;
0309 }
0310 }
0311
0312 private:
0313 const unsigned int trans_;
0314 mutable std::atomic<unsigned int> m_count{0};
0315 edm::EDGetTokenT<unsigned int> getTokenBegin_;
0316 edm::EDGetTokenT<unsigned int> getTokenEnd_;
0317 };
0318
0319 class TestInputProcessBlockCache {
0320 public:
0321 long long int value_ = 0;
0322 };
0323
0324 class TestInputProcessBlockCache1 {
0325 public:
0326 long long int value_ = 0;
0327 };
0328
0329 class InputProcessBlockIntAnalyzer
0330 : public edm::one::EDAnalyzer<
0331 edm::WatchProcessBlock,
0332 edm::InputProcessBlockCache<int, TestInputProcessBlockCache, TestInputProcessBlockCache1>> {
0333 public:
0334 explicit InputProcessBlockIntAnalyzer(edm::ParameterSet const& pset) {
0335 expectedTransitions_ = pset.getParameter<int>("transitions");
0336 expectedByRun_ = pset.getParameter<std::vector<int>>("expectedByRun");
0337 expectedSum_ = pset.getParameter<int>("expectedSum");
0338 expectedFillerSum_ = pset.getUntrackedParameter<int>("expectedFillerSum", 0);
0339 expectedCacheSize_ = pset.getUntrackedParameter<unsigned int>("expectedCacheSize", 0);
0340 {
0341 auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlock");
0342 if (not tag.label().empty()) {
0343 getTokenBegin_ = consumes<IntProduct, edm::InProcess>(tag);
0344 }
0345 }
0346 {
0347 auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlock");
0348 if (not tag.label().empty()) {
0349 getTokenEnd_ = consumes<IntProduct, edm::InProcess>(tag);
0350 }
0351 }
0352 {
0353 auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlockM");
0354 if (not tag.label().empty()) {
0355 getTokenBeginM_ = consumes<IntProduct, edm::InProcess>(tag);
0356 }
0357 }
0358 {
0359 auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlockM");
0360 if (not tag.label().empty()) {
0361 getTokenEndM_ = consumes<IntProduct, edm::InProcess>(tag);
0362 }
0363 }
0364 {
0365 auto tag = pset.getParameter<edm::InputTag>("consumesBeginProcessBlockNotFound");
0366 if (not tag.label().empty()) {
0367 getTokenBeginNotFound_ = consumes<IntProduct, edm::InProcess>(tag);
0368 }
0369 }
0370 {
0371 auto tag = pset.getParameter<edm::InputTag>("consumesEndProcessBlockNotFound");
0372 if (not tag.label().empty()) {
0373 getTokenEndNotFound_ = consumes<IntProduct, edm::InProcess>(tag);
0374 }
0375 }
0376 {
0377 auto tag = pset.getParameter<edm::InputTag>("consumesProcessBlockNotFound1");
0378 if (not tag.label().empty()) {
0379 getTokenNotFound1_ = consumes<IntProduct, edm::InProcess>(tag);
0380 }
0381 }
0382 {
0383 auto tag = pset.getParameter<edm::InputTag>("consumesProcessBlockNotFound2");
0384 if (not tag.label().empty()) {
0385 getTokenNotFound2_ = consumes<IntProduct, edm::InProcess>(tag);
0386 }
0387 }
0388 {
0389 auto tag = pset.getParameter<edm::InputTag>("consumesProcessBlockNotFound3");
0390 if (not tag.label().empty()) {
0391 getTokenNotFound3_ = consumes<IntProduct, edm::InProcess>(tag);
0392 }
0393 }
0394 {
0395 auto tag = pset.getParameter<edm::InputTag>("consumesProcessBlockNotFound4");
0396 if (not tag.label().empty()) {
0397 getTokenNotFound4_ = consumes<IntProduct, edm::InProcess>(tag);
0398 }
0399 }
0400
0401 if (!getTokenBegin_.isUninitialized()) {
0402 registerProcessBlockCacheFiller<int>(
0403 getTokenBegin_, [this](edm::ProcessBlock const& processBlock, std::shared_ptr<int> const& previousCache) {
0404 auto returnValue = std::make_shared<int>(0);
0405 *returnValue += processBlock.get(getTokenBegin_).value;
0406 *returnValue += processBlock.get(getTokenEnd_).value;
0407 fillerSum_ += processBlock.get(getTokenBegin_).value;
0408 fillerSum_ += processBlock.get(getTokenEnd_).value;
0409 ++transitions_;
0410 return returnValue;
0411 });
0412 }
0413 if (!getTokenBegin_.isUninitialized()) {
0414 registerProcessBlockCacheFiller<1>(getTokenBegin_,
0415 [this](edm::ProcessBlock const& processBlock,
0416 std::shared_ptr<TestInputProcessBlockCache> const& previousCache) {
0417 auto returnValue = std::make_shared<TestInputProcessBlockCache>();
0418 returnValue->value_ += processBlock.get(getTokenBegin_).value;
0419 returnValue->value_ += processBlock.get(getTokenEnd_).value;
0420 fillerSum_ += processBlock.get(getTokenBegin_).value;
0421 fillerSum_ += processBlock.get(getTokenEnd_).value;
0422 ++transitions_;
0423 return returnValue;
0424 });
0425 }
0426 if (!getTokenBegin_.isUninitialized()) {
0427 registerProcessBlockCacheFiller<TestInputProcessBlockCache1>(
0428 getTokenBegin_,
0429 [this](edm::ProcessBlock const& processBlock,
0430 std::shared_ptr<TestInputProcessBlockCache1> const& previousCache) {
0431 auto returnValue = std::make_shared<TestInputProcessBlockCache1>();
0432 returnValue->value_ += processBlock.get(getTokenBegin_).value;
0433 returnValue->value_ += processBlock.get(getTokenEnd_).value;
0434 fillerSum_ += processBlock.get(getTokenBegin_).value;
0435 fillerSum_ += processBlock.get(getTokenEnd_).value;
0436 ++transitions_;
0437 return returnValue;
0438 });
0439 }
0440 }
0441
0442 void beginProcessBlock(edm::ProcessBlock const& processBlock) override {
0443 if (!getTokenBeginNotFound_.isUninitialized() && processBlock.getHandle(getTokenBeginNotFound_).isValid()) {
0444 throw cms::Exception("TestFailure") << "Expected handle to be invalid but it is valid (begin)";
0445 }
0446 }
0447
0448 void endProcessBlock(edm::ProcessBlock const& processBlock) override {
0449 if (!getTokenEndNotFound_.isUninitialized() && processBlock.getHandle(getTokenEndNotFound_).isValid()) {
0450 throw cms::Exception("TestFailure") << "Expected handle to be invalid but it is valid (end)";
0451 }
0452 }
0453
0454 void accessInputProcessBlock(edm::ProcessBlock const& processBlock) override {
0455 if (processBlock.processName() == "PROD1") {
0456 if (!getTokenBegin_.isUninitialized() && processBlock.getHandle(getTokenBegin_).isValid()) {
0457 sum_ += processBlock.get(getTokenBegin_).value;
0458 sum_ += processBlock.get(getTokenEnd_).value;
0459 }
0460 }
0461 if (processBlock.processName() == "MERGE") {
0462 if (!getTokenBeginM_.isUninitialized() && processBlock.getHandle(getTokenBeginM_).isValid()) {
0463 sum_ += processBlock.get(getTokenBeginM_).value;
0464 sum_ += processBlock.get(getTokenEndM_).value;
0465 }
0466 }
0467
0468 if (!getTokenNotFound1_.isUninitialized() && processBlock.getHandle(getTokenNotFound1_).isValid()) {
0469 throw cms::Exception("TestFailure") << "Expected handle to be invalid but it is valid (token 1)";
0470 }
0471 if (!getTokenNotFound2_.isUninitialized() && processBlock.getHandle(getTokenNotFound2_).isValid()) {
0472 throw cms::Exception("TestFailure") << "Expected handle to be invalid but it is valid (token 2)";
0473 }
0474 if (!getTokenNotFound3_.isUninitialized() && processBlock.getHandle(getTokenNotFound3_).isValid()) {
0475 throw cms::Exception("TestFailure") << "Expected handle to be invalid but it is valid (token 3)";
0476 }
0477 if (!getTokenNotFound4_.isUninitialized() && processBlock.getHandle(getTokenNotFound4_).isValid()) {
0478 throw cms::Exception("TestFailure") << "Expected handle to be invalid but it is valid (token 4)";
0479 }
0480
0481 ++transitions_;
0482 }
0483
0484 void analyze(edm::Event const& event, edm::EventSetup const&) override {
0485 auto cacheTuple = processBlockCaches(event);
0486 if (!expectedByRun_.empty()) {
0487 if (expectedByRun_.at(event.run() - 1) != *std::get<edm::CacheHandle<int>>(cacheTuple)) {
0488 throw cms::Exception("UnexpectedValue")
0489 << "InputProcessBlockIntAnalyzer::analyze cached value was "
0490 << *std::get<edm::CacheHandle<int>>(cacheTuple) << " but it was supposed to be "
0491 << expectedByRun_.at(event.run() - 1);
0492 }
0493 if (expectedByRun_.at(event.run() - 1) != std::get<1>(cacheTuple)->value_) {
0494 throw cms::Exception("UnexpectedValue")
0495 << "InputProcessBlockIntAnalyzer::analyze second cached value was " << std::get<1>(cacheTuple)->value_
0496 << " but it was supposed to be " << expectedByRun_.at(event.run() - 1);
0497 }
0498 if (expectedByRun_.at(event.run() - 1) !=
0499 std::get<edm::CacheHandle<TestInputProcessBlockCache1>>(cacheTuple)->value_) {
0500 throw cms::Exception("UnexpectedValue")
0501 << "InputProcessBlockIntAnalyzer::analyze third cached value was "
0502 << std::get<edm::CacheHandle<TestInputProcessBlockCache1>>(cacheTuple)->value_
0503 << " but it was supposed to be " << expectedByRun_.at(event.run() - 1);
0504 }
0505 }
0506
0507 if (expectedCacheSize_ != 0u && expectedCacheSize_ != cacheSize()) {
0508 throw cms::Exception("UnexpectedValue") << "InputProcessBlockIntAnalyzer::analyze, unexpected cacheSize "
0509 << cacheSize() << " but it was supposed to be " << expectedCacheSize_;
0510 }
0511 ++transitions_;
0512 }
0513
0514 void endJob() override {
0515 if (transitions_ != expectedTransitions_) {
0516 throw cms::Exception("transitions") << "InputProcessBlockIntAnalyzer transitions " << transitions_
0517 << " but it was supposed to be " << expectedTransitions_;
0518 }
0519 if (sum_ != expectedSum_) {
0520 throw cms::Exception("UnexpectedValue")
0521 << "InputProcessBlockIntAnalyzer sum " << sum_ << " but it was supposed to be " << expectedSum_;
0522 }
0523 if (expectedFillerSum_ != 0 && fillerSum_ != expectedFillerSum_) {
0524 throw cms::Exception("UnexpectedValue") << "InputProcessBlockIntAnalyzer fillerSum " << fillerSum_
0525 << " but it was supposed to be " << expectedFillerSum_;
0526 }
0527 if (cacheSize() > 0u) {
0528 throw cms::Exception("UnexpectedValue")
0529 << "InputProcessBlockIntAnalyzer cache size not zero at endJob " << cacheSize();
0530 }
0531 }
0532
0533 static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0534 edm::ParameterSetDescription desc;
0535 desc.add<int>("transitions");
0536 desc.add<std::vector<int>>("expectedByRun", std::vector<int>());
0537 desc.add<int>("expectedSum");
0538 edm::InputTag defaultInputTag;
0539 desc.addUntracked<int>("expectedFillerSum", 0);
0540 desc.addUntracked<unsigned int>("expectedCacheSize", 0);
0541 desc.add<edm::InputTag>("consumesBeginProcessBlock", defaultInputTag);
0542 desc.add<edm::InputTag>("consumesEndProcessBlock", defaultInputTag);
0543 desc.add<edm::InputTag>("consumesBeginProcessBlockM", defaultInputTag);
0544 desc.add<edm::InputTag>("consumesEndProcessBlockM", defaultInputTag);
0545 desc.add<edm::InputTag>("consumesBeginProcessBlockNotFound", defaultInputTag);
0546 desc.add<edm::InputTag>("consumesEndProcessBlockNotFound", defaultInputTag);
0547 desc.add<edm::InputTag>("consumesProcessBlockNotFound1", defaultInputTag);
0548 desc.add<edm::InputTag>("consumesProcessBlockNotFound2", defaultInputTag);
0549 desc.add<edm::InputTag>("consumesProcessBlockNotFound3", defaultInputTag);
0550 desc.add<edm::InputTag>("consumesProcessBlockNotFound4", defaultInputTag);
0551 descriptions.addDefault(desc);
0552 }
0553
0554 private:
0555 edm::EDGetTokenT<IntProduct> getTokenBegin_;
0556 edm::EDGetTokenT<IntProduct> getTokenEnd_;
0557 edm::EDGetTokenT<IntProduct> getTokenBeginM_;
0558 edm::EDGetTokenT<IntProduct> getTokenEndM_;
0559 edm::EDGetTokenT<IntProduct> getTokenBeginNotFound_;
0560 edm::EDGetTokenT<IntProduct> getTokenEndNotFound_;
0561 edm::EDGetTokenT<IntProduct> getTokenNotFound1_;
0562 edm::EDGetTokenT<IntProduct> getTokenNotFound2_;
0563 edm::EDGetTokenT<IntProduct> getTokenNotFound3_;
0564 edm::EDGetTokenT<IntProduct> getTokenNotFound4_;
0565 mutable std::atomic<unsigned int> transitions_{0};
0566 int sum_{0};
0567 unsigned int expectedTransitions_{0};
0568 std::vector<int> expectedByRun_;
0569 int expectedSum_{0};
0570 int fillerSum_{0};
0571 int expectedFillerSum_{0};
0572 unsigned int expectedCacheSize_{0};
0573 };
0574
0575 }
0576 }
0577
0578 DEFINE_FWK_MODULE(edmtest::one::SharedResourcesAnalyzer);
0579 DEFINE_FWK_MODULE(edmtest::one::WatchRunsAnalyzer);
0580 DEFINE_FWK_MODULE(edmtest::one::WatchLumiBlocksAnalyzer);
0581 DEFINE_FWK_MODULE(edmtest::one::RunCacheAnalyzer);
0582 DEFINE_FWK_MODULE(edmtest::one::LumiBlockCacheAnalyzer);
0583 DEFINE_FWK_MODULE(edmtest::one::ProcessBlockIntAnalyzer);
0584 DEFINE_FWK_MODULE(edmtest::one::InputProcessBlockIntAnalyzer);
