Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-04-30 22:24:10 

0001 /*
0002  *  dependentrecord_t.cpp
0003  *  EDMProto
0004  *
0005  *  Created by Chris Jones on 4/29/05.
0006  *  Changed by Viji Sundararajan on 29-Jun-2005
0007  *
0008  */
0009 
0010 #include "FWCore/Framework/test/DummyRecord.h"
0011 #include "FWCore/Framework/test/Dummy2Record.h"
0012 #include "FWCore/Framework/test/DepRecord.h"
0013 #include "FWCore/Framework/test/DepOn2Record.h"
0014 #include "FWCore/Framework/test/DummyFinder.h"
0015 #include "FWCore/Framework/test/DummyData.h"
0016 #include "FWCore/Framework/test/DummyESProductResolverProvider.h"
0017 #include "FWCore/Framework/interface/DependentRecordIntervalFinder.h"
0018 #include "FWCore/Framework/interface/EventSetupImpl.h"
0019 #include "FWCore/Framework/interface/EventSetupProvider.h"
0020 #include "FWCore/Framework/interface/EventSetup.h"
0021 #include "FWCore/Framework/interface/ESProductResolverProvider.h"
0022 #include "FWCore/Framework/interface/ESProductResolverTemplate.h"
0023 #include "FWCore/Framework/interface/ESRecordsToProductResolverIndices.h"
0024 #include "FWCore/Framework/interface/EDConsumerBase.h"
0025 #include "FWCore/Framework/interface/EventSetupRecordIntervalFinder.h"
0026 #include "FWCore/Framework/interface/EventSetupRecordProvider.h"
0027 #include "FWCore/Framework/src/SynchronousEventSetupsController.h"
0028 #include "FWCore/Framework/interface/NoRecordException.h"
0029 #include "FWCore/Framework/test/print_eventsetup_record_dependencies.h"
0030 #include "FWCore/Framework/interface/ESModuleProducesInfo.h"
0031 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0032 #include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
0033 #include "FWCore/ServiceRegistry/interface/ESParentContext.h"
0034 #include "FWCore/Utilities/interface/propagate_const.h"
0035 #include "FWCore/Concurrency/interface/ThreadsController.h"
0036 #include "FWCore/Concurrency/interface/FinalWaitingTask.h"
0037 
0038 #include "cppunit/extensions/HelperMacros.h"
0039 
0040 #include <memory>
0041 #include <string>
0042 #include <vector>
0043 #include <cstring>
0044 
0045 using namespace edm::eventsetup;
0046 
0047 namespace {
0048   edm::ParameterSet createDummyPset() {
0049     edm::ParameterSet pset;
0050     std::vector<std::string> emptyVStrings;
0051     pset.addParameter<std::vector<std::string>>("@all_esprefers", emptyVStrings);
0052     pset.addParameter<std::vector<std::string>>("@all_essources", emptyVStrings);
0053     pset.addParameter<std::vector<std::string>>("@all_esmodules", emptyVStrings);
0054     return pset;
0055   }
0056 }  // namespace
0057 
0058 class testdependentrecord : public CppUnit::TestFixture {
0059   CPPUNIT_TEST_SUITE(testdependentrecord);
0060 
0061   CPPUNIT_TEST(dependentConstructorTest);
0062   CPPUNIT_TEST(dependentFinder1Test);
0063   CPPUNIT_TEST(dependentFinder2Test);
0064   CPPUNIT_TEST(testIncomparibleIOVAlgorithm);
0065   CPPUNIT_TEST(testInvalidIOVAlgorithm);
0066   CPPUNIT_TEST(testInvalidIOVFirstTime);
0067   CPPUNIT_TEST(testInvalidIOVFirstEventID);
0068   CPPUNIT_TEST(timeAndRunTest);
0069   CPPUNIT_TEST(dependentSetproviderTest);
0070   CPPUNIT_TEST(getTest);
0071   CPPUNIT_TEST(getDataWithESGetTokenTest);
0072   CPPUNIT_TEST(getHandleWithESGetTokenTest);
0073   CPPUNIT_TEST(getTransientHandleWithESGetTokenTest);
0074   CPPUNIT_TEST(oneOfTwoRecordTest);
0075   CPPUNIT_TEST(resetTest);
0076   CPPUNIT_TEST(alternateFinderTest);
0077   CPPUNIT_TEST(invalidRecordTest);
0078   CPPUNIT_TEST(extendIOVTest);
0079 
0080   CPPUNIT_TEST_SUITE_END();
0081 
0082 public:
0083   void setUp() { m_scheduler = std::make_unique<edm::ThreadsController>(1); }
0084   void tearDown() {}
0085 
0086   void dependentConstructorTest();
0087   void dependentFinder1Test();
0088   void dependentFinder2Test();
0089   void testIncomparibleIOVAlgorithm();
0090   void testInvalidIOVAlgorithm();
0091   void testInvalidIOVFirstTime();
0092   void testInvalidIOVFirstEventID();
0093   void timeAndRunTest();
0094   void dependentSetproviderTest();
0095   void getTest();
0096   void getDataWithESGetTokenTest();
0097   void getHandleWithESGetTokenTest();
0098   void getTransientHandleWithESGetTokenTest();
0099   void oneOfTwoRecordTest();
0100   void resetTest();
0101   void alternateFinderTest();
0102   void invalidRecordTest();
0103   void extendIOVTest();
0104 
0105 private:
0106   edm::propagate_const<std::unique_ptr<edm::ThreadsController>> m_scheduler;
0107 
0108 };  //Cppunit class declaration over
0109 
0110 ///registration of the test so that the runner can find it
0111 CPPUNIT_TEST_SUITE_REGISTRATION(testdependentrecord);
0112 
0113 /* The Records used in the test have the following dependencies
0114    DepRecord -----> DummyRecord
0115                 /
0116    DepOn2Record---> Dummy2Record
0117 
0118  */
0119 
0120 namespace {
0121 
0122   edm::ActivityRegistry activityRegistry;
0123 
0124   class DummyESProductResolverProvider : public edm::eventsetup::ESProductResolverProvider {
0125   public:
0126     DummyESProductResolverProvider() { usingRecord<DummyRecord>(); }
0127 
0128   protected:
0129     KeyedResolversVector registerResolvers(const EventSetupRecordKey&, unsigned int /* iovIndex */) override {
0130       return KeyedResolversVector();
0131     }
0132     std::vector<edm::eventsetup::ESModuleProducesInfo> producesInfo() const override {
0133       return std::vector<edm::eventsetup::ESModuleProducesInfo>();
0134     }
0135   };
0136 
0137   class DepRecordResolverProvider : public edm::eventsetup::ESProductResolverProvider {
0138   public:
0139     DepRecordResolverProvider() { usingRecord<DepRecord>(); }
0140 
0141   protected:
0142     KeyedResolversVector registerResolvers(const EventSetupRecordKey&, unsigned int /* iovIndex */) override {
0143       return KeyedResolversVector();
0144     }
0145     std::vector<edm::eventsetup::ESModuleProducesInfo> producesInfo() const override {
0146       return std::vector<edm::eventsetup::ESModuleProducesInfo>();
0147     }
0148   };
0149 
0150   class WorkingDepRecordResolver
0151       : public edm::eventsetup::ESProductResolverTemplate<DepRecord, edm::eventsetup::test::DummyData> {
0152   public:
0153     WorkingDepRecordResolver(const edm::eventsetup::test::DummyData* iDummy) : data_(iDummy) {}
0154 
0155   protected:
0156     const value_type* make(const record_type&, const DataKey&) final { return data_; }
0157     void const* getAfterPrefetchImpl() const final { return data_; }
0158 
0159   private:
0160     const edm::eventsetup::test::DummyData* data_;
0161   };
0162 
0163   class DepRecordResolverProviderWithData : public edm::eventsetup::ESProductResolverProvider {
0164   public:
0165     DepRecordResolverProviderWithData(const edm::eventsetup::test::DummyData& iData = edm::eventsetup::test::DummyData())
0166         : dummy_(iData) {
0167       usingRecord<DepRecord>();
0168     }
0169 
0170   protected:
0171     KeyedResolversVector registerResolvers(const EventSetupRecordKey&, unsigned int /* iovIndex */) override {
0172       KeyedResolversVector keyedResolversVector;
0173       std::shared_ptr<WorkingDepRecordResolver> pResolver = std::make_shared<WorkingDepRecordResolver>(&dummy_);
0174       edm::eventsetup::DataKey dataKey(edm::eventsetup::DataKey::makeTypeTag<edm::eventsetup::test::DummyData>(), "");
0175       keyedResolversVector.emplace_back(dataKey, pResolver);
0176       return keyedResolversVector;
0177     }
0178     std::vector<edm::eventsetup::ESModuleProducesInfo> producesInfo() const override {
0179       return std::vector<edm::eventsetup::ESModuleProducesInfo>(
0180           1,
0181           edm::eventsetup::ESModuleProducesInfo(
0182               edm::eventsetup::EventSetupRecordKey::makeKey<DepRecord>(),
0183               edm::eventsetup::DataKey(edm::eventsetup::DataKey::makeTypeTag<edm::eventsetup::test::DummyData>(), ""),
0184               0));
0185     }
0186 
0187   private:
0188     edm::eventsetup::test::DummyData dummy_;
0189   };
0190 
0191   class DepOn2RecordResolverProvider : public edm::eventsetup::ESProductResolverProvider {
0192   public:
0193     DepOn2RecordResolverProvider() { usingRecord<DepOn2Record>(); }
0194 
0195   protected:
0196     KeyedResolversVector registerResolvers(const EventSetupRecordKey&, unsigned int /* iovIndex */) override {
0197       return KeyedResolversVector();
0198     }
0199     std::vector<edm::eventsetup::ESModuleProducesInfo> producesInfo() const override {
0200       return std::vector<edm::eventsetup::ESModuleProducesInfo>();
0201     }
0202   };
0203 
0204   class DepRecordFinder : public edm::EventSetupRecordIntervalFinder {
0205   public:
0206     DepRecordFinder() : edm::EventSetupRecordIntervalFinder(), interval_() { this->findingRecord<DepRecord>(); }
0207 
0208     void setInterval(const edm::ValidityInterval& iInterval) { interval_ = iInterval; }
0209 
0210   protected:
0211     void setIntervalFor(const edm::eventsetup::EventSetupRecordKey&,
0212                         const edm::IOVSyncValue& iTime,
0213                         edm::ValidityInterval& iInterval) override {
0214       if (interval_.validFor(iTime)) {
0215         iInterval = interval_;
0216       } else {
0217         if (interval_.last() == edm::IOVSyncValue::invalidIOVSyncValue() &&
0218             interval_.first() != edm::IOVSyncValue::invalidIOVSyncValue() && interval_.first() <= iTime) {
0219           iInterval = interval_;
0220         } else {
0221           iInterval = edm::ValidityInterval();
0222         }
0223       }
0224     }
0225 
0226   private:
0227     edm::ValidityInterval interval_;
0228   };
0229 
0230   class Dummy2RecordFinder : public edm::EventSetupRecordIntervalFinder {
0231   public:
0232     Dummy2RecordFinder() : edm::EventSetupRecordIntervalFinder(), interval_() { this->findingRecord<Dummy2Record>(); }
0233 
0234     void setInterval(const edm::ValidityInterval& iInterval) { interval_ = iInterval; }
0235 
0236   protected:
0237     void setIntervalFor(const edm::eventsetup::EventSetupRecordKey&,
0238                         const edm::IOVSyncValue& iTime,
0239                         edm::ValidityInterval& iInterval) override {
0240       if (interval_.validFor(iTime)) {
0241         iInterval = interval_;
0242       } else {
0243         if (interval_.last() == edm::IOVSyncValue::invalidIOVSyncValue() &&
0244             interval_.first() != edm::IOVSyncValue::invalidIOVSyncValue() && interval_.first() <= iTime) {
0245           iInterval = interval_;
0246         } else {
0247           iInterval = edm::ValidityInterval();
0248         }
0249       }
0250     }
0251 
0252   private:
0253     edm::ValidityInterval interval_;
0254   };
0255 }  // namespace
0256 
0257 using namespace edm::eventsetup;
0258 void testdependentrecord::dependentConstructorTest() {
0259   EventSetupRecordProvider depProvider(DepRecord::keyForClass(), &activityRegistry);
0260 
0261   CPPUNIT_ASSERT(1 == depProvider.dependentRecords().size());
0262   CPPUNIT_ASSERT(*(depProvider.dependentRecords().begin()) == DummyRecord::keyForClass());
0263 
0264   edm::print_eventsetup_record_dependencies<DepRecord>(std::cout);
0265 }
0266 
0267 void testdependentrecord::dependentFinder1Test() {
0268   auto dummyProvider = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0269   const edm::EventID eID_1(1, 1, 1);
0270   const edm::IOVSyncValue sync_1(eID_1);
0271   const edm::EventID eID_3(1, 1, 3);
0272   const edm::ValidityInterval definedInterval(sync_1, edm::IOVSyncValue(eID_3));
0273   std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0274   dummyFinder->setInterval(definedInterval);
0275   dummyProvider->addFinder(dummyFinder);
0276 
0277   const EventSetupRecordKey depRecordKey = DepRecord::keyForClass();
0278   DependentRecordIntervalFinder finder(depRecordKey);
0279   finder.addProviderWeAreDependentOn(dummyProvider);
0280 
0281   CPPUNIT_ASSERT(definedInterval == finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 2))));
0282 
0283   dummyFinder->setInterval(edm::ValidityInterval::invalidInterval());
0284   dummyProvider->initializeForNewSyncValue();
0285   CPPUNIT_ASSERT(edm::ValidityInterval::invalidInterval() ==
0286                  finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 4))));
0287 
0288   const edm::EventID eID_5(1, 1, 5);
0289   const edm::IOVSyncValue sync_5(eID_5);
0290   const edm::ValidityInterval unknownedEndInterval(sync_5, edm::IOVSyncValue::invalidIOVSyncValue());
0291   dummyFinder->setInterval(unknownedEndInterval);
0292 
0293   dummyProvider->initializeForNewSyncValue();
0294   CPPUNIT_ASSERT(unknownedEndInterval ==
0295                  finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 5))));
0296 }
0297 
0298 void testdependentrecord::dependentFinder2Test() {
0299   auto dummyProvider1 = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0300 
0301   const edm::EventID eID_1(1, 1, 1);
0302   const edm::IOVSyncValue sync_1(eID_1);
0303   const edm::ValidityInterval definedInterval1(sync_1, edm::IOVSyncValue(edm::EventID(1, 1, 5)));
0304   dummyProvider1->setValidityInterval_forTesting(definedInterval1);
0305 
0306   auto dummyProvider2 = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0307 
0308   const edm::EventID eID_2(1, 1, 2);
0309   const edm::IOVSyncValue sync_2(eID_2);
0310   const edm::ValidityInterval definedInterval2(sync_2, edm::IOVSyncValue(edm::EventID(1, 1, 6)));
0311   dummyProvider2->setValidityInterval_forTesting(definedInterval2);
0312 
0313   const edm::ValidityInterval overlapInterval(std::max(definedInterval1.first(), definedInterval2.first()),
0314                                               std::min(definedInterval1.last(), definedInterval2.last()));
0315 
0316   const EventSetupRecordKey depRecordKey = DepRecord::keyForClass();
0317 
0318   DependentRecordIntervalFinder finder(depRecordKey);
0319   finder.addProviderWeAreDependentOn(dummyProvider1);
0320   finder.addProviderWeAreDependentOn(dummyProvider2);
0321 
0322   CPPUNIT_ASSERT(overlapInterval == finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 4))));
0323 }
0324 
0325 void testdependentrecord::testIncomparibleIOVAlgorithm() {
0326   const EventSetupRecordKey depRecordKey = DepRecord::keyForClass();
0327   DependentRecordIntervalFinder finder(depRecordKey);
0328 
0329   //test case where we have two providers, one synching on time the other on run/lumi/event
0330   auto dummyProviderEventID = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0331   auto dummyProviderTime = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0332 
0333   finder.addProviderWeAreDependentOn(dummyProviderEventID);
0334   finder.addProviderWeAreDependentOn(dummyProviderTime);
0335 
0336   {
0337     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(1, 1, 1)),
0338                                            edm::IOVSyncValue(edm::EventID(1, 1, 5)));
0339     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0340 
0341     const edm::ValidityInterval iovTime(edm::IOVSyncValue(edm::Timestamp(1)), edm::IOVSyncValue(edm::Timestamp(6)));
0342     dummyProviderTime->setValidityInterval_forTesting(iovTime);
0343 
0344     const edm::ValidityInterval expectedIOV(iovTime.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0345 
0346     // The algorithm selects incomparable IOVs from the two providers based on
0347     // the least estimated time difference from the start of changed IOVs.
0348     // The difference based on lumi numbers is zero in this case (assumes
0349     // 23 second lumis). The difference in times is also zero because it is
0350     // calculating in seconds and the lower 32 bits of the time argument to
0351     // the Timestamp constructor are dropped by the algorithm. So when finding
0352     // the closest both time and eventID estimates are zero. On a tie, the algorithm
0353     // selects the time IOV.
0354     CPPUNIT_ASSERT(expectedIOV ==
0355                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 4), edm::Timestamp(3))));
0356 
0357     // With IOVs that are not comparable we just continually get back the same
0358     // result when none of the IOVs changes. Next 3 just show that.
0359 
0360     //should give back same interval
0361     dummyProviderEventID->initializeForNewSyncValue();
0362     dummyProviderTime->initializeForNewSyncValue();
0363     CPPUNIT_ASSERT(expectedIOV ==
0364                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 4), edm::Timestamp(4))));
0365 
0366     //should give back same interval
0367     dummyProviderEventID->initializeForNewSyncValue();
0368     dummyProviderTime->initializeForNewSyncValue();
0369     CPPUNIT_ASSERT(expectedIOV ==
0370                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 2), edm::Timestamp(3))));
0371 
0372     //should give back same interval
0373     dummyProviderEventID->initializeForNewSyncValue();
0374     dummyProviderTime->initializeForNewSyncValue();
0375     CPPUNIT_ASSERT(expectedIOV ==
0376                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 1), edm::Timestamp(2))));
0377   }
0378   {
0379     //Change only run/lumi/event based provider. The algorithm picks
0380     //the closest of the IOVs that changed, so now gets the EventID based
0381     //IOV.
0382     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(1, 1, 6)),
0383                                            edm::IOVSyncValue(edm::EventID(1, 1, 10)));
0384     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0385 
0386     const edm::ValidityInterval expectedIOV(iovEventID.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0387 
0388     // Don't need to call initializeForNewSyncValue() if setValidityInterval_forTesting
0389     // was called.
0390     dummyProviderTime->initializeForNewSyncValue();
0391     CPPUNIT_ASSERT(expectedIOV ==
0392                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 6), edm::Timestamp(5))));
0393   }
0394   {
0395     //Change only time based provider
0396     const edm::ValidityInterval iovTime(edm::IOVSyncValue(edm::Timestamp(7)), edm::IOVSyncValue(edm::Timestamp(10)));
0397     dummyProviderTime->setValidityInterval_forTesting(iovTime);
0398 
0399     const edm::ValidityInterval expectedIOV(iovTime.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0400 
0401     dummyProviderEventID->initializeForNewSyncValue();
0402     CPPUNIT_ASSERT(expectedIOV ==
0403                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 7), edm::Timestamp(7))));
0404   }
0405   //Change both but make run/lumi/event 'closer' by having same lumi
0406   {
0407     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(1, 2, 11)),
0408                                            edm::IOVSyncValue(edm::EventID(1, 3, 20)));
0409     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0410 
0411     const edm::ValidityInterval iovTime(edm::IOVSyncValue(edm::Timestamp(1ULL << 32)),
0412                                         edm::IOVSyncValue(edm::Timestamp(5ULL << 32)));
0413     dummyProviderTime->setValidityInterval_forTesting(iovTime);
0414 
0415     const edm::ValidityInterval expectedIOV(iovEventID.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0416     CPPUNIT_ASSERT(
0417         expectedIOV ==
0418         finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 2, 12), edm::Timestamp(3ULL << 32))));
0419   }
0420   //Change both but make time 'closer'
0421   {
0422     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(1, 3, 21)),
0423                                            edm::IOVSyncValue(edm::EventID(1, 10, 40)));
0424     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0425 
0426     const edm::ValidityInterval iovTime(edm::IOVSyncValue(edm::Timestamp(7ULL << 32)),
0427                                         edm::IOVSyncValue(edm::Timestamp(10ULL << 32)));
0428     dummyProviderTime->setValidityInterval_forTesting(iovTime);
0429 
0430     const edm::ValidityInterval expectedIOV(iovTime.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0431     CPPUNIT_ASSERT(
0432         expectedIOV ==
0433         finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 4, 30), edm::Timestamp(8ULL << 32))));
0434   }
0435   //Change both but make run/lumi/event 'closer'
0436   {
0437     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(1, 11, 41)),
0438                                            edm::IOVSyncValue(edm::EventID(1, 20, 60)));
0439     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0440 
0441     const edm::ValidityInterval iovTime(edm::IOVSyncValue(edm::Timestamp(11ULL << 32)),
0442                                         edm::IOVSyncValue(edm::Timestamp(100ULL << 32)));
0443     dummyProviderTime->setValidityInterval_forTesting(iovTime);
0444 
0445     const edm::ValidityInterval expectedIOV(iovEventID.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0446     CPPUNIT_ASSERT(
0447         expectedIOV ==
0448         finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 12, 50), edm::Timestamp(70ULL << 32))));
0449   }
0450 
0451   //Change both and make it ambiguous because of different run #
0452   {
0453     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(2, 1, 0)),
0454                                            edm::IOVSyncValue(edm::EventID(6, 0, 0)));
0455     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0456 
0457     const edm::ValidityInterval iovTime(edm::IOVSyncValue(edm::Timestamp(200ULL << 32)),
0458                                         edm::IOVSyncValue(edm::Timestamp(500ULL << 32)));
0459     dummyProviderTime->setValidityInterval_forTesting(iovTime);
0460 
0461     const edm::ValidityInterval expectedIOV(iovTime.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0462     CPPUNIT_ASSERT(
0463         expectedIOV ==
0464         finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(4, 12, 50), edm::Timestamp(400ULL << 32))));
0465   }
0466   {
0467     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(1, 1, 6)),
0468                                            edm::IOVSyncValue(edm::EventID(1, 1, 10)));
0469     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0470 
0471     const edm::ValidityInterval iovTime(edm::IOVSyncValue(edm::Timestamp(7)), edm::IOVSyncValue(edm::Timestamp(10)));
0472     dummyProviderTime->setValidityInterval_forTesting(iovTime);
0473 
0474     const edm::ValidityInterval expectedIOV(iovTime.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0475     CPPUNIT_ASSERT(expectedIOV ==
0476                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 7), edm::Timestamp(7))));
0477   }
0478 }
0479 
0480 void testdependentrecord::testInvalidIOVAlgorithm() {
0481   const EventSetupRecordKey depRecordKey = DepRecord::keyForClass();
0482   DependentRecordIntervalFinder finder(depRecordKey);
0483 
0484   auto dummyProviderEventID = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0485   auto dummyProviderTime = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0486 
0487   finder.addProviderWeAreDependentOn(dummyProviderEventID);
0488   finder.addProviderWeAreDependentOn(dummyProviderTime);
0489 
0490   {
0491     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(1, 1, 6)),
0492                                            edm::IOVSyncValue(edm::EventID(1, 1, 10)));
0493     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0494 
0495     const edm::ValidityInterval iovTime(edm::IOVSyncValue(edm::Timestamp(7)), edm::IOVSyncValue(edm::Timestamp(10)));
0496     dummyProviderTime->setValidityInterval_forTesting(iovTime);
0497 
0498     const edm::ValidityInterval expectedIOV(iovTime.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0499     CPPUNIT_ASSERT(expectedIOV ==
0500                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 7), edm::Timestamp(7))));
0501   }
0502 
0503   //check with invalid intervals
0504   const edm::ValidityInterval invalid(edm::IOVSyncValue::invalidIOVSyncValue(),
0505                                       edm::IOVSyncValue::invalidIOVSyncValue());
0506   {
0507     dummyProviderEventID->setValidityInterval_forTesting(invalid);
0508     dummyProviderTime->initializeForNewSyncValue();
0509     const edm::ValidityInterval expectedIOV(edm::IOVSyncValue(edm::Timestamp(7)),
0510                                             edm::IOVSyncValue::invalidIOVSyncValue());
0511     CPPUNIT_ASSERT(expectedIOV ==
0512                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 11), edm::Timestamp(8))));
0513   }
0514   {
0515     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(1, 1, 12)),
0516                                            edm::IOVSyncValue(edm::EventID(1, 1, 20)));
0517     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0518     dummyProviderTime->setValidityInterval_forTesting(invalid);
0519     const edm::ValidityInterval expectedIOV(iovEventID.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0520     CPPUNIT_ASSERT(expectedIOV ==
0521                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 13), edm::Timestamp(11))));
0522   }
0523   {
0524     dummyProviderEventID->setValidityInterval_forTesting(invalid);
0525     dummyProviderTime->setValidityInterval_forTesting(invalid);
0526 
0527     dummyProviderEventID->initializeForNewSyncValue();
0528     CPPUNIT_ASSERT(invalid ==
0529                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 13), edm::Timestamp(11))));
0530   }
0531 }
0532 
0533 void testdependentrecord::testInvalidIOVFirstTime() {
0534   const EventSetupRecordKey depRecordKey = DepRecord::keyForClass();
0535   DependentRecordIntervalFinder finder(depRecordKey);
0536 
0537   auto dummyProviderEventID = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0538   auto dummyProviderTime = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0539 
0540   finder.addProviderWeAreDependentOn(dummyProviderEventID);
0541   finder.addProviderWeAreDependentOn(dummyProviderTime);
0542 
0543   const edm::ValidityInterval invalid(edm::IOVSyncValue::invalidIOVSyncValue(),
0544                                       edm::IOVSyncValue::invalidIOVSyncValue());
0545   {
0546     //check for bug which only happens the first time we synchronize
0547     // have the second one invalid
0548     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(1, 1, 1)),
0549                                            edm::IOVSyncValue(edm::EventID(1, 1, 6)));
0550     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0551 
0552     dummyProviderTime->setValidityInterval_forTesting(invalid);
0553 
0554     const edm::ValidityInterval expectedIOV(iovEventID.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0555 
0556     CPPUNIT_ASSERT(expectedIOV ==
0557                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 4), edm::Timestamp(1))));
0558   }
0559   {
0560     const edm::ValidityInterval iovTime(edm::IOVSyncValue(edm::Timestamp(2)), edm::IOVSyncValue(edm::Timestamp(6)));
0561     dummyProviderTime->setValidityInterval_forTesting(iovTime);
0562 
0563     const edm::ValidityInterval expectedIOV(iovTime.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0564 
0565     dummyProviderEventID->initializeForNewSyncValue();
0566     CPPUNIT_ASSERT(expectedIOV ==
0567                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 5), edm::Timestamp(3))));
0568   }
0569 }
0570 
0571 void testdependentrecord::testInvalidIOVFirstEventID() {
0572   const EventSetupRecordKey depRecordKey = DepRecord::keyForClass();
0573   DependentRecordIntervalFinder finder(depRecordKey);
0574 
0575   auto dummyProviderEventID = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0576   auto dummyProviderTime = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0577 
0578   finder.addProviderWeAreDependentOn(dummyProviderEventID);
0579   finder.addProviderWeAreDependentOn(dummyProviderTime);
0580 
0581   const edm::ValidityInterval invalid(edm::IOVSyncValue::invalidIOVSyncValue(),
0582                                       edm::IOVSyncValue::invalidIOVSyncValue());
0583   {
0584     //check for bug which only happens the first time we synchronize
0585     // have the  first one invalid
0586     dummyProviderEventID->setValidityInterval_forTesting(invalid);
0587 
0588     const edm::ValidityInterval iovTime(edm::IOVSyncValue(edm::Timestamp(1)), edm::IOVSyncValue(edm::Timestamp(6)));
0589     dummyProviderTime->setValidityInterval_forTesting(iovTime);
0590 
0591     const edm::ValidityInterval expectedIOV(iovTime.first(), edm::IOVSyncValue::invalidIOVSyncValue());
0592 
0593     CPPUNIT_ASSERT(expectedIOV ==
0594                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 4), edm::Timestamp(3))));
0595   }
0596   {
0597     const edm::ValidityInterval iovEventID(edm::IOVSyncValue(edm::EventID(1, 1, 5)),
0598                                            edm::IOVSyncValue(edm::EventID(1, 1, 10)));
0599     dummyProviderEventID->setValidityInterval_forTesting(iovEventID);
0600 
0601     const edm::ValidityInterval expectedIOV(edm::IOVSyncValue(edm::Timestamp(1)),
0602                                             edm::IOVSyncValue::invalidIOVSyncValue());
0603     dummyProviderTime->initializeForNewSyncValue();
0604     CPPUNIT_ASSERT(expectedIOV ==
0605                    finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 5), edm::Timestamp(4))));
0606   }
0607 }
0608 
0609 void testdependentrecord::timeAndRunTest() {
0610   edm::ParameterSet pset = createDummyPset();
0611   {
0612     SynchronousEventSetupsController controller;
0613     EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0614 
0615     std::shared_ptr<edm::eventsetup::ESProductResolverProvider> dummyProv =
0616         std::make_shared<DummyESProductResolverProvider>();
0617     provider.add(dummyProv);
0618 
0619     std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0620     dummyFinder->setInterval(
0621         edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 1)), edm::IOVSyncValue(edm::EventID(1, 1, 5))));
0622     provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
0623 
0624     std::shared_ptr<edm::eventsetup::ESProductResolverProvider> depProv =
0625         std::make_shared<DepOn2RecordResolverProvider>();
0626     provider.add(depProv);
0627 
0628     std::shared_ptr<Dummy2RecordFinder> dummy2Finder = std::make_shared<Dummy2RecordFinder>();
0629     dummy2Finder->setInterval(
0630         edm::ValidityInterval(edm::IOVSyncValue(edm::Timestamp(1)), edm::IOVSyncValue(edm::Timestamp(5))));
0631     provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummy2Finder));
0632 
0633     {
0634       edm::ESParentContext parentC;
0635       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1), edm::Timestamp(1)));
0636       const edm::EventSetup eventSetup1(provider.eventSetupImpl(), 0, nullptr, parentC);
0637       long long id1 = eventSetup1.get<DepOn2Record>().cacheIdentifier();
0638 
0639       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1), edm::Timestamp(2)));
0640       const edm::EventSetup eventSetup2(provider.eventSetupImpl(), 0, nullptr, parentC);
0641       long long id2 = eventSetup2.get<DepOn2Record>().cacheIdentifier();
0642       CPPUNIT_ASSERT(id1 == id2);
0643 
0644       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 2), edm::Timestamp(2)));
0645       const edm::EventSetup eventSetup3(provider.eventSetupImpl(), 0, nullptr, parentC);
0646       long long id3 = eventSetup3.get<DepOn2Record>().cacheIdentifier();
0647       CPPUNIT_ASSERT(id1 == id3);
0648 
0649       dummy2Finder->setInterval(
0650           edm::ValidityInterval(edm::IOVSyncValue(edm::Timestamp(6)), edm::IOVSyncValue(edm::Timestamp(10))));
0651 
0652       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 4), edm::Timestamp(7)));
0653       const edm::EventSetup eventSetup4(provider.eventSetupImpl(), 0, nullptr, parentC);
0654       long long id4 = eventSetup4.get<DepOn2Record>().cacheIdentifier();
0655       CPPUNIT_ASSERT(id1 != id4);
0656 
0657       dummyFinder->setInterval(
0658           edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 6)), edm::IOVSyncValue(edm::EventID(1, 1, 10))));
0659 
0660       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 7), edm::Timestamp(8)));
0661       const edm::EventSetup eventSetup5(provider.eventSetupImpl(), 0, nullptr, parentC);
0662       long long id5 = eventSetup5.get<DepOn2Record>().cacheIdentifier();
0663       CPPUNIT_ASSERT(id4 != id5);
0664     }
0665   }
0666 
0667   {
0668     //check that going all the way through EventSetup works properly
0669     // using two records with open ended IOVs
0670     SynchronousEventSetupsController controller;
0671     EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0672 
0673     std::shared_ptr<edm::eventsetup::ESProductResolverProvider> dummyProv =
0674         std::make_shared<DummyESProductResolverProvider>();
0675     provider.add(dummyProv);
0676 
0677     std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0678     dummyFinder->setInterval(
0679         edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 1)), edm::IOVSyncValue::invalidIOVSyncValue()));
0680     provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
0681 
0682     std::shared_ptr<edm::eventsetup::ESProductResolverProvider> depProv =
0683         std::make_shared<DepOn2RecordResolverProvider>();
0684     provider.add(depProv);
0685 
0686     std::shared_ptr<Dummy2RecordFinder> dummy2Finder = std::make_shared<Dummy2RecordFinder>();
0687     dummy2Finder->setInterval(
0688         edm::ValidityInterval(edm::IOVSyncValue(edm::Timestamp(1)), edm::IOVSyncValue::invalidIOVSyncValue()));
0689     provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummy2Finder));
0690     {
0691       edm::ESParentContext parentC;
0692       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1), edm::Timestamp(1)));
0693       const edm::EventSetup eventSetup1(provider.eventSetupImpl(), 0, nullptr, parentC);
0694       long long id1 = eventSetup1.get<DepOn2Record>().cacheIdentifier();
0695 
0696       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1), edm::Timestamp(2)));
0697       const edm::EventSetup eventSetup2(provider.eventSetupImpl(), 0, nullptr, parentC);
0698       long long id2 = eventSetup2.get<DepOn2Record>().cacheIdentifier();
0699       CPPUNIT_ASSERT(id1 == id2);
0700 
0701       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 2), edm::Timestamp(2)));
0702       const edm::EventSetup eventSetup3(provider.eventSetupImpl(), 0, nullptr, parentC);
0703       long long id3 = eventSetup3.get<DepOn2Record>().cacheIdentifier();
0704       CPPUNIT_ASSERT(id1 == id3);
0705 
0706       dummy2Finder->setInterval(
0707           edm::ValidityInterval(edm::IOVSyncValue(edm::Timestamp(6)), edm::IOVSyncValue::invalidIOVSyncValue()));
0708       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 4), edm::Timestamp(7)));
0709       const edm::EventSetup eventSetup4(provider.eventSetupImpl(), 0, nullptr, parentC);
0710       long long id4 = eventSetup4.get<DepOn2Record>().cacheIdentifier();
0711       CPPUNIT_ASSERT(id1 != id4);
0712 
0713       dummyFinder->setInterval(
0714           edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 6)), edm::IOVSyncValue::invalidIOVSyncValue()));
0715       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 7), edm::Timestamp(8)));
0716       const edm::EventSetup eventSetup5(provider.eventSetupImpl(), 0, nullptr, parentC);
0717       long long id5 = eventSetup5.get<DepOn2Record>().cacheIdentifier();
0718       CPPUNIT_ASSERT(id4 != id5);
0719     }
0720   }
0721 }
0722 
0723 void testdependentrecord::dependentSetproviderTest() {
0724   auto depProvider = std::make_unique<EventSetupRecordProvider>(DepRecord::keyForClass(), &activityRegistry);
0725 
0726   auto dummyProvider = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
0727 
0728   std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0729   dummyFinder->setInterval(
0730       edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 1)), edm::IOVSyncValue(edm::EventID(1, 1, 3))));
0731   dummyProvider->addFinder(dummyFinder);
0732 
0733   CPPUNIT_ASSERT(*(depProvider->dependentRecords().begin()) == dummyProvider->key());
0734 
0735   std::vector<std::shared_ptr<EventSetupRecordProvider>> providers;
0736   providers.push_back(dummyProvider);
0737   depProvider->setDependentProviders(providers);
0738 }
0739 
0740 void testdependentrecord::getTest() {
0741   SynchronousEventSetupsController controller;
0742   edm::ParameterSet pset = createDummyPset();
0743   EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0744 
0745   std::shared_ptr<edm::eventsetup::ESProductResolverProvider> dummyProv =
0746       std::make_shared<DummyESProductResolverProvider>();
0747   provider.add(dummyProv);
0748 
0749   std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0750   dummyFinder->setInterval(
0751       edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 1)), edm::IOVSyncValue(edm::EventID(1, 1, 3))));
0752   provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
0753 
0754   std::shared_ptr<edm::eventsetup::ESProductResolverProvider> depProv = std::make_shared<DepRecordResolverProvider>();
0755   provider.add(depProv);
0756   edm::ESParentContext parentC;
0757   {
0758     controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1)));
0759     const edm::EventSetup eventSetup1(provider.eventSetupImpl(), 0, nullptr, parentC);
0760     const DepRecord& depRecord = eventSetup1.get<DepRecord>();
0761 
0762     depRecord.getRecord<DummyRecord>();
0763 
0764     auto dr = depRecord.tryToGetRecord<DummyRecord>();
0765     CPPUNIT_ASSERT(dr.has_value());
0766   }
0767   {
0768     controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 4)));
0769     const edm::EventSetup eventSetup2(provider.eventSetupImpl(), 0, nullptr, parentC);
0770     CPPUNIT_ASSERT_THROW(eventSetup2.get<DepRecord>(), edm::eventsetup::NoRecordException<DepRecord>);
0771   }
0772 }
0773 
0774 namespace {
0775   template <typename RECORD>
0776   struct DummyDataConsumer : public edm::EDConsumerBase {
0777     explicit DummyDataConsumer(edm::ESInputTag const& iTag)
0778         : m_token{esConsumes<edm::eventsetup::test::DummyData, RECORD>(iTag)} {}
0779 
0780     void prefetch(edm::EventSetupImpl const& iImpl) const {
0781       auto const& recs = this->esGetTokenRecordIndicesVector(edm::Transition::Event);
0782       auto const& resolvers = this->esGetTokenIndicesVector(edm::Transition::Event);
0783       for (size_t i = 0; i != resolvers.size(); ++i) {
0784         auto rec = iImpl.findImpl(recs[i]);
0785         if (rec) {
0786           oneapi::tbb::task_group group;
0787           edm::FinalWaitingTask waitTask{group};
0788           edm::ServiceToken token;
0789           rec->prefetchAsync(
0790               edm::WaitingTaskHolder(group, &waitTask), resolvers[i], &iImpl, token, edm::ESParentContext{});
0791           waitTask.wait();
0792         }
0793       }
0794     }
0795     edm::ESGetToken<edm::eventsetup::test::DummyData, RECORD> m_token;
0796   };
0797 
0798   template <typename RECORD1, typename RECORD2>
0799   struct DummyDataConsumer2 : public edm::EDConsumerBase {
0800     explicit DummyDataConsumer2(edm::ESInputTag const& iTag1, edm::ESInputTag const& iTag2)
0801         : m_token1{esConsumes<edm::eventsetup::test::DummyData, RECORD1>(iTag1)},
0802           m_token2{esConsumes<edm::eventsetup::test::DummyData, RECORD2>(iTag2)} {}
0803 
0804     void prefetch(edm::EventSetupImpl const& iImpl) const {
0805       auto const& recs = this->esGetTokenRecordIndicesVector(edm::Transition::Event);
0806       auto const& resolvers = this->esGetTokenIndicesVector(edm::Transition::Event);
0807       for (size_t i = 0; i != resolvers.size(); ++i) {
0808         auto rec = iImpl.findImpl(recs[i]);
0809         if (rec) {
0810           oneapi::tbb::task_group group;
0811           edm::FinalWaitingTask waitTask{group};
0812           edm::ServiceToken token;
0813           rec->prefetchAsync(
0814               edm::WaitingTaskHolder(group, &waitTask), resolvers[i], &iImpl, token, edm::ESParentContext{});
0815           waitTask.wait();
0816         }
0817       }
0818     }
0819 
0820     edm::ESGetToken<edm::eventsetup::test::DummyData, RECORD1> m_token1;
0821     edm::ESGetToken<edm::eventsetup::test::DummyData, RECORD2> m_token2;
0822   };
0823 }  // namespace
0824 
0825 void testdependentrecord::getDataWithESGetTokenTest() {
0826   using edm::eventsetup::test::DummyData;
0827   using edm::eventsetup::test::DummyESProductResolverProvider;
0828   DummyData kGood{1};
0829   DummyData kBad{0};
0830 
0831   SynchronousEventSetupsController controller;
0832   edm::ParameterSet pset = createDummyPset();
0833   EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0834 
0835   try {
0836     {
0837       edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "testOne", 0, true);
0838       edm::ParameterSet ps;
0839       ps.addParameter<std::string>("name", "test11");
0840       ps.registerIt();
0841       description.pid_ = ps.id();
0842       auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
0843       dummyProv->setDescription(description);
0844       provider.add(dummyProv);
0845     }
0846     {
0847       edm::eventsetup::ComponentDescription description("DepRecordResolverProviderWithData", "testTwo", 1, true);
0848       edm::ParameterSet ps;
0849       ps.addParameter<std::string>("name", "test22");
0850       ps.addParameter<std::string>("appendToDataLabel", "blah");
0851       ps.registerIt();
0852       description.pid_ = ps.id();
0853       auto dummyProv = std::make_shared<DepRecordResolverProviderWithData>(kGood);
0854       dummyProv->setDescription(description);
0855       dummyProv->setAppendToDataLabel(ps);
0856       provider.add(dummyProv);
0857     }
0858 
0859     std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
0860     dummyFinder->setInterval(
0861         edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 1)), edm::IOVSyncValue(edm::EventID(1, 1, 3))));
0862     provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
0863 
0864     controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1)));
0865     edm::ESParentContext parentC;
0866     {
0867       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"", "blah"}};
0868       consumer.updateLookup(provider.recordsToResolverIndices());
0869       consumer.prefetch(provider.eventSetupImpl());
0870       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0871                                        static_cast<unsigned int>(edm::Transition::Event),
0872                                        consumer.esGetTokenIndices(edm::Transition::Event),
0873                                        parentC};
0874       auto const& data = eventSetup.getData(consumer.m_token);
0875       CPPUNIT_ASSERT(kGood.value_ == data.value_);
0876     }
0877     {
0878       DummyDataConsumer<DummyRecord> consumer{edm::ESInputTag{"", ""}};
0879       consumer.updateLookup(provider.recordsToResolverIndices());
0880       consumer.prefetch(provider.eventSetupImpl());
0881       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0882                                        static_cast<unsigned int>(edm::Transition::Event),
0883                                        consumer.esGetTokenIndices(edm::Transition::Event),
0884                                        parentC};
0885       auto const& data = eventSetup.getData(consumer.m_token);
0886       CPPUNIT_ASSERT(kBad.value_ == data.value_);
0887     }
0888     {
0889       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"", "blah"}};
0890       consumer.updateLookup(provider.recordsToResolverIndices());
0891       consumer.prefetch(provider.eventSetupImpl());
0892       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0893                                        static_cast<unsigned int>(edm::Transition::Event),
0894                                        consumer.esGetTokenIndices(edm::Transition::Event),
0895                                        parentC};
0896       auto const& depRecord = eventSetup.get<DepRecord>();
0897       auto const& data = depRecord.get(consumer.m_token);
0898       CPPUNIT_ASSERT(kGood.value_ == data.value_);
0899     }
0900     {
0901       DummyDataConsumer<DummyRecord> consumer{edm::ESInputTag{"", ""}};
0902       consumer.updateLookup(provider.recordsToResolverIndices());
0903       consumer.prefetch(provider.eventSetupImpl());
0904       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0905                                        static_cast<unsigned int>(edm::Transition::Event),
0906                                        consumer.esGetTokenIndices(edm::Transition::Event),
0907                                        parentC};
0908       auto const& depRecord = eventSetup.get<DepRecord>();
0909 
0910       auto const& data = depRecord.get(consumer.m_token);
0911       CPPUNIT_ASSERT(kBad.value_ == data.value_);
0912     }
0913     {
0914       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"", "blah"}};
0915       consumer.updateLookup(provider.recordsToResolverIndices());
0916       consumer.prefetch(provider.eventSetupImpl());
0917       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0918                                        static_cast<unsigned int>(edm::Transition::Event),
0919                                        consumer.esGetTokenIndices(edm::Transition::Event),
0920                                        parentC};
0921       auto const& depRecord = eventSetup.get<DepRecord>();
0922 
0923       auto const& data = depRecord.get(consumer.m_token);
0924       CPPUNIT_ASSERT(kGood.value_ == data.value_);
0925     }
0926     {
0927       DummyDataConsumer2<DummyRecord, DepRecord> consumer{edm::ESInputTag{"", ""}, edm::ESInputTag{"", "blah"}};
0928       consumer.updateLookup(provider.recordsToResolverIndices());
0929       consumer.prefetch(provider.eventSetupImpl());
0930       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0931                                        static_cast<unsigned int>(edm::Transition::Event),
0932                                        consumer.esGetTokenIndices(edm::Transition::Event),
0933                                        parentC};
0934       auto const& depRecord = eventSetup.get<DepRecord>();
0935 
0936       auto const& data1 = depRecord.get(consumer.m_token1);
0937       CPPUNIT_ASSERT(kBad.value_ == data1.value_);
0938 
0939       auto const& data2 = depRecord.get(consumer.m_token2);
0940       CPPUNIT_ASSERT(kGood.value_ == data2.value_);
0941     }
0942     {
0943       DummyDataConsumer<DummyRecord> consumer{edm::ESInputTag{"DoesNotExist", ""}};
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                                        parentC};
0950       auto const& depRecord = eventSetup.get<DepRecord>();
0951 
0952       CPPUNIT_ASSERT_THROW(depRecord.get(consumer.m_token), cms::Exception);
0953     }
0954     {
0955       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"DoesNotExist", "blah"}};
0956       consumer.updateLookup(provider.recordsToResolverIndices());
0957       consumer.prefetch(provider.eventSetupImpl());
0958       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
0959                                        static_cast<unsigned int>(edm::Transition::Event),
0960                                        consumer.esGetTokenIndices(edm::Transition::Event),
0961                                        parentC};
0962       auto const& depRecord = eventSetup.get<DepRecord>();
0963 
0964       CPPUNIT_ASSERT_THROW(depRecord.get(consumer.m_token), cms::Exception);
0965     }
0966   } catch (const cms::Exception& iException) {
0967     std::cout << "caught " << iException.explainSelf() << std::endl;
0968     throw;
0969   }
0970 }
0971 
0972 void testdependentrecord::getHandleWithESGetTokenTest() {
0973   using edm::eventsetup::test::DummyData;
0974   using edm::eventsetup::test::DummyESProductResolverProvider;
0975   DummyData kGood{1};
0976   DummyData kBad{0};
0977 
0978   SynchronousEventSetupsController controller;
0979   edm::ParameterSet pset = createDummyPset();
0980   EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
0981 
0982   try {
0983     {
0984       edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "testOne", 0, true);
0985       edm::ParameterSet ps;
0986       ps.addParameter<std::string>("name", "test11");
0987       ps.registerIt();
0988       description.pid_ = ps.id();
0989       auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
0990       dummyProv->setDescription(description);
0991       provider.add(dummyProv);
0992     }
0993     {
0994       edm::eventsetup::ComponentDescription description("DepRecordResolverProviderWithData", "testTwo", 1, true);
0995       edm::ParameterSet ps;
0996       ps.addParameter<std::string>("name", "test22");
0997       ps.addParameter<std::string>("appendToDataLabel", "blah");
0998       ps.registerIt();
0999       description.pid_ = ps.id();
1000       auto dummyProv = std::make_shared<DepRecordResolverProviderWithData>(kGood);
1001       dummyProv->setDescription(description);
1002       dummyProv->setAppendToDataLabel(ps);
1003       provider.add(dummyProv);
1004     }
1005     std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
1006     dummyFinder->setInterval(
1007         edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 1)), edm::IOVSyncValue(edm::EventID(1, 1, 3))));
1008     provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
1009 
1010     controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1)));
1011 
1012     edm::ESParentContext parentC;
1013     {
1014       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"", "blah"}};
1015       consumer.updateLookup(provider.recordsToResolverIndices());
1016       consumer.prefetch(provider.eventSetupImpl());
1017       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1018                                        static_cast<unsigned int>(edm::Transition::Event),
1019                                        consumer.esGetTokenIndices(edm::Transition::Event),
1020                                        parentC};
1021       edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
1022       CPPUNIT_ASSERT(kGood.value_ == data->value_);
1023       const edm::eventsetup::ComponentDescription* desc = data.description();
1024       CPPUNIT_ASSERT(desc->label_ == "testTwo");
1025     }
1026     {
1027       DummyDataConsumer<DummyRecord> consumer{edm::ESInputTag{"", ""}};
1028       consumer.updateLookup(provider.recordsToResolverIndices());
1029       consumer.prefetch(provider.eventSetupImpl());
1030       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1031                                        static_cast<unsigned int>(edm::Transition::Event),
1032                                        consumer.esGetTokenIndices(edm::Transition::Event),
1033                                        parentC};
1034       edm::ESHandle<DummyData> data = eventSetup.getHandle(consumer.m_token);
1035       CPPUNIT_ASSERT(kBad.value_ == data->value_);
1036       const edm::eventsetup::ComponentDescription* desc = data.description();
1037       CPPUNIT_ASSERT(desc->label_ == "testOne");
1038     }
1039     {
1040       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"", "blah"}};
1041       consumer.updateLookup(provider.recordsToResolverIndices());
1042       consumer.prefetch(provider.eventSetupImpl());
1043       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1044                                        static_cast<unsigned int>(edm::Transition::Event),
1045                                        consumer.esGetTokenIndices(edm::Transition::Event),
1046                                        parentC};
1047       auto const& depRecord = eventSetup.get<DepRecord>();
1048 
1049       edm::ESHandle<DummyData> data = depRecord.getHandle(consumer.m_token);
1050       CPPUNIT_ASSERT(kGood.value_ == data->value_);
1051       const edm::eventsetup::ComponentDescription* desc = data.description();
1052       CPPUNIT_ASSERT(desc->label_ == "testTwo");
1053     }
1054     {
1055       DummyDataConsumer<DummyRecord> consumer{edm::ESInputTag{"", ""}};
1056       consumer.updateLookup(provider.recordsToResolverIndices());
1057       consumer.prefetch(provider.eventSetupImpl());
1058       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1059                                        static_cast<unsigned int>(edm::Transition::Event),
1060                                        consumer.esGetTokenIndices(edm::Transition::Event),
1061                                        parentC};
1062       auto const& depRecord = eventSetup.get<DepRecord>();
1063 
1064       edm::ESHandle<DummyData> data = depRecord.getHandle(consumer.m_token);
1065       CPPUNIT_ASSERT(kBad.value_ == data->value_);
1066       const edm::eventsetup::ComponentDescription* desc = data.description();
1067       CPPUNIT_ASSERT(desc->label_ == "testOne");
1068     }
1069     {
1070       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"", "blah"}};
1071       consumer.updateLookup(provider.recordsToResolverIndices());
1072       consumer.prefetch(provider.eventSetupImpl());
1073       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1074                                        static_cast<unsigned int>(edm::Transition::Event),
1075                                        consumer.esGetTokenIndices(edm::Transition::Event),
1076                                        parentC};
1077       auto const& depRecord = eventSetup.get<DepRecord>();
1078 
1079       edm::ESHandle<DummyData> data = depRecord.getHandle(consumer.m_token);
1080       CPPUNIT_ASSERT(kGood.value_ == data->value_);
1081       const edm::eventsetup::ComponentDescription* desc = data.description();
1082       CPPUNIT_ASSERT(desc->label_ == "testTwo");
1083     }
1084     {
1085       DummyDataConsumer2<DummyRecord, DepRecord> consumer{edm::ESInputTag{"", ""}, edm::ESInputTag{"", "blah"}};
1086       consumer.updateLookup(provider.recordsToResolverIndices());
1087       consumer.prefetch(provider.eventSetupImpl());
1088       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1089                                        static_cast<unsigned int>(edm::Transition::Event),
1090                                        consumer.esGetTokenIndices(edm::Transition::Event),
1091                                        parentC};
1092       auto const& depRecord = eventSetup.get<DepRecord>();
1093 
1094       edm::ESHandle<DummyData> data1 = depRecord.getHandle(consumer.m_token1);
1095       CPPUNIT_ASSERT(kBad.value_ == data1->value_);
1096       const edm::eventsetup::ComponentDescription* desc = data1.description();
1097       CPPUNIT_ASSERT(desc->label_ == "testOne");
1098 
1099       edm::ESHandle<DummyData> data2 = depRecord.getHandle(consumer.m_token2);
1100       CPPUNIT_ASSERT(kGood.value_ == data2->value_);
1101       desc = data2.description();
1102       CPPUNIT_ASSERT(desc->label_ == "testTwo");
1103     }
1104     {
1105       DummyDataConsumer<DummyRecord> consumer{edm::ESInputTag{"DoesNotExist", ""}};
1106       consumer.updateLookup(provider.recordsToResolverIndices());
1107       consumer.prefetch(provider.eventSetupImpl());
1108       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1109                                        static_cast<unsigned int>(edm::Transition::Event),
1110                                        consumer.esGetTokenIndices(edm::Transition::Event),
1111                                        parentC};
1112       auto const& depRecord = eventSetup.get<DepRecord>();
1113 
1114       CPPUNIT_ASSERT(not depRecord.getHandle(consumer.m_token));
1115       CPPUNIT_ASSERT_THROW(*depRecord.getHandle(consumer.m_token), cms::Exception);
1116     }
1117     {
1118       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"DoesNotExist", "blah"}};
1119       consumer.updateLookup(provider.recordsToResolverIndices());
1120       consumer.prefetch(provider.eventSetupImpl());
1121       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1122                                        static_cast<unsigned int>(edm::Transition::Event),
1123                                        consumer.esGetTokenIndices(edm::Transition::Event),
1124                                        parentC};
1125       auto const& depRecord = eventSetup.get<DepRecord>();
1126 
1127       CPPUNIT_ASSERT(not depRecord.getHandle(consumer.m_token));
1128       CPPUNIT_ASSERT_THROW(*depRecord.getHandle(consumer.m_token), cms::Exception);
1129     }
1130   } catch (const cms::Exception& iException) {
1131     std::cout << "caught " << iException.explainSelf() << std::endl;
1132     throw;
1133   }
1134 }
1135 
1136 void testdependentrecord::getTransientHandleWithESGetTokenTest() {
1137   using edm::eventsetup::test::DummyData;
1138   using edm::eventsetup::test::DummyESProductResolverProvider;
1139   DummyData kGood{1};
1140   DummyData kBad{0};
1141 
1142   SynchronousEventSetupsController controller;
1143   edm::ParameterSet pset = createDummyPset();
1144   EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1145 
1146   try {
1147     {
1148       edm::eventsetup::ComponentDescription description("DummyESProductResolverProvider", "testOne", 0, true);
1149       edm::ParameterSet ps;
1150       ps.addParameter<std::string>("name", "test11");
1151       ps.registerIt();
1152       description.pid_ = ps.id();
1153       auto dummyProv = std::make_shared<DummyESProductResolverProvider>(kBad);
1154       dummyProv->setDescription(description);
1155       provider.add(dummyProv);
1156     }
1157     {
1158       edm::eventsetup::ComponentDescription description("DepRecordResolverProviderWithData", "testTwo", 1, true);
1159       edm::ParameterSet ps;
1160       ps.addParameter<std::string>("name", "test22");
1161       ps.addParameter<std::string>("appendToDataLabel", "blah");
1162       ps.registerIt();
1163       description.pid_ = ps.id();
1164       auto dummyProv = std::make_shared<DepRecordResolverProviderWithData>(kGood);
1165       dummyProv->setDescription(description);
1166       dummyProv->setAppendToDataLabel(ps);
1167       provider.add(dummyProv);
1168     }
1169     std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
1170     dummyFinder->setInterval(
1171         edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 1)), edm::IOVSyncValue(edm::EventID(1, 1, 3))));
1172     provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
1173 
1174     controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1)));
1175     edm::ESParentContext parentC;
1176     {
1177       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"", "blah"}};
1178       consumer.updateLookup(provider.recordsToResolverIndices());
1179       consumer.prefetch(provider.eventSetupImpl());
1180       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1181                                        static_cast<unsigned int>(edm::Transition::Event),
1182                                        consumer.esGetTokenIndices(edm::Transition::Event),
1183                                        parentC};
1184       edm::ESTransientHandle<DummyData> data = eventSetup.getTransientHandle(consumer.m_token);
1185       CPPUNIT_ASSERT(kGood.value_ == data->value_);
1186       const edm::eventsetup::ComponentDescription* desc = data.description();
1187       CPPUNIT_ASSERT(desc->label_ == "testTwo");
1188     }
1189     {
1190       DummyDataConsumer<DummyRecord> consumer{edm::ESInputTag{"", ""}};
1191       consumer.updateLookup(provider.recordsToResolverIndices());
1192       consumer.prefetch(provider.eventSetupImpl());
1193       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1194                                        static_cast<unsigned int>(edm::Transition::Event),
1195                                        consumer.esGetTokenIndices(edm::Transition::Event),
1196                                        parentC};
1197       edm::ESTransientHandle<DummyData> data = eventSetup.getTransientHandle(consumer.m_token);
1198       CPPUNIT_ASSERT(kBad.value_ == data->value_);
1199       const edm::eventsetup::ComponentDescription* desc = data.description();
1200       CPPUNIT_ASSERT(desc->label_ == "testOne");
1201     }
1202     {
1203       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"", "blah"}};
1204       consumer.updateLookup(provider.recordsToResolverIndices());
1205       consumer.prefetch(provider.eventSetupImpl());
1206       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1207                                        static_cast<unsigned int>(edm::Transition::Event),
1208                                        consumer.esGetTokenIndices(edm::Transition::Event),
1209                                        parentC};
1210       auto const& depRecord = eventSetup.get<DepRecord>();
1211 
1212       edm::ESTransientHandle<DummyData> data = depRecord.getTransientHandle(consumer.m_token);
1213       CPPUNIT_ASSERT(kGood.value_ == data->value_);
1214       const edm::eventsetup::ComponentDescription* desc = data.description();
1215       CPPUNIT_ASSERT(desc->label_ == "testTwo");
1216     }
1217     {
1218       DummyDataConsumer<DummyRecord> consumer{edm::ESInputTag{"", ""}};
1219       consumer.updateLookup(provider.recordsToResolverIndices());
1220       consumer.prefetch(provider.eventSetupImpl());
1221       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1222                                        static_cast<unsigned int>(edm::Transition::Event),
1223                                        consumer.esGetTokenIndices(edm::Transition::Event),
1224                                        parentC};
1225       auto const& depRecord = eventSetup.get<DepRecord>();
1226 
1227       edm::ESTransientHandle<DummyData> data = depRecord.getTransientHandle(consumer.m_token);
1228       CPPUNIT_ASSERT(kBad.value_ == data->value_);
1229       const edm::eventsetup::ComponentDescription* desc = data.description();
1230       CPPUNIT_ASSERT(desc->label_ == "testOne");
1231     }
1232     {
1233       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"", "blah"}};
1234       consumer.updateLookup(provider.recordsToResolverIndices());
1235       consumer.prefetch(provider.eventSetupImpl());
1236       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1237                                        static_cast<unsigned int>(edm::Transition::Event),
1238                                        consumer.esGetTokenIndices(edm::Transition::Event),
1239                                        parentC};
1240       auto const& depRecord = eventSetup.get<DepRecord>();
1241 
1242       edm::ESTransientHandle<DummyData> data = depRecord.getTransientHandle(consumer.m_token);
1243       CPPUNIT_ASSERT(kGood.value_ == data->value_);
1244       const edm::eventsetup::ComponentDescription* desc = data.description();
1245       CPPUNIT_ASSERT(desc->label_ == "testTwo");
1246     }
1247     {
1248       DummyDataConsumer2<DummyRecord, DepRecord> consumer{edm::ESInputTag{"", ""}, edm::ESInputTag{"", "blah"}};
1249       consumer.updateLookup(provider.recordsToResolverIndices());
1250       consumer.prefetch(provider.eventSetupImpl());
1251       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1252                                        static_cast<unsigned int>(edm::Transition::Event),
1253                                        consumer.esGetTokenIndices(edm::Transition::Event),
1254                                        parentC};
1255       auto const& depRecord = eventSetup.get<DepRecord>();
1256 
1257       edm::ESTransientHandle<DummyData> data1 = depRecord.getTransientHandle(consumer.m_token1);
1258       CPPUNIT_ASSERT(kBad.value_ == data1->value_);
1259       const edm::eventsetup::ComponentDescription* desc = data1.description();
1260       CPPUNIT_ASSERT(desc->label_ == "testOne");
1261 
1262       edm::ESTransientHandle<DummyData> data2 = depRecord.getTransientHandle(consumer.m_token2);
1263       CPPUNIT_ASSERT(kGood.value_ == data2->value_);
1264       desc = data2.description();
1265       CPPUNIT_ASSERT(desc->label_ == "testTwo");
1266     }
1267     {
1268       DummyDataConsumer<DummyRecord> consumer{edm::ESInputTag{"DoesNotExist", ""}};
1269       consumer.updateLookup(provider.recordsToResolverIndices());
1270       consumer.prefetch(provider.eventSetupImpl());
1271       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1272                                        static_cast<unsigned int>(edm::Transition::Event),
1273                                        consumer.esGetTokenIndices(edm::Transition::Event),
1274                                        parentC};
1275       auto const& depRecord = eventSetup.get<DepRecord>();
1276 
1277       edm::ESTransientHandle<DummyData> data = depRecord.getTransientHandle(consumer.m_token);
1278       CPPUNIT_ASSERT(not data);
1279       CPPUNIT_ASSERT_THROW(*data, cms::Exception);
1280     }
1281     {
1282       DummyDataConsumer<DepRecord> consumer{edm::ESInputTag{"DoesNotExist", "blah"}};
1283       consumer.updateLookup(provider.recordsToResolverIndices());
1284       consumer.prefetch(provider.eventSetupImpl());
1285       const edm::EventSetup eventSetup{provider.eventSetupImpl(),
1286                                        static_cast<unsigned int>(edm::Transition::Event),
1287                                        consumer.esGetTokenIndices(edm::Transition::Event),
1288                                        parentC};
1289       auto const& depRecord = eventSetup.get<DepRecord>();
1290 
1291       edm::ESTransientHandle<DummyData> data = depRecord.getTransientHandle(consumer.m_token);
1292       CPPUNIT_ASSERT(not data);
1293       CPPUNIT_ASSERT_THROW(*data, cms::Exception);
1294     }
1295   } catch (const cms::Exception& iException) {
1296     std::cout << "caught " << iException.explainSelf() << std::endl;
1297     throw;
1298   }
1299 }
1300 
1301 void testdependentrecord::oneOfTwoRecordTest() {
1302   SynchronousEventSetupsController controller;
1303   edm::ParameterSet pset = createDummyPset();
1304   EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1305 
1306   std::shared_ptr<edm::eventsetup::ESProductResolverProvider> dummyProv =
1307       std::make_shared<DummyESProductResolverProvider>();
1308   provider.add(dummyProv);
1309 
1310   std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
1311   dummyFinder->setInterval(
1312       edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 1)), edm::IOVSyncValue(edm::EventID(1, 1, 3))));
1313   provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
1314 
1315   std::shared_ptr<edm::eventsetup::ESProductResolverProvider> depProv =
1316       std::make_shared<DepOn2RecordResolverProvider>();
1317   provider.add(depProv);
1318   {
1319     edm::ESParentContext parentC;
1320     controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1)));
1321     const edm::EventSetup eventSetup1(provider.eventSetupImpl(), 0, nullptr, parentC);
1322     const DepOn2Record& depRecord = eventSetup1.get<DepOn2Record>();
1323 
1324     depRecord.getRecord<DummyRecord>();
1325     CPPUNIT_ASSERT_THROW(depRecord.getRecord<Dummy2Record>(), edm::eventsetup::NoRecordException<Dummy2Record>);
1326 
1327     try {
1328       depRecord.getRecord<Dummy2Record>();
1329     } catch (edm::eventsetup::NoRecordException<Dummy2Record>& e) {
1330       //make sure that the record name appears in the error message.
1331       CPPUNIT_ASSERT(0 != strstr(e.what(), "DepOn2Record"));
1332       CPPUNIT_ASSERT(0 != strstr(e.what(), "Dummy2Record"));
1333       // std::cout<<e.what()<<std::endl;
1334     }
1335   }
1336 }
1337 
1338 void testdependentrecord::resetTest() {
1339   SynchronousEventSetupsController controller;
1340   edm::ParameterSet pset = createDummyPset();
1341   EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1342 
1343   std::shared_ptr<edm::eventsetup::ESProductResolverProvider> dummyProv =
1344       std::make_shared<DummyESProductResolverProvider>();
1345   provider.add(dummyProv);
1346 
1347   std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
1348   dummyFinder->setInterval(
1349       edm::ValidityInterval(edm::IOVSyncValue(edm::EventID(1, 1, 1)), edm::IOVSyncValue(edm::EventID(1, 1, 3))));
1350   provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummyFinder));
1351 
1352   std::shared_ptr<edm::eventsetup::ESProductResolverProvider> depProv = std::make_shared<DepRecordResolverProvider>();
1353   provider.add(depProv);
1354   {
1355     edm::ESParentContext parentC;
1356     controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1)));
1357     const edm::EventSetup eventSetup1(provider.eventSetupImpl(), 0, nullptr, parentC);
1358     const DepRecord& depRecord = eventSetup1.get<DepRecord>();
1359     unsigned long long depCacheID = depRecord.cacheIdentifier();
1360     const DummyRecord& dummyRecord = depRecord.getRecord<DummyRecord>();
1361     unsigned long long dummyCacheID = dummyRecord.cacheIdentifier();
1362 
1363     provider.resetRecordPlusDependentRecords(dummyRecord.key());
1364     controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1)));
1365     CPPUNIT_ASSERT(dummyCacheID != dummyRecord.cacheIdentifier());
1366     CPPUNIT_ASSERT(depCacheID != depRecord.cacheIdentifier());
1367   }
1368 }
1369 
1370 void testdependentrecord::alternateFinderTest() {
1371   auto dummyProvider = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
1372 
1373   const edm::EventID eID_1(1, 1, 1);
1374   const edm::IOVSyncValue sync_1(eID_1);
1375   const edm::EventID eID_3(1, 1, 3);
1376   const edm::IOVSyncValue sync_3(eID_3);
1377   const edm::EventID eID_4(1, 1, 4);
1378   const edm::ValidityInterval definedInterval(sync_1, edm::IOVSyncValue(eID_4));
1379   std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
1380   dummyFinder->setInterval(definedInterval);
1381   dummyProvider->addFinder(dummyFinder);
1382 
1383   std::shared_ptr<DepRecordFinder> depFinder = std::make_shared<DepRecordFinder>();
1384   const edm::EventID eID_2(1, 1, 2);
1385   const edm::IOVSyncValue sync_2(eID_2);
1386   const edm::ValidityInterval depInterval(sync_1, sync_2);
1387   depFinder->setInterval(depInterval);
1388 
1389   const EventSetupRecordKey depRecordKey = DepRecord::keyForClass();
1390   DependentRecordIntervalFinder finder(depRecordKey);
1391   finder.setAlternateFinder(depFinder);
1392   finder.addProviderWeAreDependentOn(dummyProvider);
1393 
1394   CPPUNIT_ASSERT(depInterval == finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 1))));
1395 
1396   const edm::ValidityInterval dep2Interval(sync_3, edm::IOVSyncValue(eID_4));
1397   depFinder->setInterval(dep2Interval);
1398 
1399   /*const edm::ValidityInterval tempIOV = */
1400   finder.findIntervalFor(depRecordKey, sync_3);
1401   //std::cout <<  tempIOV.first().eventID()<<" to "<<tempIOV.last().eventID() <<std::endl;
1402   CPPUNIT_ASSERT(dep2Interval == finder.findIntervalFor(depRecordKey, sync_3));
1403 
1404   dummyFinder->setInterval(edm::ValidityInterval::invalidInterval());
1405   depFinder->setInterval(edm::ValidityInterval::invalidInterval());
1406 
1407   dummyProvider->initializeForNewSyncValue();
1408   CPPUNIT_ASSERT(edm::ValidityInterval::invalidInterval() ==
1409                  finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 5))));
1410 
1411   const edm::EventID eID_6(1, 1, 6);
1412   const edm::IOVSyncValue sync_6(eID_6);
1413   const edm::ValidityInterval unknownedEndInterval(sync_6, edm::IOVSyncValue::invalidIOVSyncValue());
1414   dummyFinder->setInterval(unknownedEndInterval);
1415 
1416   const edm::EventID eID_7(1, 1, 7);
1417   const edm::IOVSyncValue sync_7(eID_7);
1418   const edm::ValidityInterval iov6_7(sync_6, sync_7);
1419   depFinder->setInterval(iov6_7);
1420 
1421   dummyProvider->initializeForNewSyncValue();
1422   CPPUNIT_ASSERT(unknownedEndInterval == finder.findIntervalFor(depRecordKey, sync_6));
1423 
1424   //see if dependent record can override the finder
1425   dummyFinder->setInterval(depInterval);
1426   depFinder->setInterval(definedInterval);
1427   dummyProvider->initializeForNewSyncValue();
1428   CPPUNIT_ASSERT(depInterval == finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 1))));
1429 
1430   dummyFinder->setInterval(dep2Interval);
1431   dummyProvider->initializeForNewSyncValue();
1432   CPPUNIT_ASSERT(dep2Interval == finder.findIntervalFor(depRecordKey, sync_3));
1433 }
1434 
1435 void testdependentrecord::invalidRecordTest() {
1436   auto dummyProvider1 = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
1437 
1438   const edm::ValidityInterval invalid(edm::IOVSyncValue::invalidIOVSyncValue(),
1439                                       edm::IOVSyncValue::invalidIOVSyncValue());
1440 
1441   dummyProvider1->setValidityInterval_forTesting(invalid);
1442 
1443   auto dummyProvider2 = std::make_shared<EventSetupRecordProvider>(DummyRecord::keyForClass(), &activityRegistry);
1444   dummyProvider2->setValidityInterval_forTesting(invalid);
1445 
1446   const EventSetupRecordKey depRecordKey = DepRecord::keyForClass();
1447   DependentRecordIntervalFinder finder(depRecordKey);
1448   finder.addProviderWeAreDependentOn(dummyProvider1);
1449   finder.addProviderWeAreDependentOn(dummyProvider2);
1450 
1451   CPPUNIT_ASSERT(invalid == finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 2))));
1452 
1453   const edm::EventID eID_1(1, 1, 5);
1454   const edm::IOVSyncValue sync_1(eID_1);
1455   const edm::ValidityInterval definedInterval1(sync_1, edm::IOVSyncValue(edm::EventID(1, 1, 10)));
1456   const edm::EventID eID_2(1, 1, 2);
1457   const edm::IOVSyncValue sync_2(eID_2);
1458   const edm::ValidityInterval definedInterval2(sync_2, edm::IOVSyncValue(edm::EventID(1, 1, 6)));
1459   dummyProvider2->setValidityInterval_forTesting(definedInterval2);
1460 
1461   const edm::ValidityInterval openEnded1(definedInterval2.first(), edm::IOVSyncValue::invalidIOVSyncValue());
1462 
1463   dummyProvider1->initializeForNewSyncValue();
1464   dummyProvider2->initializeForNewSyncValue();
1465   CPPUNIT_ASSERT(openEnded1 == finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 4))));
1466 
1467   dummyProvider1->setValidityInterval_forTesting(definedInterval1);
1468 
1469   const edm::ValidityInterval overlapInterval(std::max(definedInterval1.first(), definedInterval2.first()),
1470                                               std::min(definedInterval1.last(), definedInterval2.last()));
1471 
1472   dummyProvider1->initializeForNewSyncValue();
1473   dummyProvider2->initializeForNewSyncValue();
1474   CPPUNIT_ASSERT(overlapInterval == finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 5))));
1475 
1476   dummyProvider2->setValidityInterval_forTesting(invalid);
1477   const edm::ValidityInterval openEnded2(definedInterval1.first(), edm::IOVSyncValue::invalidIOVSyncValue());
1478 
1479   dummyProvider1->initializeForNewSyncValue();
1480   dummyProvider2->initializeForNewSyncValue();
1481   CPPUNIT_ASSERT(openEnded2 == finder.findIntervalFor(depRecordKey, edm::IOVSyncValue(edm::EventID(1, 1, 7))));
1482 }
1483 
1484 void testdependentrecord::extendIOVTest() {
1485   SynchronousEventSetupsController controller;
1486   edm::ParameterSet pset = createDummyPset();
1487   EventSetupProvider& provider = *controller.makeProvider(pset, &activityRegistry);
1488 
1489   std::shared_ptr<edm::eventsetup::ESProductResolverProvider> dummyProv =
1490       std::make_shared<DummyESProductResolverProvider>();
1491   provider.add(dummyProv);
1492 
1493   std::shared_ptr<DummyFinder> dummyFinder = std::make_shared<DummyFinder>();
1494 
1495   edm::IOVSyncValue startSyncValue{edm::EventID{1, 1, 1}};
1496   dummyFinder->setInterval(edm::ValidityInterval{startSyncValue, edm::IOVSyncValue{edm::EventID{1, 1, 5}}});
1497   provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>{dummyFinder});
1498 
1499   std::shared_ptr<edm::eventsetup::ESProductResolverProvider> depProv =
1500       std::make_shared<DepOn2RecordResolverProvider>();
1501   provider.add(depProv);
1502 
1503   edm::ESParentContext parentC;
1504   std::shared_ptr<Dummy2RecordFinder> dummy2Finder = std::make_shared<Dummy2RecordFinder>();
1505   dummy2Finder->setInterval(edm::ValidityInterval{startSyncValue, edm::IOVSyncValue{edm::EventID{1, 1, 6}}});
1506   provider.add(std::shared_ptr<edm::EventSetupRecordIntervalFinder>(dummy2Finder));
1507   {
1508     controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 1), edm::Timestamp(1)));
1509     const edm::EventSetup eventSetup1(provider.eventSetupImpl(), 0, nullptr, parentC);
1510     unsigned long long id1 = eventSetup1.get<DepOn2Record>().cacheIdentifier();
1511     CPPUNIT_ASSERT(id1 == eventSetup1.get<DummyRecord>().cacheIdentifier());
1512     CPPUNIT_ASSERT(id1 == eventSetup1.get<Dummy2Record>().cacheIdentifier());
1513 
1514     {
1515       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 5), edm::Timestamp(2)));
1516       const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, parentC);
1517       unsigned long long id = eventSetup.get<DepOn2Record>().cacheIdentifier();
1518       CPPUNIT_ASSERT(id1 == id);
1519       CPPUNIT_ASSERT(id1 == eventSetup.get<DummyRecord>().cacheIdentifier());
1520       CPPUNIT_ASSERT(id1 == eventSetup.get<Dummy2Record>().cacheIdentifier());
1521     }
1522     //extend the IOV DummyRecord while Dummy2Record still covers this range
1523     dummyFinder->setInterval(edm::ValidityInterval{startSyncValue, edm::IOVSyncValue{edm::EventID{1, 1, 7}}});
1524     {
1525       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 6), edm::Timestamp(7)));
1526       const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, parentC);
1527       unsigned long long id = eventSetup.get<DepOn2Record>().cacheIdentifier();
1528       CPPUNIT_ASSERT(id1 == id);
1529       CPPUNIT_ASSERT(id1 == eventSetup.get<DummyRecord>().cacheIdentifier());
1530       CPPUNIT_ASSERT(id1 == eventSetup.get<Dummy2Record>().cacheIdentifier());
1531     }
1532 
1533     //extend the IOV Dummy2Record while DummyRecord still covers this range
1534     dummy2Finder->setInterval(edm::ValidityInterval{startSyncValue, edm::IOVSyncValue{edm::EventID{1, 1, 7}}});
1535 
1536     {
1537       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 7), edm::Timestamp(7)));
1538       const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, parentC);
1539       unsigned long long id = eventSetup.get<DepOn2Record>().cacheIdentifier();
1540       CPPUNIT_ASSERT(id1 == id);
1541       CPPUNIT_ASSERT(id1 == eventSetup.get<DummyRecord>().cacheIdentifier());
1542       CPPUNIT_ASSERT(id1 == eventSetup.get<Dummy2Record>().cacheIdentifier());
1543     }
1544     //extend the both IOVs
1545     dummy2Finder->setInterval(edm::ValidityInterval{startSyncValue, edm::IOVSyncValue{edm::EventID{1, 1, 8}}});
1546 
1547     dummyFinder->setInterval(edm::ValidityInterval{startSyncValue, edm::IOVSyncValue{edm::EventID{1, 1, 8}}});
1548     {
1549       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 8), edm::Timestamp(7)));
1550       const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, parentC);
1551       unsigned long long id = eventSetup.get<DepOn2Record>().cacheIdentifier();
1552       CPPUNIT_ASSERT(id1 == id);
1553       CPPUNIT_ASSERT(id1 == eventSetup.get<DummyRecord>().cacheIdentifier());
1554       CPPUNIT_ASSERT(id1 == eventSetup.get<Dummy2Record>().cacheIdentifier());
1555     }
1556     //extend only one and create a new IOV for the other
1557     dummy2Finder->setInterval(edm::ValidityInterval{startSyncValue, edm::IOVSyncValue{edm::EventID{1, 1, 9}}});
1558 
1559     dummyFinder->setInterval(
1560         edm::ValidityInterval{edm::IOVSyncValue{edm::EventID{1, 1, 9}}, edm::IOVSyncValue{edm::EventID{1, 1, 9}}});
1561     {
1562       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 9), edm::Timestamp(7)));
1563       const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, parentC);
1564       unsigned long long id = eventSetup.get<DepOn2Record>().cacheIdentifier();
1565       CPPUNIT_ASSERT(id1 + 1 == id);
1566       CPPUNIT_ASSERT(id1 + 1 == eventSetup.get<DummyRecord>().cacheIdentifier());
1567       CPPUNIT_ASSERT(id1 == eventSetup.get<Dummy2Record>().cacheIdentifier());
1568     }
1569     //extend the otherone and create a new IOV for the other
1570     dummy2Finder->setInterval(
1571         edm::ValidityInterval{edm::IOVSyncValue{edm::EventID{1, 1, 10}}, edm::IOVSyncValue{edm::EventID{1, 1, 10}}});
1572 
1573     dummyFinder->setInterval(
1574         edm::ValidityInterval{edm::IOVSyncValue{edm::EventID{1, 1, 9}}, edm::IOVSyncValue{edm::EventID{1, 1, 10}}});
1575 
1576     {
1577       controller.eventSetupForInstance(edm::IOVSyncValue(edm::EventID(1, 1, 10), edm::Timestamp(7)));
1578       const edm::EventSetup eventSetup(provider.eventSetupImpl(), 0, nullptr, parentC);
1579       unsigned long long id = eventSetup.get<DepOn2Record>().cacheIdentifier();
1580       CPPUNIT_ASSERT(id1 + 2 == id);
1581       CPPUNIT_ASSERT(id1 + 1 == eventSetup.get<DummyRecord>().cacheIdentifier());
1582       CPPUNIT_ASSERT(id1 + 1 == eventSetup.get<Dummy2Record>().cacheIdentifier());
1583     }
1584   }
1585 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!