Framework/test/test_catch2notTP_MergeableRunProductMetadata.cc

0001 #include "catch.hpp"
0002
0003 #include "DataFormats/Provenance/interface/ProductDescription.h"
0004 #include "DataFormats/Provenance/interface/IndexIntoFile.h"
0005 #include "DataFormats/Provenance/interface/ParameterSetID.h"
0006 #include "DataFormats/Provenance/interface/ParameterSetID.h"
0007 #include "DataFormats/Provenance/interface/ProcessConfiguration.h"
0008 #include "DataFormats/Provenance/interface/ProcessHistory.h"
0009 #include "DataFormats/Provenance/interface/ProcessHistoryID.h"
0010 #include "DataFormats/Provenance/interface/ProductRegistry.h"
0011 #include "DataFormats/Provenance/interface/RunLumiEventNumber.h"
0012 #include "DataFormats/Provenance/interface/StoredMergeableRunProductMetadata.h"
0013 #include "DataFormats/TestObjects/interface/Thing.h"
0014 #include "DataFormats/TestObjects/interface/ThingWithMerge.h"
0015 #include "FWCore/Framework/interface/MergeableRunProductMetadata.h"
0016 #include "FWCore/Framework/interface/MergeableRunProductProcesses.h"
0017 #include "FWCore/Framework/interface/SignallingProductRegistryFiller.h"
0018 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0019 #include "FWCore/Utilities/interface/BranchType.h"
0020 #include "FWCore/Reflection/interface/TypeWithDict.h"
0021
0022 #include <memory>
0023 #include <string>
0024 #include <vector>
0025
0026 TEST_CASE("test MergeableRunProductMetadata", "[MergeableRunProductMetadata]") {
0027   SECTION("test nested class MetadataForProcess") {
0028     edm::MergeableRunProductMetadata::MetadataForProcess metaDataForProcess;
0029     REQUIRE(metaDataForProcess.lumis().empty());
0030     REQUIRE(metaDataForProcess.valid());
0031     REQUIRE(!metaDataForProcess.useIndexIntoFile());
0032     REQUIRE(!metaDataForProcess.allLumisProcessed());
0033     REQUIRE(metaDataForProcess.mergeDecision() == edm::MergeableRunProductMetadata::MERGE);
0034
0035     std::vector<edm::LuminosityBlockNumber_t>& lumis = metaDataForProcess.lumis();
0036     lumis.push_back(11);
0037     edm::MergeableRunProductMetadata::MetadataForProcess const& acref(metaDataForProcess);
0038     REQUIRE(acref.lumis().at(0) == 11);
0039
0040     metaDataForProcess.setMergeDecision(edm::MergeableRunProductMetadata::IGNORE);
0041     metaDataForProcess.setValid(false);
0042     metaDataForProcess.setUseIndexIntoFile(true);
0043     metaDataForProcess.setAllLumisProcessed(true);
0044
0045     REQUIRE(!metaDataForProcess.valid());
0046     REQUIRE(metaDataForProcess.useIndexIntoFile());
0047     REQUIRE(metaDataForProcess.allLumisProcessed());
0048     REQUIRE(metaDataForProcess.mergeDecision() == edm::MergeableRunProductMetadata::IGNORE);
0049
0050     metaDataForProcess.reset();
0051     REQUIRE(metaDataForProcess.lumis().empty());
0052     REQUIRE(metaDataForProcess.valid());
0053     REQUIRE(!metaDataForProcess.useIndexIntoFile());
0054     REQUIRE(!metaDataForProcess.allLumisProcessed());
0055     REQUIRE(metaDataForProcess.mergeDecision() == edm::MergeableRunProductMetadata::MERGE);
0056   }
0057
0058   SECTION("test constructor") {
0059     // edm::MergeableRunProductMetadata mergeableRunProductMetadata(nullptr);
0060     // REQUIRE(mergeableRunProductMetadata.metadataForProcesses().empty());
0061
0062     edm::MergeableRunProductProcesses mergeableRunProductProcesses;
0063     edm::MergeableRunProductMetadata mergeableRunProductMetadata2(mergeableRunProductProcesses);
0064     REQUIRE(mergeableRunProductMetadata2.metadataForProcesses().empty());
0065   }
0066
0067   SECTION("test main functions") {
0068     edm::SignallingProductRegistryFiller productRegistry;
0069
0070     {
0071       edm::ProductRegistry inputRegistry;
0072       // not mergeable
0073       edm::ProductDescription prod1(edm::InRun,
0074                                     "label",
0075                                     "PROD",
0076                                     "edmtest::Thing",
0077                                     "edmtestThing",
0078                                     "instance",
0079                                     edm::TypeWithDict::byName("edmtest::Thing"),
0080                                     false);
0081       inputRegistry.copyProduct(prod1);
0082
0083       // This one should be used
0084       edm::ProductDescription prod2(edm::InRun,
0085                                     "aLabel",
0086                                     "APROD",
0087                                     "edmtest::ThingWithMerge",
0088                                     "edmtestThingWithMerge",
0089                                     "instance",
0090                                     edm::TypeWithDict::byName("edmtest::ThingWithMerge"),
0091                                     false);
0092       inputRegistry.copyProduct(prod2);
0093
0094       //not in a Run
0095       edm::ProductDescription prod3(edm::InLumi,
0096                                     "bLabel",
0097                                     "BPROD",
0098                                     "edmtest::ThingWithMerge",
0099                                     "edmtestThingWithMerge",
0100                                     "instance",
0101                                     edm::TypeWithDict::byName("edmtest::ThingWithMerge"),
0102                                     false);
0103       inputRegistry.copyProduct(prod3);
0104       productRegistry.addFromInput(inputRegistry);
0105     }
0106
0107     // produced
0108     edm::ProductDescription prod4(edm::InRun,
0109                                   "cLabel",
0110                                   "CPROD",
0111                                   "edmtest::ThingWithMerge",
0112                                   "edmtestThingWithMerge",
0113                                   "instance",
0114                                   edm::TypeWithDict::byName("edmtest::ThingWithMerge"),
0115                                   true);
0116     productRegistry.addProduct(prod4);
0117
0118     {
0119       edm::ProductRegistry inputRegistry;
0120       // dropped
0121       edm::ProductDescription prod5(edm::InRun,
0122                                     "dLabel",
0123                                     "DPROD",
0124                                     "edmtest::ThingWithMerge",
0125                                     "edmtestThingWithMerge",
0126                                     "instance",
0127                                     edm::TypeWithDict::byName("edmtest::ThingWithMerge"),
0128                                     false);
0129       prod5.setDropped(true);
0130       inputRegistry.copyProduct(prod5);
0131
0132       // Should be used but the same process name
0133       edm::ProductDescription prod6(edm::InRun,
0134                                     "eLabel",
0135                                     "APROD",
0136                                     "edmtest::ThingWithMerge",
0137                                     "edmtestThingWithMerge",
0138                                     "instance",
0139                                     edm::TypeWithDict::byName("edmtest::ThingWithMerge"),
0140                                     false);
0141       inputRegistry.copyProduct(prod6);
0142
0143       // Should be used
0144       edm::ProductDescription prod7(edm::InRun,
0145                                     "fLabel",
0146                                     "AAPROD",
0147                                     "edmtest::ThingWithMerge",
0148                                     "edmtestThingWithMerge",
0149                                     "instance",
0150                                     edm::TypeWithDict::byName("edmtest::ThingWithMerge"),
0151                                     false);
0152       inputRegistry.copyProduct(prod7);
0153
0154       productRegistry.addFromInput(inputRegistry);
0155     }
0156
0157     edm::MergeableRunProductProcesses mergeableRunProductProcesses;
0158
0159     REQUIRE(mergeableRunProductProcesses.size() == 0);
0160
0161     mergeableRunProductProcesses.setProcessesWithMergeableRunProducts(productRegistry.registry());
0162
0163     REQUIRE(mergeableRunProductProcesses.size() == 2);
0164
0165     {
0166       std::vector<std::string> expected{"AAPROD", "APROD"};
0167       REQUIRE(mergeableRunProductProcesses.processesWithMergeableRunProducts() == expected);
0168     }
0169     std::vector<std::string> storedProcesses{"AAAPROD", "AAPROD", "APROD", "ZPROD"};
0170     edm::StoredMergeableRunProductMetadata storedMetadata(storedProcesses);
0171     REQUIRE(storedMetadata.processesWithMergeableRunProducts() == storedProcesses);
0172     REQUIRE(storedMetadata.allValidAndUseIndexIntoFile());
0173
0174     unsigned long long iBeginProcess{100};
0175     unsigned long long iEndProcess{101};
0176     edm::StoredMergeableRunProductMetadata::SingleRunEntry singleRunEntry(iBeginProcess, iEndProcess);
0177     REQUIRE(singleRunEntry.beginProcess() == 100);
0178     REQUIRE(singleRunEntry.endProcess() == 101);
0179
0180     unsigned long long iBeginLumi{200};
0181     unsigned long long iEndLumi{201};
0182     unsigned int iProcess{202};
0183     bool iValid{true};
0184     bool iUseIndexIntoFile{false};
0185     edm::StoredMergeableRunProductMetadata::SingleRunEntryAndProcess singleRunEntryAndProcess(
0186         iBeginLumi, iEndLumi, iProcess, iValid, iUseIndexIntoFile);
0187     REQUIRE(singleRunEntryAndProcess.beginLumi() == 200);
0188     REQUIRE(singleRunEntryAndProcess.endLumi() == 201);
0189     REQUIRE(singleRunEntryAndProcess.process() == 202);
0190     REQUIRE(singleRunEntryAndProcess.valid() == true);
0191     REQUIRE(singleRunEntryAndProcess.useIndexIntoFile() == false);
0192
0193     // Fill storedMetadata with fake data
0194     // 9 run entries
0195     // Let AAPROD be not present for all run entries
0196     // Let APROD be there with a vector
0197     //              not there at all (no entries for any process)
0198     //              there invalid with no vector
0199     //              not there at all
0200     //              there with a vector and invalid
0201     // Let AAAPROD and ZPROD be there for all entries 0, 2, 3, 4
0202     {
0203       std::vector<edm::StoredMergeableRunProductMetadata::SingleRunEntry>& singleRunEntries =
0204           storedMetadata.singleRunEntries();
0205       singleRunEntries.emplace_back(0, 3);
0206       singleRunEntries.emplace_back(3, 3);
0207       singleRunEntries.emplace_back(3, 6);
0208       singleRunEntries.emplace_back(6, 8);
0209       singleRunEntries.emplace_back(8, 11);
0210       singleRunEntries.emplace_back(11, 12);
0211       singleRunEntries.emplace_back(12, 13);
0212       singleRunEntries.emplace_back(13, 14);
0213       singleRunEntries.emplace_back(14, 15);
0214
0215       std::vector<edm::StoredMergeableRunProductMetadata::SingleRunEntryAndProcess>& singleRunEntryAndProcesses =
0216           storedMetadata.singleRunEntryAndProcesses();
0217       std::vector<edm::LuminosityBlockNumber_t>& lumis = storedMetadata.lumis();
0218
0219       // arguments: beginLumi, endLumi, process Index, valid, useIndexIntoFile
0220       unsigned int iAAAPROD{0};
0221       // unsigned int iAAPROD { 1 };
0222       unsigned int iAPROD{2};
0223       unsigned int iZPROD{3};
0224
0225       // 0th run entry
0226       iBeginLumi = lumis.size();
0227       lumis.emplace_back(1);
0228       lumis.emplace_back(2);
0229       iEndLumi = lumis.size();
0230       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAAAPROD, true, false);
0231
0232       iBeginLumi = lumis.size();
0233       lumis.emplace_back(101);
0234       lumis.emplace_back(102);
0235       iEndLumi = lumis.size();
0236       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAPROD, true, false);
0237
0238       iBeginLumi = lumis.size();
0239       lumis.emplace_back(1);
0240       lumis.emplace_back(2);
0241       iEndLumi = lumis.size();
0242       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iZPROD, true, false);
0243
0244       // nothing in the 1st entry
0245
0246       // 2nd run entry
0247       iBeginLumi = lumis.size();
0248       lumis.emplace_back(1);
0249       lumis.emplace_back(2);
0250       iEndLumi = lumis.size();
0251       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAAAPROD, true, false);
0252
0253       iBeginLumi = lumis.size();
0254       iEndLumi = lumis.size();
0255       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAPROD, false, true);
0256
0257       iBeginLumi = lumis.size();
0258       lumis.emplace_back(1);
0259       lumis.emplace_back(2);
0260       iEndLumi = lumis.size();
0261       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iZPROD, true, false);
0262
0263       // 3rd run entry
0264       iBeginLumi = lumis.size();
0265       lumis.emplace_back(1);
0266       lumis.emplace_back(2);
0267       iEndLumi = lumis.size();
0268       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAAAPROD, true, false);
0269
0270       iBeginLumi = lumis.size();
0271       lumis.emplace_back(1);
0272       lumis.emplace_back(2);
0273       iEndLumi = lumis.size();
0274       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iZPROD, true, false);
0275
0276       // 4th run entry
0277       iBeginLumi = lumis.size();
0278       lumis.emplace_back(1);
0279       lumis.emplace_back(2);
0280       iEndLumi = lumis.size();
0281       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAAAPROD, true, false);
0282
0283       iBeginLumi = lumis.size();
0284       lumis.emplace_back(111);
0285       lumis.emplace_back(112);
0286       iEndLumi = lumis.size();
0287       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAPROD, false, false);
0288
0289       iBeginLumi = lumis.size();
0290       lumis.emplace_back(1);
0291       lumis.emplace_back(2);
0292       iEndLumi = lumis.size();
0293       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iZPROD, true, false);
0294
0295       // 5th entry
0296       iBeginLumi = lumis.size();
0297       lumis.emplace_back(91);
0298       lumis.emplace_back(92);
0299       iEndLumi = lumis.size();
0300       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAPROD, true, false);
0301
0302       // 6th entry
0303       iBeginLumi = lumis.size();
0304       lumis.emplace_back(121);
0305       lumis.emplace_back(122);
0306       iEndLumi = lumis.size();
0307       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAPROD, true, false);
0308
0309       // 7th entry
0310       iBeginLumi = lumis.size();
0311       lumis.emplace_back(95);
0312       lumis.emplace_back(101);
0313       lumis.emplace_back(105);
0314       iEndLumi = lumis.size();
0315       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAPROD, true, false);
0316
0317       // 8th entry
0318       iBeginLumi = lumis.size();
0319       lumis.emplace_back(1000);
0320       lumis.emplace_back(1002);
0321       lumis.emplace_back(1003);
0322       lumis.emplace_back(1004);
0323       iEndLumi = lumis.size();
0324       singleRunEntryAndProcesses.emplace_back(iBeginLumi, iEndLumi, iAPROD, true, false);
0325     }
0326
0327     storedMetadata.allValidAndUseIndexIntoFile() = false;
0328
0329     bool valid;
0330     std::vector<edm::LuminosityBlockNumber_t>::const_iterator lumisBegin;
0331     std::vector<edm::LuminosityBlockNumber_t>::const_iterator lumisEnd;
0332     REQUIRE(storedMetadata.getLumiContent(0, std::string("APROD"), valid, lumisBegin, lumisEnd));
0333     {
0334       std::vector<edm::LuminosityBlockNumber_t> test(lumisBegin, lumisEnd);
0335       std::vector<edm::LuminosityBlockNumber_t> expected{101, 102};
0336       REQUIRE(test == expected);
0337       REQUIRE(valid);
0338     }
0339     REQUIRE(!storedMetadata.getLumiContent(1, std::string("APROD"), valid, lumisBegin, lumisEnd));
0340     REQUIRE(valid);
0341     REQUIRE(!storedMetadata.getLumiContent(2, std::string("APROD"), valid, lumisBegin, lumisEnd));
0342     REQUIRE(!valid);
0343     REQUIRE(!storedMetadata.getLumiContent(3, std::string("APROD"), valid, lumisBegin, lumisEnd));
0344     REQUIRE(valid);
0345     REQUIRE(storedMetadata.getLumiContent(4, std::string("APROD"), valid, lumisBegin, lumisEnd));
0346     {
0347       std::vector<edm::LuminosityBlockNumber_t> test(lumisBegin, lumisEnd);
0348       std::vector<edm::LuminosityBlockNumber_t> expected{111, 112};
0349       REQUIRE(test == expected);
0350       REQUIRE(!valid);
0351     }
0352
0353     edm::IndexIntoFile indexIntoFile;
0354
0355     edm::ProcessHistoryID fakePHID1;
0356     edm::ProcessConfiguration pc;
0357     auto processHistory1 = std::make_unique<edm::ProcessHistory>();
0358     edm::ProcessHistory& ph1 = *processHistory1;
0359     processHistory1->push_back(pc);
0360     fakePHID1 = ph1.id();
0361
0362     edm::ProcessHistoryID fakePHID2;
0363     auto processHistory2 = std::make_unique<edm::ProcessHistory>();
0364     edm::ProcessHistory& ph2 = *processHistory2;
0365     processHistory2->push_back(pc);
0366     processHistory2->push_back(pc);
0367     fakePHID2 = ph2.id();
0368
0369     indexIntoFile.addEntry(fakePHID1, 11, 1001, 7, 0);  // Event
0370     indexIntoFile.addEntry(fakePHID1, 11, 1001, 6, 1);  // Event
0371     indexIntoFile.addEntry(fakePHID1, 11, 1001, 0, 0);  // Lumi
0372     indexIntoFile.addEntry(fakePHID1, 11, 1001, 0, 1);  // Lumi
0373     indexIntoFile.addEntry(fakePHID1, 11, 1001, 5, 2);  // Event
0374     indexIntoFile.addEntry(fakePHID1, 11, 1001, 4, 3);  // Event
0375     indexIntoFile.addEntry(fakePHID1, 11, 1001, 0, 2);  // Lumi
0376     indexIntoFile.addEntry(fakePHID1, 11, 1003, 5, 4);  // Event
0377     indexIntoFile.addEntry(fakePHID1, 11, 1003, 4, 5);  // Event
0378     indexIntoFile.addEntry(fakePHID1, 11, 1003, 0, 3);  // Lumi
0379     indexIntoFile.addEntry(fakePHID1, 11, 0, 0, 0);     // Run
0380     indexIntoFile.addEntry(fakePHID2, 11, 0, 0, 1);     // Run
0381     indexIntoFile.addEntry(fakePHID2, 11, 1001, 0, 4);  // Lumi
0382     indexIntoFile.addEntry(fakePHID2, 11, 1003, 0, 5);  // Lumi
0383     indexIntoFile.addEntry(fakePHID2, 11, 1003, 4, 6);  // Event
0384     indexIntoFile.addEntry(fakePHID2, 11, 1003, 0, 6);  // Lumi
0385     indexIntoFile.addEntry(fakePHID2, 11, 0, 0, 2);     // Run
0386     indexIntoFile.sortVector_Run_Or_Lumi_Entries();
0387     edm::IndexIntoFile::IndexIntoFileItr iter = indexIntoFile.begin(edm::IndexIntoFile::firstAppearanceOrder);
0388
0389     edm::MergeableRunProductMetadata mergeableRunProductMetadata(mergeableRunProductProcesses);
0390
0391     edm::MergeableRunProductMetadata::MetadataForProcess const* APRODMetadataForProcess =
0392         mergeableRunProductMetadata.metadataForOneProcess("APROD");
0393     REQUIRE(APRODMetadataForProcess);
0394
0395     edm::MergeableRunProductMetadata::MetadataForProcess const* NullMetadataForProcess =
0396         mergeableRunProductMetadata.metadataForOneProcess("DOESNOTEXIST");
0397     REQUIRE(NullMetadataForProcess == nullptr);
0398
0399     mergeableRunProductMetadata.readRun(0, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0400     {
0401       std::vector<edm::LuminosityBlockNumber_t> expected{101, 102};
0402       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0403       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::REPLACE);
0404       REQUIRE(mergeableRunProductMetadata.getMergeDecision("APROD") == edm::MergeableRunProductMetadata::REPLACE);
0405       REQUIRE(APRODMetadataForProcess->valid());
0406       REQUIRE(!mergeableRunProductMetadata.knownImproperlyMerged("APROD"));
0407       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0408       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0409     }
0410     // Same one again for test purposes
0411     mergeableRunProductMetadata.readRun(0, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0412     {
0413       std::vector<edm::LuminosityBlockNumber_t> expected{101, 102};
0414       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0415       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::IGNORE);
0416       REQUIRE(mergeableRunProductMetadata.getMergeDecision("APROD") == edm::MergeableRunProductMetadata::IGNORE);
0417       REQUIRE(APRODMetadataForProcess->valid());
0418       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0419       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0420     }
0421     // disjoint with newly read ones coming first
0422     mergeableRunProductMetadata.readRun(5, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0423     {
0424       std::vector<edm::LuminosityBlockNumber_t> expected{91, 92, 101, 102};
0425       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0426       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::MERGE);
0427       REQUIRE(mergeableRunProductMetadata.getMergeDecision("APROD") == edm::MergeableRunProductMetadata::MERGE);
0428       REQUIRE(APRODMetadataForProcess->valid());
0429       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0430       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0431     }
0432     // disjoint with newly read ones coming last
0433     mergeableRunProductMetadata.readRun(6, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0434     {
0435       std::vector<edm::LuminosityBlockNumber_t> expected{91, 92, 101, 102, 121, 122};
0436       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0437       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::MERGE);
0438       REQUIRE(APRODMetadataForProcess->valid());
0439       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0440       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0441     }
0442     // impossible to merge case, shared elements and both also have at least one non-shared element
0443     mergeableRunProductMetadata.readRun(7, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0444     {
0445       std::vector<edm::LuminosityBlockNumber_t> expected{91, 92, 95, 101, 102, 105, 121, 122};
0446       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0447       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::MERGE);
0448       REQUIRE(!APRODMetadataForProcess->valid());
0449       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0450       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0451     }
0452     mergeableRunProductMetadata.preReadFile();
0453     {
0454       std::vector<edm::LuminosityBlockNumber_t> expected{91, 92, 95, 101, 102, 105, 121, 122};
0455       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0456       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0457     }
0458     mergeableRunProductMetadata.readRun(3, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0459     {
0460       std::vector<edm::LuminosityBlockNumber_t> expected{91, 92, 95, 101, 102, 105, 121, 122};
0461       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0462       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::MERGE);
0463       REQUIRE(!APRODMetadataForProcess->valid());
0464       REQUIRE(APRODMetadataForProcess->useIndexIntoFile());
0465       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0466     }
0467     mergeableRunProductMetadata.preReadFile();
0468     {
0469       std::vector<edm::LuminosityBlockNumber_t> expected{91, 92, 95, 101, 102, 105, 121, 122, 1001, 1003};
0470       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0471       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0472     }
0473
0474     mergeableRunProductMetadata.postWriteRun();
0475     {
0476       std::vector<edm::LuminosityBlockNumber_t> expected;
0477       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0478       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::MERGE);
0479       REQUIRE(APRODMetadataForProcess->valid());
0480       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0481       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0482     }
0483     mergeableRunProductMetadata.readRun(0, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0484     {
0485       std::vector<edm::LuminosityBlockNumber_t> expected{101, 102};
0486       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0487       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::REPLACE);
0488       REQUIRE(APRODMetadataForProcess->valid());
0489       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0490       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0491     }
0492     mergeableRunProductMetadata.readRun(4, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0493     {
0494       std::vector<edm::LuminosityBlockNumber_t> expected{101, 102, 111, 112};
0495       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0496       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::MERGE);
0497       REQUIRE(!APRODMetadataForProcess->valid());
0498       REQUIRE(mergeableRunProductMetadata.knownImproperlyMerged("APROD"));
0499       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0500       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0501     }
0502     mergeableRunProductMetadata.preReadFile();
0503     mergeableRunProductMetadata.postWriteRun();
0504     {
0505       std::vector<edm::LuminosityBlockNumber_t> expected;
0506       REQUIRE(expected == mergeableRunProductMetadata.lumisFromIndexIntoFile());
0507       REQUIRE(!mergeableRunProductMetadata.gotLumisFromIndexIntoFile());
0508
0509       mergeableRunProductMetadata.readRun(1, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0510
0511       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0512       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::MERGE);
0513       REQUIRE(APRODMetadataForProcess->valid());
0514       REQUIRE(APRODMetadataForProcess->useIndexIntoFile());
0515       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0516
0517       expected = std::vector<edm::LuminosityBlockNumber_t>{1001, 1003};
0518       REQUIRE(expected == mergeableRunProductMetadata.lumisFromIndexIntoFile());
0519       REQUIRE(mergeableRunProductMetadata.gotLumisFromIndexIntoFile());
0520     }
0521     mergeableRunProductMetadata.preReadFile();
0522     {
0523       std::vector<edm::LuminosityBlockNumber_t> expected;
0524       REQUIRE(expected == mergeableRunProductMetadata.lumisFromIndexIntoFile());
0525       REQUIRE(!mergeableRunProductMetadata.gotLumisFromIndexIntoFile());
0526
0527       expected = std::vector<edm::LuminosityBlockNumber_t>{1001, 1003};
0528       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0529       REQUIRE(!APRODMetadataForProcess->useIndexIntoFile());
0530       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0531     }
0532
0533     mergeableRunProductMetadata.postWriteRun();
0534     {
0535       mergeableRunProductMetadata.readRun(2, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0536
0537       std::vector<edm::LuminosityBlockNumber_t> expected;
0538       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0539       REQUIRE(APRODMetadataForProcess->mergeDecision() == edm::MergeableRunProductMetadata::MERGE);
0540       REQUIRE(!APRODMetadataForProcess->valid());
0541       REQUIRE(APRODMetadataForProcess->useIndexIntoFile());
0542       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0543
0544       expected = std::vector<edm::LuminosityBlockNumber_t>{1001, 1003};
0545       REQUIRE(expected == mergeableRunProductMetadata.lumisFromIndexIntoFile());
0546       REQUIRE(mergeableRunProductMetadata.gotLumisFromIndexIntoFile());
0547     }
0548     {
0549       mergeableRunProductMetadata.readRun(8, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0550       std::vector<edm::LuminosityBlockNumber_t> expected{1000, 1002, 1003, 1004};
0551       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0552       mergeableRunProductMetadata.readRun(2, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0553       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0554       mergeableRunProductMetadata.preReadFile();
0555       expected = std::vector<edm::LuminosityBlockNumber_t>{1000, 1001, 1002, 1003, 1004};
0556       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0557     }
0558     mergeableRunProductMetadata.postWriteRun();
0559
0560     {
0561       mergeableRunProductMetadata.readRun(2, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0562       mergeableRunProductMetadata.readRun(8, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0563
0564       std::vector<edm::LuminosityBlockNumber_t> expected{1001, 1003};
0565       REQUIRE(expected == mergeableRunProductMetadata.lumisFromIndexIntoFile());
0566       REQUIRE(mergeableRunProductMetadata.gotLumisFromIndexIntoFile());
0567
0568       expected = std::vector<edm::LuminosityBlockNumber_t>{1000, 1002, 1003, 1004};
0569       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0570
0571       mergeableRunProductMetadata.writeLumi(1004);
0572       mergeableRunProductMetadata.writeLumi(1002);
0573       mergeableRunProductMetadata.writeLumi(1002);
0574       mergeableRunProductMetadata.preWriteRun();
0575
0576       expected.clear();
0577       REQUIRE(expected == mergeableRunProductMetadata.lumisFromIndexIntoFile());
0578       REQUIRE(!mergeableRunProductMetadata.gotLumisFromIndexIntoFile());
0579       REQUIRE(!APRODMetadataForProcess->allLumisProcessed());
0580
0581       expected = std::vector<edm::LuminosityBlockNumber_t>{1000, 1001, 1002, 1003, 1004};
0582       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0583     }
0584     mergeableRunProductMetadata.postWriteRun();
0585     REQUIRE(mergeableRunProductMetadata.lumisProcessed().empty());
0586     {
0587       // ----------------------------------------------------
0588
0589       std::vector<std::string> storedProcessesOutput{"AAAPROD", "AAPROD", "APROD", "ZPROD"};
0590       edm::StoredMergeableRunProductMetadata storedMetadataOutput(storedProcesses);
0591
0592       mergeableRunProductMetadata.readRun(1, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0593       mergeableRunProductMetadata.writeLumi(1003);
0594       mergeableRunProductMetadata.writeLumi(1001);
0595       mergeableRunProductMetadata.preWriteRun();
0596       mergeableRunProductMetadata.addEntryToStoredMetadata(storedMetadataOutput);
0597       mergeableRunProductMetadata.postWriteRun();
0598
0599       REQUIRE(storedMetadataOutput.allValidAndUseIndexIntoFile());
0600
0601       // ---------------------------------------------------
0602
0603       mergeableRunProductMetadata.readRun(2, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0604       mergeableRunProductMetadata.readRun(8, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0605
0606       std::vector<edm::LuminosityBlockNumber_t> expected{1001, 1003};
0607       REQUIRE(expected == mergeableRunProductMetadata.lumisFromIndexIntoFile());
0608       REQUIRE(mergeableRunProductMetadata.gotLumisFromIndexIntoFile());
0609
0610       expected = std::vector<edm::LuminosityBlockNumber_t>{1000, 1002, 1003, 1004};
0611       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0612
0613       mergeableRunProductMetadata.writeLumi(1004);
0614       mergeableRunProductMetadata.writeLumi(1002);
0615       mergeableRunProductMetadata.writeLumi(1002);
0616       mergeableRunProductMetadata.writeLumi(1000);
0617       mergeableRunProductMetadata.writeLumi(1001);
0618       mergeableRunProductMetadata.writeLumi(1003);
0619       mergeableRunProductMetadata.preWriteRun();
0620
0621       expected.clear();
0622       REQUIRE(expected == mergeableRunProductMetadata.lumisFromIndexIntoFile());
0623       REQUIRE(!mergeableRunProductMetadata.gotLumisFromIndexIntoFile());
0624       REQUIRE(APRODMetadataForProcess->allLumisProcessed());
0625
0626       expected = std::vector<edm::LuminosityBlockNumber_t>{1000, 1001, 1002, 1003, 1004};
0627       REQUIRE(APRODMetadataForProcess->lumis() == expected);
0628
0629       mergeableRunProductMetadata.addEntryToStoredMetadata(storedMetadataOutput);
0630
0631       // ----------------------------------------------------
0632
0633       mergeableRunProductMetadata.postWriteRun();
0634       mergeableRunProductMetadata.readRun(2, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0635       mergeableRunProductMetadata.preWriteRun();
0636       mergeableRunProductMetadata.addEntryToStoredMetadata(storedMetadataOutput);
0637
0638       // ----------------------------------------------------
0639
0640       mergeableRunProductMetadata.readRun(2, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0641       mergeableRunProductMetadata.readRun(8, storedMetadata, edm::IndexIntoFileItrHolder(iter));
0642       mergeableRunProductMetadata.writeLumi(1004);
0643       mergeableRunProductMetadata.writeLumi(1002);
0644       mergeableRunProductMetadata.writeLumi(1002);
0645       mergeableRunProductMetadata.writeLumi(1000);
0646       mergeableRunProductMetadata.writeLumi(1001);
0647       mergeableRunProductMetadata.preWriteRun();
0648       mergeableRunProductMetadata.addEntryToStoredMetadata(storedMetadataOutput);
0649       mergeableRunProductMetadata.postWriteRun();
0650
0651       // ---------------------------------------------------
0652       {
0653         std::vector<edm::StoredMergeableRunProductMetadata::SingleRunEntry>& singleRunEntries =
0654             storedMetadataOutput.singleRunEntries();
0655         REQUIRE(singleRunEntries.size() == 4);
0656         REQUIRE(singleRunEntries[0].beginProcess() == 0);
0657         REQUIRE(singleRunEntries[0].endProcess() == 0);
0658         REQUIRE(singleRunEntries[1].beginProcess() == 0);
0659         REQUIRE(singleRunEntries[1].endProcess() == 1);
0660         REQUIRE(singleRunEntries[2].beginProcess() == 1);
0661         REQUIRE(singleRunEntries[2].endProcess() == 3);
0662         REQUIRE(singleRunEntries[3].beginProcess() == 3);
0663         REQUIRE(singleRunEntries[3].endProcess() == 5);
0664
0665         std::vector<edm::StoredMergeableRunProductMetadata::SingleRunEntryAndProcess>& singleRunEntryAndProcesses =
0666             storedMetadataOutput.singleRunEntryAndProcesses();
0667         REQUIRE(singleRunEntryAndProcesses.size() == 5);
0668
0669         REQUIRE(singleRunEntryAndProcesses[0].beginLumi() == 0);
0670         REQUIRE(singleRunEntryAndProcesses[0].endLumi() == 0);
0671         REQUIRE(singleRunEntryAndProcesses[0].process() == 2);
0672         REQUIRE(!singleRunEntryAndProcesses[0].valid());
0673         REQUIRE(singleRunEntryAndProcesses[0].useIndexIntoFile());
0674
0675         REQUIRE(singleRunEntryAndProcesses[1].beginLumi() == 0);
0676         REQUIRE(singleRunEntryAndProcesses[1].endLumi() == 2);
0677         REQUIRE(singleRunEntryAndProcesses[1].process() == 1);
0678         REQUIRE(singleRunEntryAndProcesses[1].valid());
0679         REQUIRE(!singleRunEntryAndProcesses[1].useIndexIntoFile());
0680
0681         REQUIRE(singleRunEntryAndProcesses[2].beginLumi() == 0);
0682         REQUIRE(singleRunEntryAndProcesses[2].endLumi() == 2);
0683         REQUIRE(singleRunEntryAndProcesses[2].process() == 2);
0684         REQUIRE(!singleRunEntryAndProcesses[2].valid());
0685         REQUIRE(!singleRunEntryAndProcesses[2].useIndexIntoFile());
0686
0687         REQUIRE(singleRunEntryAndProcesses[3].beginLumi() == 2);
0688         REQUIRE(singleRunEntryAndProcesses[3].endLumi() == 4);
0689         REQUIRE(singleRunEntryAndProcesses[3].process() == 1);
0690         REQUIRE(singleRunEntryAndProcesses[3].valid());
0691         REQUIRE(!singleRunEntryAndProcesses[3].useIndexIntoFile());
0692
0693         REQUIRE(singleRunEntryAndProcesses[4].beginLumi() == 4);
0694         REQUIRE(singleRunEntryAndProcesses[4].endLumi() == 9);
0695         REQUIRE(singleRunEntryAndProcesses[4].process() == 2);
0696         REQUIRE(!singleRunEntryAndProcesses[4].valid());
0697         REQUIRE(!singleRunEntryAndProcesses[4].useIndexIntoFile());
0698
0699         std::vector<edm::LuminosityBlockNumber_t>& lumis = storedMetadataOutput.lumis();
0700         REQUIRE(lumis.size() == 9);
0701         REQUIRE(lumis[0] == 1001);
0702         REQUIRE(lumis[1] == 1003);
0703         REQUIRE(lumis[2] == 1001);
0704         REQUIRE(lumis[3] == 1003);
0705         REQUIRE(lumis[4] == 1000);
0706         REQUIRE(lumis[5] == 1001);
0707         REQUIRE(lumis[6] == 1002);
0708         REQUIRE(lumis[7] == 1003);
0709         REQUIRE(lumis[8] == 1004);
0710       }
0711       REQUIRE(!storedMetadataOutput.allValidAndUseIndexIntoFile());
0712     }
0713   }
0714 }