File indexing completed on 2024-04-06 12:12:26
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017 #include "DataFormats/Provenance/interface/EventID.h"
0018 #include "DataFormats/Provenance/interface/Timestamp.h"
0019 #include "FWCore/Framework/interface/ComponentDescription.h"
0020 #include "FWCore/Framework/interface/ESProductResolverProvider.h"
0021 #include "FWCore/Framework/interface/EDConsumerBase.h"
0022 #include "FWCore/Framework/interface/ConsumesCollector.h"
0023 #include "FWCore/Framework/interface/ESHandle.h"
0024 #include "FWCore/Framework/interface/ESTransientHandle.h"
0025 #include "FWCore/Framework/interface/ESRecordsToProductResolverIndices.h"
0026 #include "FWCore/Framework/interface/EventSetupImpl.h"
0027 #include "FWCore/Framework/interface/EventSetupProvider.h"
0028 #include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
0029 #include "FWCore/Framework/interface/IOVSyncValue.h"
0030 #include "FWCore/Framework/interface/RecordDependencyRegister.h"
0031 #include "FWCore/Framework/interface/NoRecordException.h"
0032 #include "FWCore/Framework/interface/MakeDataException.h"
0033 #include "FWCore/Framework/interface/ValidityInterval.h"
0034
0035 #include "FWCore/Framework/src/SynchronousEventSetupsController.h"
0036
0037 #include "FWCore/Framework/test/DummyData.h"
0038 #include "FWCore/Framework/test/DummyEventSetupRecordRetriever.h"
0039 #include "FWCore/Framework/test/DummyESProductResolverProvider.h"
0040 #include "FWCore/Framework/test/DummyRecord.h"
0041
0042 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0043 #include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
0044 #include "FWCore/Utilities/interface/Exception.h"
0045 #include "FWCore/Utilities/interface/ESProductTag.h"
0046 #include "FWCore/Concurrency/interface/ThreadsController.h"
0047 #include "FWCore/Concurrency/interface/FinalWaitingTask.h"
0048
0049 #include "cppunit/extensions/HelperMacros.h"
0050
0051 #include <memory>
0052 #include <optional>
0053 #include <string>
0054 #include <vector>
0055
0056 using namespace edm;
0057 using namespace edm::eventsetup;
0058 using edm::eventsetup::test::DummyData;
0059 using edm::eventsetup::test::DummyESProductResolverProvider;
0060
0061 namespace {
0062
0063 bool non_null(const void* iPtr) { return iPtr != nullptr; }
0064
0065 edm::ParameterSet createDummyPset() {
0066 edm::ParameterSet pset;
0067 std::vector<std::string> emptyVStrings;
0068 pset.addParameter<std::vector<std::string>>("@all_esprefers", emptyVStrings);
0069 pset.addParameter<std::vector<std::string>>("@all_essources", emptyVStrings);
0070 pset.addParameter<std::vector<std::string>>("@all_esmodules", emptyVStrings);
0071 return pset;
0072 }
0073 }
0074
0075 class testEventsetup : public CppUnit::TestFixture {
0076 CPPUNIT_TEST_SUITE(testEventsetup);
0077
0078 CPPUNIT_TEST(constructTest);
0079 CPPUNIT_TEST(getTest);
0080 CPPUNIT_TEST(tryToGetTest);
0081 CPPUNIT_TEST_EXCEPTION(getExcTest, edm::eventsetup::NoRecordException<DummyRecord>);
0082 CPPUNIT_TEST(provenanceTest);
0083 CPPUNIT_TEST(getDataWithESGetTokenTest);
0084 CPPUNIT_TEST(getHandleWithESGetTokenTest);
0085 CPPUNIT_TEST(getTransientHandleWithESGetTokenTest);
0086 CPPUNIT_TEST(recordValidityTest);
0087 CPPUNIT_TEST_EXCEPTION(recordValidityExcTest, edm::eventsetup::NoRecordException<DummyRecord>);
0088 CPPUNIT_TEST(recordValidityNoFinderTest);
0089 CPPUNIT_TEST_EXCEPTION(recordValidityNoFinderExcTest, edm::eventsetup::NoRecordException<DummyRecord>);
0090 CPPUNIT_TEST(recordValidityResolverNoFinderTest);
0091 CPPUNIT_TEST_EXCEPTION(recordValidityResolverNoFinderExcTest, edm::eventsetup::NoRecordException<DummyRecord>);
0092
0093 CPPUNIT_TEST_EXCEPTION(producerConflictTest, cms::Exception);
0094 CPPUNIT_TEST_EXCEPTION(sourceConflictTest, cms::Exception);
0095 CPPUNIT_TEST(twoSourceTest);
0096 CPPUNIT_TEST(sourceProducerResolutionTest);
0097 CPPUNIT_TEST(preferTest);
0098
0099 CPPUNIT_TEST(introspectionTest);
0100
0101 CPPUNIT_TEST(iovExtensionTest);
0102 CPPUNIT_TEST(resetProxiesTest);
0103
0104 CPPUNIT_TEST_SUITE_END();
0105
0106 public:
0107 void setUp() { m_scheduler = std::make_unique<edm::ThreadsController>(1); }
0108 void tearDown() {}
0109
0110 void constructTest();
0111 void getTest();
0112 void tryToGetTest();
0113 void getExcTest();
0114 void recordValidityTest();
0115 void recordValidityExcTest();
0116 void recordValidityNoFinderTest();
0117 void recordValidityNoFinderExcTest();
0118 void recordValidityResolverNoFinderTest();
0119 void recordValidityResolverNoFinderExcTest();
0120 void provenanceTest();
0121 void getDataWithESGetTokenTest();
0122 void getHandleWithESGetTokenTest();
0123 void getTransientHandleWithESGetTokenTest();
0124
0125 void producerConflictTest();
0126 void sourceConflictTest();
0127 void twoSourceTest();
0128 void sourceProducerResolutionTest();
0129 void preferTest();
0130
0131 void introspectionTest();
0132
0133 void iovExtensionTest();
0134 void resetProxiesTest();
0135
0136 private:
0137 edm::propagate_const<std::unique_ptr<edm::ThreadsController>> m_scheduler;
0138
0139 DummyData kGood{1};
0140 DummyData kBad{0};
0141 };
0142
0143
0144 CPPUNIT_TEST_SUITE_REGISTRATION(testEventsetup);
0145
0146 namespace {
0147 edm::ActivityRegistry activityRegistry;
0148 }
0149
0150 void testEventsetup::constructTest() {
0151 eventsetup::EventSetupProvider provider(&activityRegistry);
0152 const Timestamp time(1);
0153 const IOVSyncValue timestamp(time);
0154 bool newEventSetupImpl = false;
0155 auto eventSetupImpl = provider.eventSetupForInstance(timestamp, newEventSetupImpl);
0156 CPPUNIT_ASSERT(non_null(eventSetupImpl.get()));
0157 edm::ESParentContext pc;
0158 const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, pc);
0159 }
0160
0161
0162
0163
0164
0165
0166 void testEventsetup::getTest() {
0167 EventSetupImpl eventSetupImpl;
0168 std::vector<eventsetup::EventSetupRecordKey> keys;
0169 EventSetupRecordKey key = EventSetupRecordKey::makeKey<DummyRecord>();
0170 keys.push_back(key);
0171 eventSetupImpl.setKeyIters(keys.begin(), keys.end());
0172 EventSetupRecordImpl dummyRecordImpl{key, &activityRegistry};
0173 eventSetupImpl.addRecordImpl(dummyRecordImpl);
0174 edm::ESParentContext pc;
0175 const edm::EventSetup eventSetup(eventSetupImpl, 0, nullptr, pc);
0176 const DummyRecord& gottenRecord = eventSetup.get<DummyRecord>();
0177 CPPUNIT_ASSERT(&dummyRecordImpl == gottenRecord.impl_);
0178 }
0179
0180 void testEventsetup::tryToGetTest() {
0181 EventSetupImpl eventSetupImpl;
0182 std::vector<eventsetup::EventSetupRecordKey> keys;
0183 EventSetupRecordKey key = EventSetupRecordKey::makeKey<DummyRecord>();
0184 keys.push_back(key);
0185 eventSetupImpl.setKeyIters(keys.begin(), keys.end());
0186 EventSetupRecordImpl dummyRecordImpl{key, &activityRegistry};
0187 eventSetupImpl.addRecordImpl(dummyRecordImpl);
0188 edm::ESParentContext pc;
0189 const edm::EventSetup eventSetup(eventSetupImpl, 0, nullptr, pc);
0190 std::optional<DummyRecord> gottenRecord = eventSetup.tryToGet<DummyRecord>();
0191 CPPUNIT_ASSERT(gottenRecord);
0192 CPPUNIT_ASSERT(&dummyRecordImpl == gottenRecord.value().impl_);
0193 }
0194
0195 void testEventsetup::getExcTest() {
0196 SynchronousEventSetupsController controller;
0197 edm::ParameterSet pset = createDummyPset();
0198 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0199 controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1), edm::Timestamp(1)));
0200 edm::ESParentContext pc;
0201 const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, pc);
0202 eventSetup.get<DummyRecord>();
0203 }
0204
0205 class DummyFinder : public EventSetupRecordIntervalFinder {
0206 public:
0207 DummyFinder() : EventSetupRecordIntervalFinder(), interval_() { this->findingRecord<DummyRecord>(); }
0208
0209 void setInterval(const ValidityInterval& iInterval) { interval_ = iInterval; }
0210
0211 protected:
0212 virtual void setIntervalFor(const eventsetup::EventSetupRecordKey&,
0213 const IOVSyncValue& iTime,
0214 ValidityInterval& iInterval) {
0215 if (interval_.validFor(iTime)) {
0216 iInterval = interval_;
0217 } else {
0218 iInterval = ValidityInterval();
0219 }
0220 }
0221
0222 private:
0223 ValidityInterval interval_;
0224 };
0225
0226 void testEventsetup::recordValidityTest() {
0227 SynchronousEventSetupsController controller;
0228 edm::ParameterSet pset = createDummyPset();
0229 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0230
0231 std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0232
0233
0234
0235
0236 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
0237
0238 Timestamp time_1(1);
0239 controller.eventSetupForInstance(IOVSyncValue(time_1));
0240 edm::ESParentContext pc;
0241 const edm::EventSetup eventSetup1(provider.eventSetupImpl(), 0, nullptr, pc);
0242 CPPUNIT_ASSERT(!eventSetup1.tryToGet<DummyRecord>().has_value());
0243
0244 const Timestamp time_2(2);
0245 dummyFinder->setInterval(ValidityInterval(IOVSyncValue(time_2), IOVSyncValue(Timestamp(3))));
0246 {
0247 controller.eventSetupForInstance(IOVSyncValue(time_2));
0248 edm::ESParentContext pc;
0249 const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, pc);
0250 eventSetup.get<DummyRecord>();
0251 CPPUNIT_ASSERT(eventSetup.tryToGet<DummyRecord>().has_value());
0252 }
0253
0254 {
0255 controller.eventSetupForInstance(IOVSyncValue(Timestamp(3)));
0256 edm::ESParentContext pc;
0257 const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, pc);
0258 eventSetup.get<DummyRecord>();
0259 CPPUNIT_ASSERT(eventSetup.tryToGet<DummyRecord>().has_value());
0260 }
0261 {
0262 controller.eventSetupForInstance(IOVSyncValue(Timestamp(4)));
0263 edm::ESParentContext pc;
0264 const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, pc);
0265 CPPUNIT_ASSERT(!eventSetup.tryToGet<DummyRecord>().has_value());
0266 }
0267 }
0268
0269 void testEventsetup::recordValidityExcTest() {
0270 SynchronousEventSetupsController controller;
0271 edm::ParameterSet pset = createDummyPset();
0272 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0273
0274 std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0275
0276
0277
0278
0279 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
0280
0281 Timestamp time_1(1);
0282 controller.eventSetupForInstance(IOVSyncValue(time_1));
0283 edm::ESParentContext pc;
0284 const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, pc);
0285 eventSetup.get<DummyRecord>();
0286 }
0287
0288 void testEventsetup::recordValidityNoFinderTest() {
0289 SynchronousEventSetupsController controller;
0290 edm::ParameterSet pset = createDummyPset();
0291 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0292
0293 Timestamp time_1(1);
0294 controller.eventSetupForInstance(IOVSyncValue(time_1));
0295 edm::ESParentContext pc;
0296 const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, pc);
0297 CPPUNIT_ASSERT(!eventSetup.tryToGet<DummyRecord>().has_value());
0298 }
0299
0300 void testEventsetup::recordValidityNoFinderExcTest() {
0301 SynchronousEventSetupsController controller;
0302 edm::ParameterSet pset = createDummyPset();
0303 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0304
0305 Timestamp time_1(1);
0306 controller.eventSetupForInstance(IOVSyncValue(time_1));
0307 edm::ESParentContext pc;
0308 const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, pc);
0309 eventSetup.get<DummyRecord>();
0310 }
0311
0312
0313 static eventsetup::RecordDependencyRegister<DummyRecord> s_factory;
0314
0315 void testEventsetup::recordValidityResolverNoFinderTest() {
0316 SynchronousEventSetupsController controller;
0317 edm::ParameterSet pset = createDummyPset();
0318 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0319
0320 provider.add(std::make_shared<DummyESProductResolverProvider>());
0321
0322 Timestamp time_1(1);
0323 controller.eventSetupForInstance(IOVSyncValue(time_1));
0324 edm::ESParentContext pc;
0325 const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, pc);
0326 CPPUNIT_ASSERT(!eventSetup.tryToGet<DummyRecord>().has_value());
0327 }
0328
0329 void testEventsetup::recordValidityResolverNoFinderExcTest() {
0330 SynchronousEventSetupsController controller;
0331 edm::ParameterSet pset = createDummyPset();
0332 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0333
0334 provider.add(std::make_shared<DummyESProductResolverProvider>());
0335
0336 Timestamp time_1(1);
0337 controller.eventSetupForInstance(IOVSyncValue(time_1));
0338 edm::ESParentContext pc;
0339 const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, pc);
0340 eventSetup.get<DummyRecord>();
0341 }
0342
0343 void testEventsetup::producerConflictTest() {
0344 SynchronousEventSetupsController controller;
0345 edm::ParameterSet pset = createDummyPset();
0346 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0347
0348 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 0, false);
0349
0350 {
0351 auto dummyProv = std::make_shared<DummyESProductResolverProvider>();
0352 dummyProv->setDescription(description);
0353 provider.add(dummyProv);
0354 }
0355 {
0356 auto dummyProv = std::make_shared<DummyESProductResolverProvider>();
0357 dummyProv->setDescription(description);
0358 provider.add(dummyProv);
0359 }
0360
0361 controller.eventSetupForInstance(IOVSyncValue::invalidIOVSyncValue());
0362 }
0363
0364 void testEventsetup::sourceConflictTest() {
0365 SynchronousEventSetupsController controller;
0366 edm::ParameterSet pset = createDummyPset();
0367 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0368
0369 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 0, true);
0370
0371 {
0372 auto dummyProv = std::make_shared<DummyESProductResolverProvider>();
0373 dummyProv->setDescription(description);
0374 provider.add(dummyProv);
0375 }
0376 {
0377 auto dummyProv = std::make_shared<DummyESProductResolverProvider>();
0378 dummyProv->setDescription(description);
0379 provider.add(dummyProv);
0380 }
0381
0382 controller.eventSetupForInstance(IOVSyncValue::invalidIOVSyncValue());
0383 }
0384
0385 void testEventsetup::twoSourceTest() {
0386 SynchronousEventSetupsController controller;
0387 edm::ParameterSet pset = createDummyPset();
0388 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0389
0390 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 0, true);
0391 {
0392 auto dummyProv = std::make_shared<DummyESProductResolverProvider>();
0393 dummyProv->setDescription(description);
0394 provider.add(dummyProv);
0395 }
0396 {
0397 auto dummyProv = std::make_shared<edm::DummyEventSetupRecordRetriever>();
0398 std::shared_ptr<eventsetup::ESProductResolverProvider> providerPtr(dummyProv);
0399 std::shared_ptr<edm::EventSetupRecordIntervalFinder> finderPtr(dummyProv);
0400 edm::eventsetup::ComponentDescription description2("DummyEventSetupRecordRetriever", "", 0, true);
0401 dummyProv->setDescription(description2);
0402 provider.add(providerPtr);
0403 provider.add(finderPtr);
0404 }
0405
0406 edm::ESParentContext pc;
0407 controller.eventSetupForInstance(IOVSyncValue::invalidIOVSyncValue());
0408 const edm::EventSetup eventSetup3(provider.eventSetupImpl(), 0, nullptr, pc);
0409 CPPUNIT_ASSERT(!eventSetup3.tryToGet<DummyRecord>().has_value());
0410 CPPUNIT_ASSERT(!eventSetup3.tryToGet<DummyEventSetupRecord>().has_value());
0411 controller.eventSetupForInstance(IOVSyncValue(Timestamp(3)));
0412 const edm::EventSetup eventSetup4(provider.eventSetupImpl(), 0, nullptr, pc);
0413 CPPUNIT_ASSERT(!eventSetup4.tryToGet<DummyRecord>().has_value());
0414 CPPUNIT_ASSERT(eventSetup4.tryToGet<DummyEventSetupRecord>().has_value());
0415 eventSetup4.get<DummyEventSetupRecord>();
0416 }
0417
0418 namespace {
0419 struct DummyDataConsumer : public EDConsumerBase {
0420 explicit DummyDataConsumer(ESInputTag const& iTag) : m_token{esConsumes(iTag)} {}
0421
0422 void prefetch(edm::EventSetupImpl const& iImpl) const {
0423 auto const& recs = this->esGetTokenRecordIndicesVector(edm::Transition::Event);
0424 auto const& proxies = this->esGetTokenIndicesVector(edm::Transition::Event);
0425 for (size_t i = 0; i != proxies.size(); ++i) {
0426 auto rec = iImpl.findImpl(recs[i]);
0427 if (rec) {
0428 oneapi::tbb::task_group group;
0429 edm::FinalWaitingTask waitTask{group};
0430 rec->prefetchAsync(
0431 WaitingTaskHolder(group, &waitTask), proxies[i], &iImpl, edm::ServiceToken{}, edm::ESParentContext{});
0432 waitTask.wait();
0433 }
0434 }
0435 }
0436
0437 ESGetToken<edm::eventsetup::test::DummyData, edm::DefaultRecord> m_token;
0438 ESGetToken<edm::eventsetup::test::DummyData, edm::DefaultRecord> m_tokenUninitialized;
0439 };
0440 }
0441
0442 void testEventsetup::provenanceTest() {
0443 SynchronousEventSetupsController controller;
0444 edm::ParameterSet pset = createDummyPset();
0445 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0446
0447 std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0448 dummyFinder->setInterval(ValidityInterval(IOVSyncValue(Timestamp(2)), IOVSyncValue(Timestamp(3))));
0449 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
0450
0451 try {
0452 {
0453 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 0, true);
0454 edm::ParameterSet ps;
0455 ps.addParameter<std::string>("name", "test11");
0456 ps.registerIt();
0457 description.pid_ = ps.id();
0458 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
0459 dummyProv->setDescription(description);
0460 provider.add(dummyProv);
0461 }
0462 {
0463 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "testLabel", 1, false);
0464 edm::ParameterSet ps;
0465 ps.addParameter<std::string>("name", "test22");
0466 ps.registerIt();
0467 description.pid_ = ps.id();
0468 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kGood);
0469 dummyProv->setDescription(description);
0470 provider.add(dummyProv);
0471 }
0472 controller.eventSetupForInstance(IOVSyncValue(Timestamp(2)));
0473 DummyDataConsumer consumer{edm::ESInputTag("", "")};
0474 consumer.updateLookup(provider.recordsToResolverIndices());
0475 consumer.prefetch(provider.eventSetupImpl());
0476 edm::ESParentContext pc;
0477 const edm::EventSetup eventSetup(provider.eventSetupImpl(),
0478 static_cast<unsigned int>(edm::Transition::Event),
0479 consumer.esGetTokenIndices(edm::Transition::Event),
0480 pc);
0481 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
0482
0483 CPPUNIT_ASSERT(kGood.value_ == data->value_);
0484 const edm::eventsetup::ComponentDescription* desc = data.description();
0485 CPPUNIT_ASSERT(desc->label_ == "testLabel");
0486 } catch (const cms::Exception& iException) {
0487 std::cout << "caught " << iException.explainSelf() << std::endl;
0488 throw;
0489 }
0490 }
0491
0492 namespace {
0493
0494 class [[maybe_unused]] EDConsumesCollectorConsumer : public edm::EDConsumerBase {
0495 EDConsumesCollectorConsumer() {
0496 using edm::eventsetup::test::DummyData;
0497 {
0498 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token1(
0499 consumesCollector().esConsumes<DummyData, edm::DefaultRecord>());
0500 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token2(
0501 consumesCollector().esConsumes<DummyData, edm::DefaultRecord>(edm::ESInputTag("Blah")));
0502 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token3(
0503 consumesCollector().esConsumes<DummyData, edm::DefaultRecord, edm::Transition::BeginRun>());
0504 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token4(
0505 consumesCollector().esConsumes<DummyData, edm::DefaultRecord, edm::Transition::BeginRun>(
0506 edm::ESInputTag("Blah")));
0507 }
0508 {
0509 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token1(consumesCollector().esConsumes());
0510 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token2(
0511 consumesCollector().esConsumes(edm::ESInputTag("Blah")));
0512 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token3(
0513 consumesCollector().esConsumes<edm::Transition::BeginRun>());
0514 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token4(
0515 consumesCollector().esConsumes<edm::Transition::BeginRun>(edm::ESInputTag("Blah")));
0516 }
0517 {
0518 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token1;
0519 token1 = consumesCollector().esConsumes();
0520 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token2;
0521 token2 = consumesCollector().esConsumes(edm::ESInputTag("Blah"));
0522 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token3;
0523 token3 = consumesCollector().esConsumes<edm::Transition::BeginRun>();
0524 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token4;
0525 token4 = consumesCollector().esConsumes<edm::Transition::BeginRun>(edm::ESInputTag("Blah"));
0526 }
0527
0528 }
0529 };
0530
0531 class ConsumesProducer : public ESProducer {
0532 public:
0533 ConsumesProducer() : token_{setWhatProduced(this, "consumes").consumes<edm::eventsetup::test::DummyData>()} {}
0534 std::unique_ptr<edm::eventsetup::test::DummyData> produce(const DummyRecord& iRecord) {
0535 auto const& data = iRecord.get(token_);
0536 return std::make_unique<edm::eventsetup::test::DummyData>(data);
0537 }
0538
0539 private:
0540 edm::ESGetToken<edm::eventsetup::test::DummyData, DummyRecord> token_;
0541 };
0542
0543 class ConsumesFromProducer : public ESProducer {
0544 public:
0545 ConsumesFromProducer()
0546 : token_{setWhatProduced(this, "consumesFrom").consumesFrom<edm::eventsetup::test::DummyData, DummyRecord>()} {}
0547 std::unique_ptr<edm::eventsetup::test::DummyData> produce(const DummyRecord& iRecord) {
0548 auto const& data = iRecord.get(token_);
0549 return std::make_unique<edm::eventsetup::test::DummyData>(data);
0550 }
0551
0552 private:
0553 edm::ESGetToken<edm::eventsetup::test::DummyData, DummyRecord> token_;
0554 };
0555
0556
0557 class [[maybe_unused]] ESConsumesCollectorProducer : public ESProducer {
0558 public:
0559 struct Helper {
0560 Helper(ESConsumesCollector iCollector) {
0561 using edm::eventsetup::test::DummyData;
0562 {
0563 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token1(
0564 iCollector.consumesFrom<DummyData, edm::DefaultRecord>());
0565 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token2(
0566 iCollector.consumesFrom<DummyData, edm::DefaultRecord>(edm::ESInputTag("Blah")));
0567 }
0568 {
0569 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token1(iCollector.consumes());
0570 [[maybe_unused]] edm::ESGetToken<DummyData, edm::DefaultRecord> token2(
0571 iCollector.consumes(edm::ESInputTag("Blah")));
0572 }
0573 }
0574 };
0575
0576 ESConsumesCollectorProducer() : helper_(setWhatProduced(this, "consumesCollector")) {}
0577
0578 std::unique_ptr<edm::eventsetup::test::DummyData> produce(const DummyRecord& iRecord) {
0579 return std::unique_ptr<edm::eventsetup::test::DummyData>();
0580 }
0581
0582 private:
0583 Helper helper_;
0584 };
0585
0586 class SetMayConsumeProducer : public ESProducer {
0587 public:
0588 SetMayConsumeProducer(bool iSucceed) : succeed_(iSucceed) {
0589 setWhatProduced(this, label(iSucceed))
0590 .setMayConsume(
0591 token_,
0592 [iSucceed](auto& get, edm::ESTransientHandle<edm::eventsetup::test::DummyData> const& handle) {
0593 if (iSucceed) {
0594 return get("", "");
0595 }
0596 return get.nothing();
0597 },
0598 edm::ESProductTag<edm::eventsetup::test::DummyData, DummyRecord>("", ""));
0599 }
0600 std::unique_ptr<edm::eventsetup::test::DummyData> produce(const DummyRecord& iRecord) {
0601 auto const& data = iRecord.getHandle(token_);
0602 CPPUNIT_ASSERT(data.isValid() == succeed_);
0603 if (data.isValid()) {
0604 return std::make_unique<edm::eventsetup::test::DummyData>(*data);
0605 }
0606 return std::unique_ptr<edm::eventsetup::test::DummyData>();
0607 }
0608
0609 private:
0610 static const char* label(bool iSucceed) noexcept {
0611 if (iSucceed) {
0612 return "setMayConsumeSucceed";
0613 }
0614 return "setMayConsumeFail";
0615 }
0616
0617 edm::ESGetToken<edm::eventsetup::test::DummyData, DummyRecord> token_;
0618 bool succeed_;
0619 };
0620
0621 }
0622
0623 void testEventsetup::getDataWithESGetTokenTest() {
0624 SynchronousEventSetupsController controller;
0625 edm::ParameterSet pset = createDummyPset();
0626 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0627
0628 std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0629 dummyFinder->setInterval(ValidityInterval(IOVSyncValue(Timestamp(2)), IOVSyncValue(Timestamp(3))));
0630 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
0631
0632 try {
0633 {
0634 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "testOne", 0, true);
0635 edm::ParameterSet ps;
0636 ps.addParameter<std::string>("name", "test11");
0637 ps.registerIt();
0638 description.pid_ = ps.id();
0639 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
0640 dummyProv->setDescription(description);
0641 provider.add(dummyProv);
0642 }
0643 {
0644 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "testTwo", 1, false);
0645 edm::ParameterSet ps;
0646 ps.addParameter<std::string>("name", "test22");
0647 ps.addParameter<std::string>("appendToDataLabel", "blah");
0648 ps.registerIt();
0649 description.pid_ = ps.id();
0650 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kGood);
0651 dummyProv->setDescription(description);
0652 dummyProv->setAppendToDataLabel(ps);
0653 provider.add(dummyProv);
0654 }
0655 {
0656 edm::eventsetup::ComponentDescription description("ConsumesProducer", "consumes", 2, false);
0657 edm::ParameterSet ps;
0658 ps.addParameter<std::string>("name", "consumes");
0659 ps.registerIt();
0660 description.pid_ = ps.id();
0661 auto dummyProv = std::make_shared<ConsumesProducer>();
0662 dummyProv->setDescription(description);
0663 dummyProv->setAppendToDataLabel(ps);
0664 provider.add(dummyProv);
0665 }
0666 {
0667 edm::eventsetup::ComponentDescription description("ConsumesFromProducer", "consumesFrom", 3, false);
0668 edm::ParameterSet ps;
0669 ps.addParameter<std::string>("name", "consumesFrom");
0670 ps.registerIt();
0671 description.pid_ = ps.id();
0672 auto dummyProv = std::make_shared<ConsumesFromProducer>();
0673 dummyProv->setDescription(description);
0674 dummyProv->setAppendToDataLabel(ps);
0675 provider.add(dummyProv);
0676 }
0677 {
0678 edm::eventsetup::ComponentDescription description("SetMayConsumeProducer", "setMayConsumeSuceed", 4, false);
0679 edm::ParameterSet ps;
0680 ps.addParameter<std::string>("name", "setMayConsumeSuceed");
0681 ps.registerIt();
0682 description.pid_ = ps.id();
0683 auto dummyProv = std::make_shared<SetMayConsumeProducer>(true);
0684 dummyProv->setDescription(description);
0685 dummyProv->setAppendToDataLabel(ps);
0686 provider.add(dummyProv);
0687 }
0688 {
0689 edm::eventsetup::ComponentDescription description("SetMayConsumeProducer", "setMayConsumeFail", 5, false);
0690 edm::ParameterSet ps;
0691 ps.addParameter<std::string>("name", "setMayConsumeFail");
0692 ps.registerIt();
0693 description.pid_ = ps.id();
0694 auto dummyProv = std::make_shared<SetMayConsumeProducer>(false);
0695 dummyProv->setDescription(description);
0696 dummyProv->setAppendToDataLabel(ps);
0697 provider.add(dummyProv);
0698 }
0699
0700 edm::ESParentContext pc;
0701 controller.eventSetupForInstance(IOVSyncValue(Timestamp(2)));
0702 {
0703 DummyDataConsumer consumer{edm::ESInputTag("", "blah")};
0704 consumer.updateLookup(provider.recordsToResolverIndices());
0705 consumer.prefetch(provider.eventSetupImpl());
0706 EventSetup eventSetup{provider.eventSetupImpl(),
0707 static_cast<unsigned int>(edm::Transition::Event),
0708 consumer.esGetTokenIndices(edm::Transition::Event),
0709 pc};
0710 auto const& data = eventSetup.getData(consumer.m_token);
0711 CPPUNIT_ASSERT(kGood.value_ == data.value_);
0712 bool uninitializedTokenThrewException = false;
0713 try {
0714 (void)eventSetup.getData(consumer.m_tokenUninitialized);
0715 } catch (cms::Exception& ex) {
0716 uninitializedTokenThrewException = true;
0717 CPPUNIT_ASSERT(ex.category() == "InvalidESGetToken");
0718 }
0719 CPPUNIT_ASSERT(uninitializedTokenThrewException);
0720 }
0721
0722 {
0723 DummyDataConsumer consumer{edm::ESInputTag("", "")};
0724 consumer.updateLookup(provider.recordsToResolverIndices());
0725 consumer.prefetch(provider.eventSetupImpl());
0726 EventSetup eventSetup{provider.eventSetupImpl(),
0727 static_cast<unsigned int>(edm::Transition::Event),
0728 consumer.esGetTokenIndices(edm::Transition::Event),
0729 pc};
0730 const DummyData& data = eventSetup.getData(consumer.m_token);
0731 CPPUNIT_ASSERT(kBad.value_ == data.value_);
0732 }
0733
0734 {
0735 DummyDataConsumer consumer{edm::ESInputTag("testTwo", "blah")};
0736 consumer.updateLookup(provider.recordsToResolverIndices());
0737 consumer.prefetch(provider.eventSetupImpl());
0738 EventSetup eventSetup{provider.eventSetupImpl(),
0739 static_cast<unsigned int>(edm::Transition::Event),
0740 consumer.esGetTokenIndices(edm::Transition::Event),
0741 pc};
0742 auto const& data = eventSetup.getData(consumer.m_token);
0743 CPPUNIT_ASSERT(kGood.value_ == data.value_);
0744 }
0745
0746 {
0747 DummyDataConsumer consumer{edm::ESInputTag("DoesNotExist", "blah")};
0748 consumer.updateLookup(provider.recordsToResolverIndices());
0749 consumer.prefetch(provider.eventSetupImpl());
0750 EventSetup eventSetup{provider.eventSetupImpl(),
0751 static_cast<unsigned int>(edm::Transition::Event),
0752 consumer.esGetTokenIndices(edm::Transition::Event),
0753 pc};
0754 CPPUNIT_ASSERT_THROW(eventSetup.getData(consumer.m_token), cms::Exception);
0755 }
0756
0757 {
0758 DummyDataConsumer consumer{edm::ESInputTag("", "consumes")};
0759 consumer.updateLookup(provider.recordsToResolverIndices());
0760 consumer.prefetch(provider.eventSetupImpl());
0761 EventSetup eventSetup{provider.eventSetupImpl(),
0762 static_cast<unsigned int>(edm::Transition::Event),
0763 consumer.esGetTokenIndices(edm::Transition::Event),
0764 pc};
0765 const DummyData& data = eventSetup.getData(consumer.m_token);
0766 CPPUNIT_ASSERT(kBad.value_ == data.value_);
0767 }
0768 {
0769 DummyDataConsumer consumer{edm::ESInputTag("", "consumesFrom")};
0770 consumer.updateLookup(provider.recordsToResolverIndices());
0771 consumer.prefetch(provider.eventSetupImpl());
0772 EventSetup eventSetup{provider.eventSetupImpl(),
0773 static_cast<unsigned int>(edm::Transition::Event),
0774 consumer.esGetTokenIndices(edm::Transition::Event),
0775 pc};
0776 const DummyData& data = eventSetup.getData(consumer.m_token);
0777 CPPUNIT_ASSERT(kBad.value_ == data.value_);
0778 }
0779 {
0780 DummyDataConsumer consumer{edm::ESInputTag("", "setMayConsumeFail")};
0781 consumer.updateLookup(provider.recordsToResolverIndices());
0782 consumer.prefetch(provider.eventSetupImpl());
0783 EventSetup eventSetup{provider.eventSetupImpl(),
0784 static_cast<unsigned int>(edm::Transition::Event),
0785 consumer.esGetTokenIndices(edm::Transition::Event),
0786 pc};
0787 CPPUNIT_ASSERT_THROW(eventSetup.getData(consumer.m_token), edm::eventsetup::MakeDataException);
0788 }
0789 {
0790 DummyDataConsumer consumer{edm::ESInputTag("", "setMayConsumeSucceed")};
0791 consumer.updateLookup(provider.recordsToResolverIndices());
0792 consumer.prefetch(provider.eventSetupImpl());
0793 EventSetup eventSetup{provider.eventSetupImpl(),
0794 static_cast<unsigned int>(edm::Transition::Event),
0795 consumer.esGetTokenIndices(edm::Transition::Event),
0796 pc};
0797 const DummyData& data = eventSetup.getData(consumer.m_token);
0798 CPPUNIT_ASSERT(kBad.value_ == data.value_);
0799 }
0800
0801 } catch (const cms::Exception& iException) {
0802 std::cout << "caught " << iException.explainSelf() << std::endl;
0803 throw;
0804 }
0805 }
0806
0807 void testEventsetup::getHandleWithESGetTokenTest() {
0808 SynchronousEventSetupsController controller;
0809 edm::ParameterSet pset = createDummyPset();
0810 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0811
0812 std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0813 dummyFinder->setInterval(ValidityInterval(IOVSyncValue(Timestamp(2)), IOVSyncValue(Timestamp(3))));
0814 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
0815
0816 edm::ESParentContext pc;
0817 try {
0818 {
0819 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "testOne", 0, true);
0820 edm::ParameterSet ps;
0821 ps.addParameter<std::string>("name", "test11");
0822 ps.registerIt();
0823 description.pid_ = ps.id();
0824 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
0825 dummyProv->setDescription(description);
0826 provider.add(dummyProv);
0827 }
0828 {
0829 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "testTwo", 1, false);
0830 edm::ParameterSet ps;
0831 ps.addParameter<std::string>("name", "test22");
0832 ps.addParameter<std::string>("appendToDataLabel", "blah");
0833 ps.registerIt();
0834 description.pid_ = ps.id();
0835 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kGood);
0836 dummyProv->setDescription(description);
0837 dummyProv->setAppendToDataLabel(ps);
0838 provider.add(dummyProv);
0839 }
0840 controller.eventSetupForInstance(IOVSyncValue(Timestamp(2)));
0841 {
0842 DummyDataConsumer consumer{edm::ESInputTag("", "blah")};
0843 consumer.updateLookup(provider.recordsToResolverIndices());
0844 consumer.prefetch(provider.eventSetupImpl());
0845
0846 EventSetup eventSetup{provider.eventSetupImpl(),
0847 static_cast<unsigned int>(edm::Transition::Event),
0848 consumer.esGetTokenIndices(edm::Transition::Event),
0849 pc};
0850 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
0851 CPPUNIT_ASSERT(kGood.value_ == data->value_);
0852 const edm::eventsetup::ComponentDescription* desc = data.description();
0853 CPPUNIT_ASSERT(desc->label_ == "testTwo");
0854 }
0855
0856 {
0857 DummyDataConsumer consumer{edm::ESInputTag("", "")};
0858 consumer.updateLookup(provider.recordsToResolverIndices());
0859 consumer.prefetch(provider.eventSetupImpl());
0860 EventSetup eventSetup{provider.eventSetupImpl(),
0861 static_cast<unsigned int>(edm::Transition::Event),
0862 consumer.esGetTokenIndices(edm::Transition::Event),
0863 pc};
0864 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
0865 CPPUNIT_ASSERT(kBad.value_ == data->value_);
0866 const edm::eventsetup::ComponentDescription* desc = data.description();
0867 CPPUNIT_ASSERT(desc->label_ == "testOne");
0868 }
0869
0870 {
0871 DummyDataConsumer consumer{edm::ESInputTag("testTwo", "blah")};
0872 consumer.updateLookup(provider.recordsToResolverIndices());
0873 consumer.prefetch(provider.eventSetupImpl());
0874 EventSetup eventSetup{provider.eventSetupImpl(),
0875 static_cast<unsigned int>(edm::Transition::Event),
0876 consumer.esGetTokenIndices(edm::Transition::Event),
0877 pc};
0878 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
0879 CPPUNIT_ASSERT(kGood.value_ == data->value_);
0880 const edm::eventsetup::ComponentDescription* desc = data.description();
0881 CPPUNIT_ASSERT(desc->label_ == "testTwo");
0882 }
0883
0884 {
0885 DummyDataConsumer consumer{edm::ESInputTag("DoesNotExist", "blah")};
0886 consumer.updateLookup(provider.recordsToResolverIndices());
0887 consumer.prefetch(provider.eventSetupImpl());
0888 EventSetup eventSetup{provider.eventSetupImpl(),
0889 static_cast<unsigned int>(edm::Transition::Event),
0890 consumer.esGetTokenIndices(edm::Transition::Event),
0891 pc};
0892 CPPUNIT_ASSERT(not eventSetup.getHandle(consumer.m_token));
0893 CPPUNIT_ASSERT_THROW(*eventSetup.getHandle(consumer.m_token), cms::Exception);
0894 }
0895
0896 } catch (const cms::Exception& iException) {
0897 std::cout << "caught " << iException.explainSelf() << std::endl;
0898 throw;
0899 }
0900 }
0901
0902 void testEventsetup::getTransientHandleWithESGetTokenTest() {
0903 using edm::eventsetup::test::DummyData;
0904 using edm::eventsetup::test::DummyESProductResolverProvider;
0905 DummyData kGood{1};
0906 DummyData kBad{0};
0907
0908 SynchronousEventSetupsController controller;
0909 edm::ParameterSet pset = createDummyPset();
0910 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0911
0912 edm::ESParentContext pc;
0913 try {
0914 {
0915 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "testOne", 0, true);
0916 edm::ParameterSet ps;
0917 ps.addParameter<std::string>("name", "test11");
0918 ps.registerIt();
0919 description.pid_ = ps.id();
0920 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
0921 dummyProv->setDescription(description);
0922 provider.add(dummyProv);
0923 }
0924 {
0925 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "testTwo", 1, false);
0926 edm::ParameterSet ps;
0927 ps.addParameter<std::string>("name", "test22");
0928 ps.addParameter<std::string>("appendToDataLabel", "blah");
0929 ps.registerIt();
0930 description.pid_ = ps.id();
0931 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kGood);
0932 dummyProv->setDescription(description);
0933 dummyProv->setAppendToDataLabel(ps);
0934 provider.add(dummyProv);
0935 }
0936 std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0937 dummyFinder->setInterval(
0938 edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 1)), edm::IOVSyncValue(edm::EventID(1, 1, 3))));
0939 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
0940
0941 controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1)));
0942 {
0943 DummyDataConsumer consumer{edm::ESInputTag("", "blah")};
0944 consumer.updateLookup(provider.recordsToResolverIndices());
0945 consumer.prefetch(provider.eventSetupImpl());
0946 const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0947 static_cast<unsigned int>(edm::Transition::Event),
0948 consumer.esGetTokenIndices(edm::Transition::Event),
0949 pc};
0950 edm::ESTransientHandle<DummyData> data = eventSetup.getTransientHandle(consumer.m_token);
0951 CPPUNIT_ASSERT(kGood.value_ == data->value_);
0952 const edm::eventsetup::ComponentDescription* desc = data.description();
0953 CPPUNIT_ASSERT(desc->label_ == "testTwo");
0954 }
0955
0956 {
0957 DummyDataConsumer consumer{edm::ESInputTag("", "")};
0958 consumer.updateLookup(provider.recordsToResolverIndices());
0959 consumer.prefetch(provider.eventSetupImpl());
0960 const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0961 static_cast<unsigned int>(edm::Transition::Event),
0962 consumer.esGetTokenIndices(edm::Transition::Event),
0963 pc};
0964 edm::ESTransientHandle<DummyData> data = eventSetup.getTransientHandle(consumer.m_token);
0965 CPPUNIT_ASSERT(kBad.value_ == data->value_);
0966 const edm::eventsetup::ComponentDescription* desc = data.description();
0967 CPPUNIT_ASSERT(desc->label_ == "testOne");
0968 }
0969
0970 {
0971 DummyDataConsumer consumer{edm::ESInputTag("testTwo", "blah")};
0972 consumer.updateLookup(provider.recordsToResolverIndices());
0973 consumer.prefetch(provider.eventSetupImpl());
0974 const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0975 static_cast<unsigned int>(edm::Transition::Event),
0976 consumer.esGetTokenIndices(edm::Transition::Event),
0977 pc};
0978 edm::ESTransientHandle<DummyData> data = eventSetup.getTransientHandle(consumer.m_token);
0979 CPPUNIT_ASSERT(kGood.value_ == data->value_);
0980 const edm::eventsetup::ComponentDescription* desc = data.description();
0981 CPPUNIT_ASSERT(desc->label_ == "testTwo");
0982 }
0983
0984 {
0985 DummyDataConsumer consumer{edm::ESInputTag("DoesNotExist", "blah")};
0986 consumer.updateLookup(provider.recordsToResolverIndices());
0987 consumer.prefetch(provider.eventSetupImpl());
0988 const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0989 static_cast<unsigned int>(edm::Transition::Event),
0990 consumer.esGetTokenIndices(edm::Transition::Event),
0991 pc};
0992 edm::ESTransientHandle<DummyData> data = eventSetup.getTransientHandle(consumer.m_token);
0993 CPPUNIT_ASSERT(not data);
0994 CPPUNIT_ASSERT_THROW(*data, cms::Exception);
0995 }
0996
0997 } catch (const cms::Exception& iException) {
0998 std::cout << "caught " << iException.explainSelf() << std::endl;
0999 throw;
1000 }
1001 }
1002
1003 void testEventsetup::sourceProducerResolutionTest() {
1004 {
1005 SynchronousEventSetupsController controller;
1006 edm::ParameterSet pset = createDummyPset();
1007 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1008
1009 std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
1010 dummyFinder->setInterval(ValidityInterval(IOVSyncValue(Timestamp(2)), IOVSyncValue(Timestamp(3))));
1011 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
1012
1013 edm::ESParentContext pc;
1014 {
1015 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 0, true);
1016 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
1017 dummyProv->setDescription(description);
1018 provider.add(dummyProv);
1019 }
1020 {
1021 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 1, false);
1022 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kGood);
1023 dummyProv->setDescription(description);
1024 provider.add(dummyProv);
1025 }
1026 controller.eventSetupForInstance(IOVSyncValue(Timestamp(2)));
1027 DummyDataConsumer consumer{edm::ESInputTag("", "")};
1028 consumer.updateLookup(provider.recordsToResolverIndices());
1029 consumer.prefetch(provider.eventSetupImpl());
1030 const EventSetup eventSetup{provider.eventSetupImpl(),
1031 static_cast<unsigned int>(edm::Transition::Event),
1032 consumer.esGetTokenIndices(edm::Transition::Event),
1033 pc};
1034 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
1035 CPPUNIT_ASSERT(kGood.value_ == data->value_);
1036 }
1037
1038
1039 {
1040 SynchronousEventSetupsController controller;
1041 edm::ParameterSet pset = createDummyPset();
1042 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1043
1044 std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
1045 dummyFinder->setInterval(ValidityInterval(IOVSyncValue(Timestamp(2)), IOVSyncValue(Timestamp(3))));
1046 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
1047 {
1048 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 0, false);
1049 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kGood);
1050 dummyProv->setDescription(description);
1051 provider.add(dummyProv);
1052 }
1053 {
1054 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 1, true);
1055 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
1056 dummyProv->setDescription(description);
1057 provider.add(dummyProv);
1058 }
1059 controller.eventSetupForInstance(IOVSyncValue(Timestamp(2)));
1060 ESParentContext pc;
1061 DummyDataConsumer consumer{edm::ESInputTag("", "")};
1062 consumer.updateLookup(provider.recordsToResolverIndices());
1063 consumer.prefetch(provider.eventSetupImpl());
1064 EventSetup eventSetup{provider.eventSetupImpl(),
1065 static_cast<unsigned int>(edm::Transition::Event),
1066 consumer.esGetTokenIndices(edm::Transition::Event),
1067 pc};
1068 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
1069 CPPUNIT_ASSERT(kGood.value_ == data->value_);
1070 }
1071 }
1072
1073 void testEventsetup::preferTest() {
1074 edm::ParameterSet pset = createDummyPset();
1075
1076 std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
1077 dummyFinder->setInterval(ValidityInterval(IOVSyncValue(Timestamp(2)), IOVSyncValue(Timestamp(3))));
1078
1079 edm::ESParentContext pc;
1080 try {
1081 {
1082 SynchronousEventSetupsController controller;
1083 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1084 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
1085
1086 EventSetupProvider::PreferredProviderInfo preferInfo;
1087 EventSetupProvider::RecordToDataMap recordToData;
1088
1089 preferInfo[ComponentDescription("DummyESProductResolverProvider", "", ComponentDescription::unknownID(), false)] =
1090 recordToData;
1091 provider.setPreferredProviderInfo(preferInfo);
1092 {
1093 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "bad", 0, false);
1094 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
1095 dummyProv->setDescription(description);
1096 provider.add(dummyProv);
1097 }
1098 {
1099 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 1, false);
1100 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kGood);
1101 dummyProv->setDescription(description);
1102 provider.add(dummyProv);
1103 }
1104 controller.eventSetupForInstance(IOVSyncValue(Timestamp(2)));
1105 DummyDataConsumer consumer{edm::ESInputTag("", "")};
1106 consumer.updateLookup(provider.recordsToResolverIndices());
1107 consumer.prefetch(provider.eventSetupImpl());
1108 EventSetup eventSetup{provider.eventSetupImpl(),
1109 static_cast<unsigned int>(edm::Transition::Event),
1110 consumer.esGetTokenIndices(edm::Transition::Event),
1111 pc};
1112 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
1113 CPPUNIT_ASSERT(kGood.value_ == data->value_);
1114 }
1115
1116
1117 {
1118 SynchronousEventSetupsController controller;
1119 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1120 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
1121
1122 EventSetupProvider::PreferredProviderInfo preferInfo;
1123 EventSetupProvider::RecordToDataMap recordToData;
1124
1125 preferInfo[ComponentDescription("DummyESProductResolverProvider", "", ComponentDescription::unknownID(), false)] =
1126 recordToData;
1127 provider.setPreferredProviderInfo(preferInfo);
1128 {
1129 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 0, true);
1130 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kGood);
1131 dummyProv->setDescription(description);
1132 provider.add(dummyProv);
1133 }
1134 {
1135 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "bad", 1, true);
1136 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
1137 dummyProv->setDescription(description);
1138 provider.add(dummyProv);
1139 }
1140 controller.eventSetupForInstance(IOVSyncValue(Timestamp(2)));
1141 DummyDataConsumer consumer{edm::ESInputTag("", "")};
1142 consumer.updateLookup(provider.recordsToResolverIndices());
1143 consumer.prefetch(provider.eventSetupImpl());
1144 EventSetup eventSetup{provider.eventSetupImpl(),
1145 static_cast<unsigned int>(edm::Transition::Event),
1146 consumer.esGetTokenIndices(edm::Transition::Event),
1147 pc};
1148 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
1149 CPPUNIT_ASSERT(kGood.value_ == data->value_);
1150 }
1151
1152
1153 {
1154 SynchronousEventSetupsController controller;
1155 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1156 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
1157
1158 EventSetupProvider::PreferredProviderInfo preferInfo;
1159 EventSetupProvider::RecordToDataMap recordToData;
1160 recordToData.insert(
1161 std::make_pair(std::string("DummyRecord"), std::make_pair(std::string("DummyData"), std::string())));
1162 preferInfo[ComponentDescription("DummyESProductResolverProvider", "", ComponentDescription::unknownID(), false)] =
1163 recordToData;
1164 provider.setPreferredProviderInfo(preferInfo);
1165 {
1166 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 0, true);
1167 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kGood);
1168 dummyProv->setDescription(description);
1169 provider.add(dummyProv);
1170 }
1171 {
1172 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "bad", 1, true);
1173 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
1174 dummyProv->setDescription(description);
1175 provider.add(dummyProv);
1176 }
1177 controller.eventSetupForInstance(IOVSyncValue(Timestamp(2)));
1178 DummyDataConsumer consumer{edm::ESInputTag("", "")};
1179 consumer.updateLookup(provider.recordsToResolverIndices());
1180 consumer.prefetch(provider.eventSetupImpl());
1181 EventSetup eventSetup{provider.eventSetupImpl(),
1182 static_cast<unsigned int>(edm::Transition::Event),
1183 consumer.esGetTokenIndices(edm::Transition::Event),
1184 pc};
1185 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
1186 CPPUNIT_ASSERT(kGood.value_ == data->value_);
1187 }
1188
1189 } catch (const cms::Exception& iException) {
1190 std::cout << "caught " << iException.explainSelf() << std::endl;
1191 throw;
1192 }
1193 }
1194
1195 void testEventsetup::introspectionTest() {
1196 SynchronousEventSetupsController controller;
1197 edm::ParameterSet pset = createDummyPset();
1198 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1199
1200 std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
1201 dummyFinder->setInterval(ValidityInterval(IOVSyncValue(Timestamp(2)), IOVSyncValue(Timestamp(3))));
1202 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
1203
1204 edm::ESParentContext pc;
1205 try {
1206 {
1207 edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "", 0, true);
1208 edm::ParameterSet ps;
1209 ps.addParameter<std::string>("name", "test11");
1210 ps.registerIt();
1211 description.pid_ = ps.id();
1212 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
1213 dummyProv->setDescription(description);
1214 provider.add(dummyProv);
1215 }
1216 EventSetupRecordKey dummyRecordKey = EventSetupRecordKey::makeKey<DummyRecord>();
1217 controller.eventSetupForInstance(IOVSyncValue(Timestamp(2)));
1218 {
1219 EventSetup eventSetup{provider.eventSetupImpl(), 0, nullptr, pc};
1220
1221 CPPUNIT_ASSERT(eventSetup.recordIsProvidedByAModule(dummyRecordKey));
1222 std::vector<edm::eventsetup::EventSetupRecordKey> recordKeys;
1223 eventSetup.fillAvailableRecordKeys(recordKeys);
1224 CPPUNIT_ASSERT(1 == recordKeys.size());
1225 CPPUNIT_ASSERT(dummyRecordKey == recordKeys[0]);
1226 auto record = eventSetup.find(recordKeys[0]);
1227 CPPUNIT_ASSERT(record.has_value());
1228 }
1229
1230
1231
1232 controller.eventSetupForInstance(IOVSyncValue(Timestamp(4)));
1233 {
1234 EventSetup eventSetup{provider.eventSetupImpl(), 0, nullptr, pc};
1235
1236 CPPUNIT_ASSERT(eventSetup.recordIsProvidedByAModule(dummyRecordKey));
1237 std::vector<edm::eventsetup::EventSetupRecordKey> recordKeys;
1238 eventSetup.fillAvailableRecordKeys(recordKeys);
1239 CPPUNIT_ASSERT(0 == recordKeys.size());
1240 auto record = eventSetup.find(dummyRecordKey);
1241 CPPUNIT_ASSERT(!record.has_value());
1242
1243
1244
1245 EventSetupRecordKey dummyRecordKey1 = EventSetupRecordKey::makeKey<DummyEventSetupRecord>();
1246 auto record1 = eventSetup.find(dummyRecordKey1);
1247 CPPUNIT_ASSERT(!record1.has_value());
1248 }
1249 } catch (const cms::Exception& iException) {
1250 std::cout << "caught " << iException.explainSelf() << std::endl;
1251 throw;
1252 }
1253 }
1254
1255 void testEventsetup::iovExtensionTest() {
1256 SynchronousEventSetupsController controller;
1257 edm::ParameterSet pset = createDummyPset();
1258 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1259
1260 std::shared_ptr<DummyFinder> finder = std::make_shared<DummyFinder>();
1261 finder->setInterval(ValidityInterval(IOVSyncValue(Timestamp(2)), IOVSyncValue(Timestamp(3))));
1262 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(finder));
1263
1264 edm::ESParentContext pc;
1265 {
1266 controller.eventSetupForInstance(IOVSyncValue{Timestamp(2)});
1267 EventSetup eventSetup{provider.eventSetupImpl(), 0, nullptr, pc};
1268 CPPUNIT_ASSERT(2 == eventSetup.get<DummyRecord>().cacheIdentifier());
1269 }
1270 {
1271 controller.eventSetupForInstance(IOVSyncValue{Timestamp(3)});
1272 EventSetup eventSetup{provider.eventSetupImpl(), 0, nullptr, pc};
1273 eventSetup.get<DummyRecord>();
1274 CPPUNIT_ASSERT(2 == eventSetup.get<DummyRecord>().cacheIdentifier());
1275 }
1276
1277 finder->setInterval(ValidityInterval(IOVSyncValue{Timestamp{2}}, IOVSyncValue{Timestamp{4}}));
1278 {
1279 controller.eventSetupForInstance(IOVSyncValue{Timestamp(4)});
1280 EventSetup eventSetup{provider.eventSetupImpl(), 0, nullptr, pc};
1281 CPPUNIT_ASSERT(2 == eventSetup.get<DummyRecord>().cacheIdentifier());
1282 }
1283
1284
1285 finder->setInterval(ValidityInterval(IOVSyncValue{Timestamp{5}}, IOVSyncValue{Timestamp{6}}));
1286 {
1287 controller.eventSetupForInstance(IOVSyncValue{Timestamp(5)});
1288 EventSetup eventSetup{provider.eventSetupImpl(), 0, nullptr, pc};
1289 CPPUNIT_ASSERT(3 == eventSetup.get<DummyRecord>().cacheIdentifier());
1290 }
1291 }
1292
1293 void testEventsetup::resetProxiesTest() {
1294 SynchronousEventSetupsController controller;
1295 edm::ParameterSet pset = createDummyPset();
1296 EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1297
1298 std::shared_ptr<DummyFinder> finder = std::make_shared<DummyFinder>();
1299 finder->setInterval(ValidityInterval(IOVSyncValue(Timestamp(2)), IOVSyncValue(Timestamp(3))));
1300 provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(finder));
1301
1302 ComponentDescription description("DummyESProductResolverProvider", "", 0, true);
1303 ParameterSet ps;
1304 ps.addParameter<std::string>("name", "test11");
1305 ps.registerIt();
1306 description.pid_ = ps.id();
1307 DummyData kOne{1};
1308 auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kOne);
1309 dummyProv->setDescription(description);
1310 provider.add(dummyProv);
1311
1312 edm::ESParentContext pc;
1313 {
1314 controller.eventSetupForInstance(IOVSyncValue{Timestamp(2)});
1315 DummyDataConsumer consumer{edm::ESInputTag("", "")};
1316 consumer.updateLookup(provider.recordsToResolverIndices());
1317 consumer.prefetch(provider.eventSetupImpl());
1318 EventSetup eventSetup{provider.eventSetupImpl(),
1319 static_cast<unsigned int>(edm::Transition::Event),
1320 consumer.esGetTokenIndices(edm::Transition::Event),
1321 pc};
1322 CPPUNIT_ASSERT(2 == eventSetup.get<DummyRecord>().cacheIdentifier());
1323 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
1324 CPPUNIT_ASSERT(data->value_ == 1);
1325 }
1326 provider.forceCacheClear();
1327 {
1328 controller.eventSetupForInstance(IOVSyncValue{Timestamp(2)});
1329 DummyDataConsumer consumer{edm::ESInputTag("", "")};
1330 consumer.updateLookup(provider.recordsToResolverIndices());
1331 consumer.prefetch(provider.eventSetupImpl());
1332 EventSetup eventSetup{provider.eventSetupImpl(),
1333 static_cast<unsigned int>(edm::Transition::Event),
1334 consumer.esGetTokenIndices(edm::Transition::Event),
1335 pc};
1336 eventSetup.get<DummyRecord>();
1337 CPPUNIT_ASSERT(3 == eventSetup.get<DummyRecord>().cacheIdentifier());
1338 dummyProv->incrementData();
1339 edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
1340 CPPUNIT_ASSERT(data->value_ == 2);
1341 }
1342 }