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