File indexing completed on 2023-03-17 10:51:13
0001
0002
0003
0004
0005 #include "cppunit/extensions/HelperMacros.h"
0006
0007 #include "DataFormats/Provenance/interface/ProcessHistoryID.h"
0008 #include "DataFormats/Provenance/interface/ProcessConfiguration.h"
0009 #include "DataFormats/Provenance/interface/ProcessHistory.h"
0010
0011 #include "DataFormats/Provenance/interface/IndexIntoFile.h"
0012
0013 #include <string>
0014 #include <iostream>
0015 #include <memory>
0016
0017 using namespace edm;
0018
0019 class TestIndexIntoFile3 : public CppUnit::TestFixture {
0020 CPPUNIT_TEST_SUITE(TestIndexIntoFile3);
0021 CPPUNIT_TEST(testIterEndWithEvent);
0022 CPPUNIT_TEST(testOverlappingLumis);
0023 CPPUNIT_TEST(testOverlappingLumisMore);
0024 CPPUNIT_TEST(testOverlappingLumisOutOfOrderEvent);
0025 CPPUNIT_TEST(testOverlappingLumisWithEndWithEmptyLumi);
0026 CPPUNIT_TEST(testOverlappingLumisWithLumiEndOrderChanged);
0027 CPPUNIT_TEST(testNonContiguousRun);
0028 CPPUNIT_TEST(testNonValidLumiInsideValidLumis);
0029 CPPUNIT_TEST_SUITE_END();
0030
0031 public:
0032 static const IndexIntoFile::EntryType kRun = IndexIntoFile::kRun;
0033 static const IndexIntoFile::EntryType kLumi = IndexIntoFile::kLumi;
0034 static const IndexIntoFile::EntryType kEvent = IndexIntoFile::kEvent;
0035 static const IndexIntoFile::EntryType kEnd = IndexIntoFile::kEnd;
0036
0037 class Skipped {
0038 public:
0039 Skipped() : phIndexOfSkippedEvent_(0), runOfSkippedEvent_(0), lumiOfSkippedEvent_(0), skippedEventEntry_(0) {}
0040 int phIndexOfSkippedEvent_;
0041 RunNumber_t runOfSkippedEvent_;
0042 LuminosityBlockNumber_t lumiOfSkippedEvent_;
0043 IndexIntoFile::EntryNumber_t skippedEventEntry_;
0044 };
0045
0046 Skipped skipped_;
0047
0048 void setUp() {
0049
0050 nullPHID = ProcessHistoryID();
0051
0052 ProcessConfiguration pc;
0053 auto processHistory1 = std::make_unique<ProcessHistory>();
0054 ProcessHistory& ph1 = *processHistory1;
0055 processHistory1->push_back(pc);
0056 fakePHID1 = ph1.id();
0057
0058 auto processHistory2 = std::make_unique<ProcessHistory>();
0059 ProcessHistory& ph2 = *processHistory2;
0060 processHistory2->push_back(pc);
0061 processHistory2->push_back(pc);
0062 fakePHID2 = ph2.id();
0063
0064 auto processHistory3 = std::make_unique<ProcessHistory>();
0065 ProcessHistory& ph3 = *processHistory3;
0066 processHistory3->push_back(pc);
0067 processHistory3->push_back(pc);
0068 processHistory3->push_back(pc);
0069 fakePHID3 = ph3.id();
0070 }
0071
0072 void tearDown() {}
0073
0074 void testIterEndWithEvent();
0075 void testOverlappingLumis();
0076 void testOverlappingLumisMore();
0077 void testOverlappingLumisOutOfOrderEvent();
0078 void testOverlappingLumisWithEndWithEmptyLumi();
0079 void testOverlappingLumisWithLumiEndOrderChanged();
0080 void testNonContiguousRun();
0081 void testNonValidLumiInsideValidLumis();
0082
0083 ProcessHistoryID nullPHID;
0084 ProcessHistoryID fakePHID1;
0085 ProcessHistoryID fakePHID2;
0086 ProcessHistoryID fakePHID3;
0087
0088 bool check(edm::IndexIntoFile::IndexIntoFileItr const& iter,
0089 IndexIntoFile::EntryType type,
0090 int indexToRun,
0091 int indexToLumi,
0092 int indexToEventRange,
0093 long long indexToEvent,
0094 long long nEvents);
0095
0096 void skipEventForward(edm::IndexIntoFile::IndexIntoFileItr& iter);
0097 void skipEventBackward(edm::IndexIntoFile::IndexIntoFileItr& iter);
0098 void checkSkipped(int phIndexOfSkippedEvent,
0099 RunNumber_t runOfSkippedEvent,
0100 LuminosityBlockNumber_t lumiOfSkippedEvent,
0101 IndexIntoFile::EntryNumber_t skippedEventEntry);
0102
0103 void checkIDRunLumiEntry(edm::IndexIntoFile::IndexIntoFileItr const& iter,
0104 int phIndex,
0105 RunNumber_t run,
0106 LuminosityBlockNumber_t lumi,
0107 IndexIntoFile::EntryNumber_t entry);
0108 };
0109
0110
0111 CPPUNIT_TEST_SUITE_REGISTRATION(TestIndexIntoFile3);
0112
0113 bool TestIndexIntoFile3::check(edm::IndexIntoFile::IndexIntoFileItr const& iter,
0114 IndexIntoFile::EntryType type,
0115 int indexToRun,
0116 int indexToLumi,
0117 int indexToEventRange,
0118 long long indexToEvent,
0119 long long nEvents) {
0120 bool theyMatch = iter.getEntryType() == type && iter.type() == type && iter.indexToRun() == indexToRun &&
0121 iter.indexToLumi() == indexToLumi && iter.indexToEventRange() == indexToEventRange &&
0122 iter.indexToEvent() == indexToEvent && iter.nEvents() == nEvents;
0123 if (!theyMatch) {
0124 std::cout << "\nExpected " << type << " " << indexToRun << " " << indexToLumi << " " << indexToEventRange
0125 << " " << indexToEvent << " " << nEvents << "\n";
0126 std::cout << "Iterator values " << iter.type() << " " << iter.indexToRun() << " " << iter.indexToLumi() << " "
0127 << iter.indexToEventRange() << " " << iter.indexToEvent() << " " << iter.nEvents() << "\n";
0128 }
0129 return theyMatch;
0130 }
0131
0132 void TestIndexIntoFile3::checkSkipped(int phIndexOfSkippedEvent,
0133 RunNumber_t runOfSkippedEvent,
0134 LuminosityBlockNumber_t lumiOfSkippedEvent,
0135 IndexIntoFile::EntryNumber_t skippedEventEntry) {
0136 bool theyMatch =
0137 skipped_.phIndexOfSkippedEvent_ == phIndexOfSkippedEvent && skipped_.runOfSkippedEvent_ == runOfSkippedEvent &&
0138 skipped_.lumiOfSkippedEvent_ == lumiOfSkippedEvent && skipped_.skippedEventEntry_ == skippedEventEntry;
0139
0140 if (!theyMatch) {
0141 std::cout << "\nExpected " << phIndexOfSkippedEvent << " " << runOfSkippedEvent << " "
0142 << lumiOfSkippedEvent << " " << skippedEventEntry << "\n";
0143 std::cout << "Actual " << skipped_.phIndexOfSkippedEvent_ << " " << skipped_.runOfSkippedEvent_ << " "
0144 << skipped_.lumiOfSkippedEvent_ << " " << skipped_.skippedEventEntry_ << "\n";
0145 }
0146 CPPUNIT_ASSERT(theyMatch);
0147 }
0148
0149 void TestIndexIntoFile3::checkIDRunLumiEntry(edm::IndexIntoFile::IndexIntoFileItr const& iter,
0150 int phIndex,
0151 RunNumber_t run,
0152 LuminosityBlockNumber_t lumi,
0153 IndexIntoFile::EntryNumber_t entry) {
0154 bool theyMatch =
0155 iter.processHistoryIDIndex() == phIndex && iter.run() == run && iter.lumi() == lumi && iter.entry() == entry;
0156
0157 if (!theyMatch) {
0158 std::cout << "\nExpected " << phIndex << " " << run << " " << lumi << " " << entry << "\n";
0159 std::cout << "Actual " << iter.processHistoryIDIndex() << " " << iter.run() << " " << iter.lumi() << " "
0160 << iter.entry() << "\n";
0161 }
0162 CPPUNIT_ASSERT(theyMatch);
0163 }
0164
0165 void TestIndexIntoFile3::skipEventForward(edm::IndexIntoFile::IndexIntoFileItr& iter) {
0166 iter.skipEventForward(skipped_.phIndexOfSkippedEvent_,
0167 skipped_.runOfSkippedEvent_,
0168 skipped_.lumiOfSkippedEvent_,
0169 skipped_.skippedEventEntry_);
0170 }
0171
0172 void TestIndexIntoFile3::skipEventBackward(edm::IndexIntoFile::IndexIntoFileItr& iter) {
0173 iter.skipEventBackward(skipped_.phIndexOfSkippedEvent_,
0174 skipped_.runOfSkippedEvent_,
0175 skipped_.lumiOfSkippedEvent_,
0176 skipped_.skippedEventEntry_);
0177 }
0178
0179 void TestIndexIntoFile3::testIterEndWithEvent() {
0180 edm::IndexIntoFile indexIntoFile;
0181 indexIntoFile.addEntry(fakePHID1, 11, 101, 7, 0);
0182 indexIntoFile.addEntry(fakePHID1, 11, 101, 6, 1);
0183 indexIntoFile.addEntry(fakePHID1, 11, 101, 0, 0);
0184 indexIntoFile.addEntry(fakePHID1, 11, 101, 0, 1);
0185 indexIntoFile.addEntry(fakePHID1, 11, 101, 5, 2);
0186 indexIntoFile.addEntry(fakePHID1, 11, 101, 4, 3);
0187 indexIntoFile.addEntry(fakePHID1, 11, 101, 0, 2);
0188 indexIntoFile.addEntry(fakePHID1, 11, 102, 5, 4);
0189 indexIntoFile.addEntry(fakePHID1, 11, 102, 4, 5);
0190 indexIntoFile.addEntry(fakePHID1, 11, 102, 0, 3);
0191 indexIntoFile.addEntry(fakePHID1, 11, 0, 0, 0);
0192 indexIntoFile.addEntry(fakePHID2, 11, 0, 0, 1);
0193 indexIntoFile.addEntry(fakePHID2, 11, 101, 0, 4);
0194 indexIntoFile.addEntry(fakePHID2, 11, 102, 0, 5);
0195 indexIntoFile.addEntry(fakePHID2, 11, 102, 4, 6);
0196 indexIntoFile.addEntry(fakePHID2, 11, 102, 0, 6);
0197 indexIntoFile.addEntry(fakePHID2, 11, 0, 0, 2);
0198 indexIntoFile.sortVector_Run_Or_Lumi_Entries();
0199
0200 edm::IndexIntoFile::IndexIntoFileItr iter3(
0201 &indexIntoFile, IndexIntoFile::firstAppearanceOrder, IndexIntoFile::kEvent, 0, 3, 2, 1, 2);
0202 edm::IndexIntoFile::IndexIntoFileItr iter1(iter3);
0203
0204 CPPUNIT_ASSERT(iter1 == iter3);
0205 CPPUNIT_ASSERT(iter1.indexIntoFile() == &indexIntoFile);
0206 CPPUNIT_ASSERT(iter1.size() == 10);
0207 CPPUNIT_ASSERT(iter1.type() == kEvent);
0208 CPPUNIT_ASSERT(iter1.indexToRun() == 0);
0209 CPPUNIT_ASSERT(iter1.indexToLumi() == 3);
0210 CPPUNIT_ASSERT(iter1.indexToEventRange() == 2);
0211 CPPUNIT_ASSERT(iter1.indexToEvent() == 1);
0212 CPPUNIT_ASSERT(iter1.nEvents() == 2);
0213
0214 iter1 = ++iter3;
0215 CPPUNIT_ASSERT(iter1 == iter3);
0216
0217 CPPUNIT_ASSERT(indexIntoFile.iterationWillBeInEntryOrder(IndexIntoFile::firstAppearanceOrder) == true);
0218
0219 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
0220 edm::IndexIntoFile::IndexIntoFileItr iterFirstCopy = iterFirst;
0221 edm::IndexIntoFile::IndexIntoFileItr iterFirstCopy2 = iterFirst;
0222 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
0223 int i = 0;
0224 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++iterFirstCopy, ++i) {
0225 CPPUNIT_ASSERT(iterFirst == iterFirstCopy);
0226 iterFirstCopy2 = iterFirstCopy;
0227 CPPUNIT_ASSERT(iterFirst == iterFirstCopy2);
0228 if (i == 0) {
0229 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 1, 0, 2));
0230 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
0231 CPPUNIT_ASSERT(iterFirst.size() == 10);
0232 CPPUNIT_ASSERT(iterFirst.indexedSize() == 10);
0233 CPPUNIT_ASSERT(iterFirst.shouldProcessRun());
0234 } else if (i == 1) {
0235 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, 1, 0, 2));
0236 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
0237 } else if (i == 2)
0238 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 2, 1, 0, 2));
0239 else if (i == 3)
0240 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 3, 1, 0, 2));
0241 else if (i == 4)
0242 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 1, 0, 2));
0243 else if (i == 5)
0244 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 1, 1, 2));
0245 else if (i == 6)
0246 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 3, 0, 2));
0247 else if (i == 7)
0248 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 3, 1, 2));
0249 else if (i == 8)
0250 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 0, 2));
0251 else if (i == 9)
0252 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 0, 2));
0253 else if (i == 10)
0254 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 1, 2));
0255 else if (i == 11)
0256 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
0257 else if (i == 12)
0258 CPPUNIT_ASSERT(check(iterFirst, kRun, 6, 7, -1, 0, 0));
0259 else if (i == 13)
0260 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 7, -1, 0, 0));
0261 else if (i == 14)
0262 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 8, 9, 0, 1));
0263 else if (i == 15)
0264 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 9, 9, 0, 1));
0265 else if (i == 16)
0266 CPPUNIT_ASSERT(check(iterFirst, kEvent, 6, 9, 9, 0, 1));
0267 else
0268 CPPUNIT_ASSERT(false);
0269
0270 switch (i) {
0271 case 0:
0272 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
0273 break;
0274 case 10:
0275 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
0276 break;
0277 case 12:
0278 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 6);
0279 break;
0280 }
0281
0282 switch (i) {
0283 case 0:
0284 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
0285 break;
0286 case 1:
0287 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
0288 break;
0289 case 2:
0290 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
0291 break;
0292 case 3:
0293 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
0294 break;
0295 case 10:
0296 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 4);
0297 break;
0298 case 12:
0299 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == IndexIntoFile::invalidIndex);
0300 break;
0301 }
0302 }
0303 CPPUNIT_ASSERT(i == 17);
0304
0305 for (i = 0, iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder); iterFirst != iterFirstEnd;
0306 ++iterFirst, ++i) {
0307 switch (i) {
0308 case 0:
0309 checkIDRunLumiEntry(iterFirst, 0, 11, 0, 0);
0310 break;
0311 case 1:
0312 checkIDRunLumiEntry(iterFirst, 0, 11, 101, 0);
0313 break;
0314 case 2:
0315 checkIDRunLumiEntry(iterFirst, 0, 11, 101, 1);
0316 break;
0317 case 3:
0318 checkIDRunLumiEntry(iterFirst, 0, 11, 101, 2);
0319 break;
0320 case 4:
0321 checkIDRunLumiEntry(iterFirst, 0, 11, 101, 0);
0322 break;
0323 case 5:
0324 checkIDRunLumiEntry(iterFirst, 0, 11, 101, 1);
0325 break;
0326 case 6:
0327 checkIDRunLumiEntry(iterFirst, 0, 11, 101, 2);
0328 break;
0329 case 7:
0330 checkIDRunLumiEntry(iterFirst, 0, 11, 101, 3);
0331 break;
0332 case 8:
0333 checkIDRunLumiEntry(iterFirst, 0, 11, 102, 3);
0334 break;
0335 case 9:
0336 checkIDRunLumiEntry(iterFirst, 0, 11, 102, 4);
0337 break;
0338 case 10:
0339 checkIDRunLumiEntry(iterFirst, 0, 11, 102, 5);
0340 break;
0341 case 11:
0342 checkIDRunLumiEntry(iterFirst, 1, 11, 0, 1);
0343 break;
0344 case 12:
0345 checkIDRunLumiEntry(iterFirst, 1, 11, 0, 2);
0346 break;
0347 case 13:
0348 checkIDRunLumiEntry(iterFirst, 1, 11, 101, 4);
0349 break;
0350 case 14:
0351 checkIDRunLumiEntry(iterFirst, 1, 11, 102, 5);
0352 break;
0353 case 15:
0354 checkIDRunLumiEntry(iterFirst, 1, 11, 102, 6);
0355 break;
0356 case 16:
0357 checkIDRunLumiEntry(iterFirst, 1, 11, 102, 6);
0358 break;
0359 }
0360 }
0361 checkIDRunLumiEntry(iterFirst, -1, 0, 0, -1);
0362
0363 CPPUNIT_ASSERT(indexIntoFile.runOrLumiIndexes().empty());
0364
0365
0366
0367 edm::IndexIntoFile::IndexIntoFileItr iter4(
0368 &indexIntoFile, IndexIntoFile::numericalOrder, IndexIntoFile::kEvent, 0, 3, 1, 3, 4);
0369 edm::IndexIntoFile::IndexIntoFileItr iter2(iter4);
0370
0371 CPPUNIT_ASSERT(iter2 == iter4);
0372 CPPUNIT_ASSERT(iter2.indexIntoFile() == &indexIntoFile);
0373 CPPUNIT_ASSERT(iter2.size() == 10);
0374 CPPUNIT_ASSERT(iter2.type() == kEvent);
0375 CPPUNIT_ASSERT(iter2.indexToRun() == 0);
0376 CPPUNIT_ASSERT(iter2.indexToLumi() == 3);
0377 CPPUNIT_ASSERT(iter2.indexToEventRange() == 1);
0378 CPPUNIT_ASSERT(iter2.indexToEvent() == 3);
0379 CPPUNIT_ASSERT(iter2.nEvents() == 4);
0380
0381 CPPUNIT_ASSERT(!indexIntoFile.runOrLumiIndexes().empty());
0382
0383 std::vector<IndexIntoFile::EventEntry>& eventEntries = indexIntoFile.eventEntries();
0384 eventEntries.emplace_back(7, 0);
0385 eventEntries.emplace_back(6, 1);
0386 eventEntries.emplace_back(5, 2);
0387 eventEntries.emplace_back(4, 3);
0388 eventEntries.emplace_back(5, 4);
0389 eventEntries.emplace_back(4, 5);
0390 eventEntries.emplace_back(4, 6);
0391 indexIntoFile.sortEventEntries();
0392
0393 CPPUNIT_ASSERT(indexIntoFile.iterationWillBeInEntryOrder(IndexIntoFile::numericalOrder) == false);
0394
0395 edm::IndexIntoFile::IndexIntoFileItr iterNum = indexIntoFile.begin(IndexIntoFile::numericalOrder);
0396 edm::IndexIntoFile::IndexIntoFileItr iterNumCopy = iterNum;
0397 edm::IndexIntoFile::IndexIntoFileItr iterNumCopy2 = iterNum;
0398 edm::IndexIntoFile::IndexIntoFileItr iterNumEnd = indexIntoFile.end(IndexIntoFile::numericalOrder);
0399 i = 0;
0400 for (; iterNum != iterNumEnd; ++iterNum, ++iterNumCopy, ++i) {
0401 iterNumCopy2 = iterNumCopy;
0402 CPPUNIT_ASSERT(iterNum == iterNumCopy);
0403 CPPUNIT_ASSERT(iterNum == iterNumCopy2);
0404 if (i == 0) {
0405 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 1, 1, 0, 4));
0406 CPPUNIT_ASSERT(iterNum.indexIntoFile() == &indexIntoFile);
0407 CPPUNIT_ASSERT(iterNum.size() == 10);
0408 CPPUNIT_ASSERT(iterNum.indexedSize() == 10);
0409 CPPUNIT_ASSERT(iterNum.shouldProcessRun());
0410 } else if (i == 1) {
0411 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 1, 1, 0, 4));
0412 CPPUNIT_ASSERT(iterNum.shouldProcessLumi());
0413 } else if (i == 2)
0414 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 2, 1, 0, 4));
0415 else if (i == 3)
0416 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 3, 1, 0, 4));
0417 else if (i == 4)
0418 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 3, 1, 0, 4));
0419 else if (i == 5)
0420 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 3, 1, 1, 4));
0421 else if (i == 6)
0422 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 3, 1, 2, 4));
0423 else if (i == 7)
0424 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 3, 1, 3, 4));
0425 else if (i == 8)
0426 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 4, 4, 0, 2));
0427 else if (i == 9)
0428 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 4, 4, 0, 2));
0429 else if (i == 10)
0430 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 4, 4, 1, 2));
0431 else if (i == 11)
0432 CPPUNIT_ASSERT(check(iterNum, kRun, 5, 7, -1, 0, 0));
0433 else if (i == 12)
0434 CPPUNIT_ASSERT(check(iterNum, kRun, 6, 7, -1, 0, 0));
0435 else if (i == 13)
0436 CPPUNIT_ASSERT(check(iterNum, kLumi, 6, 7, -1, 0, 0));
0437 else if (i == 14)
0438 CPPUNIT_ASSERT(check(iterNum, kLumi, 6, 8, 8, 0, 1));
0439 else if (i == 15)
0440 CPPUNIT_ASSERT(check(iterNum, kLumi, 6, 9, 8, 0, 1));
0441 else if (i == 16)
0442 CPPUNIT_ASSERT(check(iterNum, kEvent, 6, 9, 8, 0, 1));
0443 else
0444 CPPUNIT_ASSERT(false);
0445
0446 switch (i) {
0447 case 0:
0448 CPPUNIT_ASSERT(iterNum.firstEventEntryThisRun() == 3);
0449 break;
0450 case 10:
0451 CPPUNIT_ASSERT(iterNum.firstEventEntryThisRun() == 3);
0452 break;
0453 case 12:
0454 CPPUNIT_ASSERT(iterNum.firstEventEntryThisRun() == 6);
0455 break;
0456 }
0457 switch (i) {
0458 case 0:
0459 CPPUNIT_ASSERT(iterNum.firstEventEntryThisLumi() == 3);
0460 break;
0461 case 1:
0462 CPPUNIT_ASSERT(iterNum.firstEventEntryThisLumi() == 3);
0463 break;
0464 case 2:
0465 CPPUNIT_ASSERT(iterNum.firstEventEntryThisLumi() == 3);
0466 break;
0467 case 3:
0468 CPPUNIT_ASSERT(iterNum.firstEventEntryThisLumi() == 3);
0469 break;
0470 case 10:
0471 CPPUNIT_ASSERT(iterNum.firstEventEntryThisLumi() == 5);
0472 break;
0473 case 12:
0474 CPPUNIT_ASSERT(iterNum.firstEventEntryThisLumi() == IndexIntoFile::invalidIndex);
0475 break;
0476 }
0477 }
0478 CPPUNIT_ASSERT(i == 17);
0479
0480 for (i = 0, iterNum = indexIntoFile.begin(IndexIntoFile::numericalOrder); iterNum != iterNumEnd; ++iterNum, ++i) {
0481 switch (i) {
0482 case 0:
0483 checkIDRunLumiEntry(iterNum, 0, 11, 0, 0);
0484 break;
0485 case 1:
0486 checkIDRunLumiEntry(iterNum, 0, 11, 101, 0);
0487 break;
0488 case 2:
0489 checkIDRunLumiEntry(iterNum, 0, 11, 101, 1);
0490 break;
0491 case 3:
0492 checkIDRunLumiEntry(iterNum, 0, 11, 101, 2);
0493 break;
0494 case 4:
0495 checkIDRunLumiEntry(iterNum, 0, 11, 101, 3);
0496 break;
0497 case 5:
0498 checkIDRunLumiEntry(iterNum, 0, 11, 101, 2);
0499 break;
0500 case 6:
0501 checkIDRunLumiEntry(iterNum, 0, 11, 101, 1);
0502 break;
0503 case 7:
0504 checkIDRunLumiEntry(iterNum, 0, 11, 101, 0);
0505 break;
0506 case 8:
0507 checkIDRunLumiEntry(iterNum, 0, 11, 102, 3);
0508 break;
0509 case 9:
0510 checkIDRunLumiEntry(iterNum, 0, 11, 102, 5);
0511 break;
0512 case 10:
0513 checkIDRunLumiEntry(iterNum, 0, 11, 102, 4);
0514 break;
0515 case 11:
0516 checkIDRunLumiEntry(iterNum, 1, 11, 0, 1);
0517 break;
0518 case 12:
0519 checkIDRunLumiEntry(iterNum, 1, 11, 0, 2);
0520 break;
0521 case 13:
0522 checkIDRunLumiEntry(iterNum, 1, 11, 101, 4);
0523 break;
0524 case 14:
0525 checkIDRunLumiEntry(iterNum, 1, 11, 102, 5);
0526 break;
0527 case 15:
0528 checkIDRunLumiEntry(iterNum, 1, 11, 102, 6);
0529 break;
0530 case 16:
0531 checkIDRunLumiEntry(iterNum, 1, 11, 102, 6);
0532 break;
0533 }
0534 }
0535 checkIDRunLumiEntry(iterNum, -1, 0, 0, -1);
0536
0537 {
0538 edm::IndexIntoFile::IndexIntoFileItr iter3(
0539 &indexIntoFile, IndexIntoFile::entryOrder, IndexIntoFile::kEvent, 0, 3, 2, 1, 2);
0540 edm::IndexIntoFile::IndexIntoFileItr iter1(iter3);
0541
0542 CPPUNIT_ASSERT(iter1 == iter3);
0543 CPPUNIT_ASSERT(iter1.indexIntoFile() == &indexIntoFile);
0544 CPPUNIT_ASSERT(iter1.size() == 10);
0545 CPPUNIT_ASSERT(iter1.type() == kEvent);
0546 CPPUNIT_ASSERT(iter1.indexToRun() == 0);
0547 CPPUNIT_ASSERT(iter1.indexToLumi() == 3);
0548 CPPUNIT_ASSERT(iter1.indexToEventRange() == 2);
0549 CPPUNIT_ASSERT(iter1.indexToEvent() == 1);
0550 CPPUNIT_ASSERT(iter1.nEvents() == 2);
0551
0552 iter1 = ++iter3;
0553 CPPUNIT_ASSERT(iter1 == iter3);
0554
0555 CPPUNIT_ASSERT(indexIntoFile.iterationWillBeInEntryOrder(IndexIntoFile::entryOrder) == true);
0556
0557 edm::IndexIntoFile::IndexIntoFileItr iterEntry = indexIntoFile.begin(IndexIntoFile::entryOrder);
0558 edm::IndexIntoFile::IndexIntoFileItr iterEntryCopy = iterEntry;
0559 edm::IndexIntoFile::IndexIntoFileItr iterEntryCopy2 = iterEntry;
0560 edm::IndexIntoFile::IndexIntoFileItr iterEntryEnd = indexIntoFile.end(IndexIntoFile::entryOrder);
0561 int i = 0;
0562 for (i = 0; iterEntry != iterEntryEnd; ++iterEntry, ++iterEntryCopy, ++i) {
0563 CPPUNIT_ASSERT(iterEntry == iterEntryCopy);
0564 iterEntryCopy2 = iterEntryCopy;
0565 CPPUNIT_ASSERT(iterEntry == iterEntryCopy2);
0566 if (i == 0) {
0567 CPPUNIT_ASSERT(check(iterEntry, kRun, 0, 1, 1, 0, 2));
0568 CPPUNIT_ASSERT(iterEntry.indexIntoFile() == &indexIntoFile);
0569 CPPUNIT_ASSERT(iterEntry.size() == 10);
0570 } else if (i == 1)
0571 CPPUNIT_ASSERT(check(iterEntry, kLumi, 0, 1, 1, 0, 2));
0572 else if (i == 2)
0573 CPPUNIT_ASSERT(check(iterEntry, kLumi, 0, 2, 1, 0, 2));
0574 else if (i == 3)
0575 CPPUNIT_ASSERT(check(iterEntry, kLumi, 0, 3, 1, 0, 2));
0576 else if (i == 4)
0577 CPPUNIT_ASSERT(check(iterEntry, kEvent, 0, 3, 1, 0, 2));
0578 else if (i == 5)
0579 CPPUNIT_ASSERT(check(iterEntry, kEvent, 0, 3, 1, 1, 2));
0580 else if (i == 6)
0581 CPPUNIT_ASSERT(check(iterEntry, kEvent, 0, 3, 3, 0, 2));
0582 else if (i == 7)
0583 CPPUNIT_ASSERT(check(iterEntry, kEvent, 0, 3, 3, 1, 2));
0584 else if (i == 8)
0585 CPPUNIT_ASSERT(check(iterEntry, kLumi, 0, 4, 4, 0, 2));
0586 else if (i == 9)
0587 CPPUNIT_ASSERT(check(iterEntry, kEvent, 0, 4, 4, 0, 2));
0588 else if (i == 10)
0589 CPPUNIT_ASSERT(check(iterEntry, kEvent, 0, 4, 4, 1, 2));
0590 else if (i == 11)
0591 CPPUNIT_ASSERT(check(iterEntry, kRun, 5, 7, -1, 0, 0));
0592 else if (i == 12)
0593 CPPUNIT_ASSERT(check(iterEntry, kRun, 6, 7, -1, 0, 0));
0594 else if (i == 13)
0595 CPPUNIT_ASSERT(check(iterEntry, kLumi, 6, 7, -1, 0, 0));
0596 else if (i == 14)
0597 CPPUNIT_ASSERT(check(iterEntry, kLumi, 6, 8, 9, 0, 1));
0598 else if (i == 15)
0599 CPPUNIT_ASSERT(check(iterEntry, kLumi, 6, 9, 9, 0, 1));
0600 else if (i == 16)
0601 CPPUNIT_ASSERT(check(iterEntry, kEvent, 6, 9, 9, 0, 1));
0602 else
0603 CPPUNIT_ASSERT(false);
0604
0605 switch (i) {
0606 case 0:
0607 CPPUNIT_ASSERT(iterEntry.firstEventEntryThisRun() == 0);
0608 break;
0609 case 10:
0610 CPPUNIT_ASSERT(iterEntry.firstEventEntryThisRun() == 0);
0611 break;
0612 case 12:
0613 CPPUNIT_ASSERT(iterEntry.firstEventEntryThisRun() == 6);
0614 break;
0615 }
0616
0617 switch (i) {
0618 case 0:
0619 CPPUNIT_ASSERT(iterEntry.firstEventEntryThisLumi() == 0);
0620 break;
0621 case 1:
0622 CPPUNIT_ASSERT(iterEntry.firstEventEntryThisLumi() == 0);
0623 break;
0624 case 2:
0625 CPPUNIT_ASSERT(iterEntry.firstEventEntryThisLumi() == 0);
0626 break;
0627 case 3:
0628 CPPUNIT_ASSERT(iterEntry.firstEventEntryThisLumi() == 0);
0629 break;
0630 case 10:
0631 CPPUNIT_ASSERT(iterEntry.firstEventEntryThisLumi() == 4);
0632 break;
0633 case 12:
0634 CPPUNIT_ASSERT(iterEntry.firstEventEntryThisLumi() == IndexIntoFile::invalidIndex);
0635 break;
0636 }
0637 }
0638 CPPUNIT_ASSERT(i == 17);
0639
0640 for (i = 0, iterEntry = indexIntoFile.begin(IndexIntoFile::entryOrder); iterEntry != iterEntryEnd;
0641 ++iterEntry, ++i) {
0642 switch (i) {
0643 case 0:
0644 checkIDRunLumiEntry(iterEntry, 0, 11, 0, 0);
0645 break;
0646 case 1:
0647 checkIDRunLumiEntry(iterEntry, 0, 11, 101, 0);
0648 break;
0649 case 2:
0650 checkIDRunLumiEntry(iterEntry, 0, 11, 101, 1);
0651 break;
0652 case 3:
0653 checkIDRunLumiEntry(iterEntry, 0, 11, 101, 2);
0654 break;
0655 case 4:
0656 checkIDRunLumiEntry(iterEntry, 0, 11, 101, 0);
0657 break;
0658 case 5:
0659 checkIDRunLumiEntry(iterEntry, 0, 11, 101, 1);
0660 break;
0661 case 6:
0662 checkIDRunLumiEntry(iterEntry, 0, 11, 101, 2);
0663 break;
0664 case 7:
0665 checkIDRunLumiEntry(iterEntry, 0, 11, 101, 3);
0666 break;
0667 case 8:
0668 checkIDRunLumiEntry(iterEntry, 0, 11, 102, 3);
0669 break;
0670 case 9:
0671 checkIDRunLumiEntry(iterEntry, 0, 11, 102, 4);
0672 break;
0673 case 10:
0674 checkIDRunLumiEntry(iterEntry, 0, 11, 102, 5);
0675 break;
0676 case 11:
0677 checkIDRunLumiEntry(iterEntry, 1, 11, 0, 1);
0678 break;
0679 case 12:
0680 checkIDRunLumiEntry(iterEntry, 1, 11, 0, 2);
0681 break;
0682 case 13:
0683 checkIDRunLumiEntry(iterEntry, 1, 11, 101, 4);
0684 break;
0685 case 14:
0686 checkIDRunLumiEntry(iterEntry, 1, 11, 102, 5);
0687 break;
0688 case 15:
0689 checkIDRunLumiEntry(iterEntry, 1, 11, 102, 6);
0690 break;
0691 case 16:
0692 checkIDRunLumiEntry(iterEntry, 1, 11, 102, 6);
0693 break;
0694 }
0695 }
0696 checkIDRunLumiEntry(iterEntry, -1, 0, 0, -1);
0697 }
0698 iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
0699 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 1, 0, 2));
0700
0701 skipEventForward(iterFirst);
0702 checkSkipped(0, 11, 101, 0);
0703 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 1, 1, 2));
0704
0705 skipEventForward(iterFirst);
0706 checkSkipped(0, 11, 101, 1);
0707 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 3, 0, 2));
0708
0709 skipEventForward(iterFirst);
0710 checkSkipped(0, 11, 101, 2);
0711 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 3, 1, 2));
0712
0713 skipEventForward(iterFirst);
0714 checkSkipped(0, 11, 101, 3);
0715 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 4, 4, 0, 2));
0716
0717 skipEventForward(iterFirst);
0718 checkSkipped(0, 11, 102, 4);
0719 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 4, 4, 1, 2));
0720
0721 skipEventForward(iterFirst);
0722 checkSkipped(0, 11, 102, 5);
0723 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
0724
0725 skipEventForward(iterFirst);
0726 checkSkipped(1, 11, 102, 6);
0727 CPPUNIT_ASSERT(check(iterFirst, kEnd, -1, -1, -1, 0, 0));
0728
0729 skipEventForward(iterFirst);
0730 checkSkipped(-1, 0, 0, -1);
0731 CPPUNIT_ASSERT(check(iterFirst, kEnd, -1, -1, -1, 0, 0));
0732
0733 iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
0734 ++iterFirst;
0735
0736 skipEventForward(iterFirst);
0737 checkSkipped(0, 11, 101, 0);
0738 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, 1, 1, 2));
0739
0740 skipEventForward(iterFirst);
0741 checkSkipped(0, 11, 101, 1);
0742 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, 3, 0, 2));
0743
0744 skipEventForward(iterFirst);
0745 checkSkipped(0, 11, 101, 2);
0746 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, 3, 1, 2));
0747
0748 skipEventForward(iterFirst);
0749 checkSkipped(0, 11, 101, 3);
0750 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 0, 2));
0751
0752 skipEventForward(iterFirst);
0753 checkSkipped(0, 11, 102, 4);
0754 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 1, 2));
0755
0756 skipEventForward(iterFirst);
0757 checkSkipped(0, 11, 102, 5);
0758 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
0759
0760 ++iterFirst;
0761 ++iterFirst;
0762 ++iterFirst;
0763 skipEventForward(iterFirst);
0764 checkSkipped(1, 11, 102, 6);
0765 CPPUNIT_ASSERT(check(iterFirst, kEnd, -1, -1, -1, 0, 0));
0766
0767 iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
0768 ++iterFirst;
0769 ++iterFirst;
0770 ++iterFirst;
0771 ++iterFirst;
0772
0773 skipEventForward(iterFirst);
0774 checkSkipped(0, 11, 101, 0);
0775 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 1, 1, 2));
0776
0777 skipEventForward(iterFirst);
0778 checkSkipped(0, 11, 101, 1);
0779 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 3, 0, 2));
0780
0781 skipEventForward(iterFirst);
0782 checkSkipped(0, 11, 101, 2);
0783 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 3, 1, 2));
0784
0785 skipEventForward(iterFirst);
0786 checkSkipped(0, 11, 101, 3);
0787 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 0, 2));
0788
0789 ++iterFirst;
0790 skipEventForward(iterFirst);
0791 checkSkipped(0, 11, 102, 4);
0792 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 1, 2));
0793
0794 skipEventForward(iterFirst);
0795 checkSkipped(0, 11, 102, 5);
0796 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
0797
0798 iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
0799 iterFirst.advanceToNextLumiOrRun();
0800 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, 1, 0, 2));
0801 iterFirst.advanceToNextLumiOrRun();
0802 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 0, 2));
0803 iterFirst.advanceToNextLumiOrRun();
0804 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
0805 iterFirst.advanceToNextLumiOrRun();
0806 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 7, -1, 0, 0));
0807 iterFirst.advanceToNextLumiOrRun();
0808 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 8, 9, 0, 1));
0809 iterFirst.advanceToNextLumiOrRun();
0810 CPPUNIT_ASSERT(check(iterFirst, kEnd, -1, -1, -1, 0, 0));
0811
0812 iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
0813 ++iterFirst;
0814 ++iterFirst;
0815 ++iterFirst;
0816 ++iterFirst;
0817 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 1, 0, 2));
0818 iterFirst.advanceToNextLumiOrRun();
0819 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 0, 2));
0820 ++iterFirst;
0821 iterFirst.advanceToNextLumiOrRun();
0822 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
0823
0824 iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
0825 ++iterFirst;
0826 ++iterFirst;
0827 ++iterFirst;
0828 ++iterFirst;
0829 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 1, 0, 2));
0830 iterFirst.advanceToNextRun();
0831 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
0832
0833
0834
0835 iterNum = indexIntoFile.begin(IndexIntoFile::numericalOrder);
0836 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 1, 1, 0, 4));
0837
0838 skipEventForward(iterNum);
0839 checkSkipped(0, 11, 101, 3);
0840 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 1, 1, 1, 4));
0841
0842 skipEventForward(iterNum);
0843 checkSkipped(0, 11, 101, 2);
0844 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 1, 1, 2, 4));
0845
0846 skipEventForward(iterNum);
0847 checkSkipped(0, 11, 101, 1);
0848 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 1, 1, 3, 4));
0849
0850 skipEventForward(iterNum);
0851 checkSkipped(0, 11, 101, 0);
0852 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 4, 4, 0, 2));
0853
0854 skipEventForward(iterNum);
0855 checkSkipped(0, 11, 102, 5);
0856 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 4, 4, 1, 2));
0857
0858 skipEventForward(iterNum);
0859 checkSkipped(0, 11, 102, 4);
0860 CPPUNIT_ASSERT(check(iterNum, kRun, 5, 7, -1, 0, 0));
0861
0862 skipEventForward(iterNum);
0863 checkSkipped(1, 11, 102, 6);
0864 CPPUNIT_ASSERT(check(iterNum, kEnd, -1, -1, -1, 0, 0));
0865
0866 skipEventForward(iterNum);
0867 checkSkipped(-1, 0, 0, -1);
0868 CPPUNIT_ASSERT(check(iterNum, kEnd, -1, -1, -1, 0, 0));
0869
0870 iterNum = indexIntoFile.begin(IndexIntoFile::numericalOrder);
0871 ++iterNum;
0872
0873 skipEventForward(iterNum);
0874 checkSkipped(0, 11, 101, 3);
0875 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 1, 1, 1, 4));
0876
0877 skipEventForward(iterNum);
0878 checkSkipped(0, 11, 101, 2);
0879 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 1, 1, 2, 4));
0880
0881 skipEventForward(iterNum);
0882 checkSkipped(0, 11, 101, 1);
0883 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 1, 1, 3, 4));
0884
0885 skipEventForward(iterNum);
0886 checkSkipped(0, 11, 101, 0);
0887 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 4, 4, 0, 2));
0888
0889 skipEventForward(iterNum);
0890 checkSkipped(0, 11, 102, 5);
0891 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 4, 4, 1, 2));
0892
0893 skipEventForward(iterNum);
0894 checkSkipped(0, 11, 102, 4);
0895 CPPUNIT_ASSERT(check(iterNum, kRun, 5, 7, -1, 0, 0));
0896
0897 ++iterNum;
0898 ++iterNum;
0899 ++iterNum;
0900 CPPUNIT_ASSERT(check(iterNum, kLumi, 6, 8, 8, 0, 1));
0901 skipEventForward(iterNum);
0902 checkSkipped(1, 11, 102, 6);
0903 CPPUNIT_ASSERT(check(iterNum, kEnd, -1, -1, -1, 0, 0));
0904
0905 iterNum = indexIntoFile.begin(IndexIntoFile::numericalOrder);
0906 ++iterNum;
0907 ++iterNum;
0908 ++iterNum;
0909 ++iterNum;
0910
0911 skipEventForward(iterNum);
0912 checkSkipped(0, 11, 101, 3);
0913 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 3, 1, 1, 4));
0914
0915 skipEventForward(iterNum);
0916 checkSkipped(0, 11, 101, 2);
0917 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 3, 1, 2, 4));
0918
0919 skipEventForward(iterNum);
0920 checkSkipped(0, 11, 101, 1);
0921 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 3, 1, 3, 4));
0922
0923 skipEventForward(iterNum);
0924 checkSkipped(0, 11, 101, 0);
0925 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 4, 4, 0, 2));
0926
0927 ++iterNum;
0928 skipEventForward(iterNum);
0929 checkSkipped(0, 11, 102, 5);
0930 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 4, 4, 1, 2));
0931
0932 skipEventForward(iterNum);
0933 checkSkipped(0, 11, 102, 4);
0934 CPPUNIT_ASSERT(check(iterNum, kRun, 5, 7, -1, 0, 0));
0935
0936 iterNum = indexIntoFile.begin(IndexIntoFile::numericalOrder);
0937 iterNum.advanceToNextLumiOrRun();
0938 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 1, 1, 0, 4));
0939 iterNum.advanceToNextLumiOrRun();
0940 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 4, 4, 0, 2));
0941 iterNum.advanceToNextLumiOrRun();
0942 CPPUNIT_ASSERT(check(iterNum, kRun, 5, 7, -1, 0, 0));
0943 iterNum.advanceToNextLumiOrRun();
0944 CPPUNIT_ASSERT(check(iterNum, kLumi, 6, 7, -1, 0, 0));
0945 iterNum.advanceToNextLumiOrRun();
0946 CPPUNIT_ASSERT(check(iterNum, kLumi, 6, 8, 8, 0, 1));
0947 iterNum.advanceToNextLumiOrRun();
0948 CPPUNIT_ASSERT(check(iterNum, kEnd, -1, -1, -1, 0, 0));
0949
0950 iterNum = indexIntoFile.begin(IndexIntoFile::numericalOrder);
0951 ++iterNum;
0952 ++iterNum;
0953 ++iterNum;
0954 ++iterNum;
0955 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 3, 1, 0, 4));
0956 iterNum.advanceToNextLumiOrRun();
0957 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 4, 4, 0, 2));
0958 ++iterNum;
0959 iterNum.advanceToNextLumiOrRun();
0960 CPPUNIT_ASSERT(check(iterNum, kRun, 5, 7, -1, 0, 0));
0961
0962 iterNum = indexIntoFile.begin(IndexIntoFile::numericalOrder);
0963 ++iterNum;
0964 ++iterNum;
0965 ++iterNum;
0966 ++iterNum;
0967 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 3, 1, 0, 4));
0968 iterNum.advanceToNextRun();
0969 CPPUNIT_ASSERT(check(iterNum, kRun, 5, 7, -1, 0, 0));
0970
0971
0972
0973 iterFirst = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
0974
0975 skipEventBackward(iterFirst);
0976 checkSkipped(1, 11, 102, 6);
0977 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 8, 9, 0, 1));
0978
0979 skipEventBackward(iterFirst);
0980 checkSkipped(0, 11, 102, 5);
0981 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 4, 4, 1, 2));
0982
0983 skipEventBackward(iterFirst);
0984 checkSkipped(0, 11, 102, 4);
0985 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 4, 4, 0, 2));
0986
0987 skipEventBackward(iterFirst);
0988 checkSkipped(0, 11, 101, 3);
0989 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 3, 1, 2));
0990
0991 skipEventBackward(iterFirst);
0992 checkSkipped(0, 11, 101, 2);
0993 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 3, 0, 2));
0994
0995 skipEventBackward(iterFirst);
0996 checkSkipped(0, 11, 101, 1);
0997 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 1, 1, 2));
0998
0999 skipEventBackward(iterFirst);
1000 checkSkipped(0, 11, 101, 0);
1001 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 1, 0, 2));
1002
1003 skipEventBackward(iterFirst);
1004 checkSkipped(-1, 0, 0, -1);
1005 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 1, 0, 2));
1006
1007 ++iterFirst;
1008 ++iterFirst;
1009 ++iterFirst;
1010 ++iterFirst;
1011 ++iterFirst;
1012 ++iterFirst;
1013 ++iterFirst;
1014 ++iterFirst;
1015 ++iterFirst;
1016 ++iterFirst;
1017 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 1, 2));
1018
1019 skipEventBackward(iterFirst);
1020 checkSkipped(0, 11, 102, 4);
1021 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 0, 2));
1022
1023 skipEventBackward(iterFirst);
1024 checkSkipped(0, 11, 101, 3);
1025 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, 3, 1, 2));
1026
1027 skipEventForward(iterFirst);
1028 skipEventForward(iterFirst);
1029 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 1, 2));
1030
1031 skipEventBackward(iterFirst);
1032 checkSkipped(0, 11, 102, 4);
1033 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 0, 2));
1034
1035 skipEventBackward(iterFirst);
1036 checkSkipped(0, 11, 101, 3);
1037 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, 3, 1, 2));
1038
1039 iterFirst.advanceToNextRun();
1040 iterFirst.advanceToEvent();
1041 CPPUNIT_ASSERT(check(iterFirst, kEvent, 6, 9, 9, 0, 1));
1042
1043 skipEventBackward(iterFirst);
1044 checkSkipped(0, 11, 102, 5);
1045 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 4, 4, 1, 2));
1046
1047 iterFirst.advanceToNextRun();
1048 ++iterFirst;
1049 ++iterFirst;
1050 ++iterFirst;
1051 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 8, 9, 0, 1));
1052
1053 skipEventBackward(iterFirst);
1054 checkSkipped(0, 11, 102, 5);
1055 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 4, 4, 1, 2));
1056
1057 iterNum = indexIntoFile.end(IndexIntoFile::numericalOrder);
1058
1059 skipEventBackward(iterNum);
1060 checkSkipped(1, 11, 102, 6);
1061 CPPUNIT_ASSERT(check(iterNum, kRun, 5, 8, 8, 0, 1));
1062
1063 skipEventBackward(iterNum);
1064 checkSkipped(0, 11, 102, 4);
1065 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 4, 4, 1, 2));
1066
1067 skipEventBackward(iterNum);
1068 checkSkipped(0, 11, 102, 5);
1069 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 4, 4, 0, 2));
1070
1071 skipEventBackward(iterNum);
1072 checkSkipped(0, 11, 101, 0);
1073 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 1, 1, 3, 4));
1074
1075 skipEventBackward(iterNum);
1076 checkSkipped(0, 11, 101, 1);
1077 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 1, 1, 2, 4));
1078
1079 skipEventBackward(iterNum);
1080 checkSkipped(0, 11, 101, 2);
1081 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 1, 1, 1, 4));
1082
1083 skipEventBackward(iterNum);
1084 checkSkipped(0, 11, 101, 3);
1085 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 1, 1, 0, 4));
1086
1087 skipEventBackward(iterNum);
1088 checkSkipped(-1, 0, 0, -1);
1089 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 1, 1, 0, 4));
1090
1091 ++iterNum;
1092 ++iterNum;
1093 ++iterNum;
1094 ++iterNum;
1095 ++iterNum;
1096 ++iterNum;
1097 ++iterNum;
1098 ++iterNum;
1099 ++iterNum;
1100 ++iterNum;
1101 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 4, 4, 1, 2));
1102
1103 skipEventBackward(iterNum);
1104 checkSkipped(0, 11, 102, 5);
1105 CPPUNIT_ASSERT(check(iterNum, kEvent, 0, 4, 4, 0, 2));
1106
1107 skipEventBackward(iterNum);
1108 checkSkipped(0, 11, 101, 0);
1109 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 1, 1, 3, 4));
1110
1111 skipEventForward(iterNum);
1112 skipEventForward(iterNum);
1113 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 4, 4, 1, 2));
1114
1115 skipEventBackward(iterNum);
1116 checkSkipped(0, 11, 102, 5);
1117 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 4, 4, 0, 2));
1118
1119 skipEventBackward(iterNum);
1120 checkSkipped(0, 11, 101, 0);
1121 CPPUNIT_ASSERT(check(iterNum, kLumi, 0, 1, 1, 3, 4));
1122
1123 iterNum.advanceToNextRun();
1124 iterNum.advanceToEvent();
1125 CPPUNIT_ASSERT(check(iterNum, kEvent, 6, 9, 8, 0, 1));
1126
1127 skipEventBackward(iterNum);
1128 checkSkipped(0, 11, 102, 4);
1129 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 4, 4, 1, 2));
1130
1131 iterNum.advanceToNextRun();
1132 ++iterNum;
1133 ++iterNum;
1134 ++iterNum;
1135 CPPUNIT_ASSERT(check(iterNum, kLumi, 6, 8, 8, 0, 1));
1136
1137 skipEventBackward(iterNum);
1138 checkSkipped(0, 11, 102, 4);
1139 CPPUNIT_ASSERT(check(iterNum, kRun, 0, 4, 4, 1, 2));
1140 }
1141
1142 void TestIndexIntoFile3::testOverlappingLumis() {
1143 edm::IndexIntoFile indexIntoFile;
1144 indexIntoFile.addEntry(fakePHID1, 11, 104, 0, 0);
1145 indexIntoFile.addEntry(fakePHID1, 11, 103, 7, 0);
1146 indexIntoFile.addEntry(fakePHID1, 11, 103, 6, 1);
1147 indexIntoFile.addEntry(fakePHID1, 11, 103, 5, 2);
1148 indexIntoFile.addEntry(fakePHID1, 11, 103, 4, 3);
1149
1150 indexIntoFile.addEntry(fakePHID1, 11, 102, 5, 4);
1151
1152 indexIntoFile.addEntry(fakePHID1, 11, 103, 0, 1);
1153
1154 indexIntoFile.addEntry(fakePHID1, 11, 102, 4, 5);
1155 indexIntoFile.addEntry(fakePHID1, 11, 102, 0, 2);
1156 indexIntoFile.addEntry(fakePHID1, 11, 0, 0, 0);
1157 indexIntoFile.addEntry(fakePHID2, 11, 0, 0, 1);
1158 indexIntoFile.addEntry(fakePHID2, 11, 101, 0, 3);
1159 indexIntoFile.addEntry(fakePHID2, 11, 102, 0, 4);
1160 indexIntoFile.addEntry(fakePHID2, 11, 102, 4, 6);
1161 indexIntoFile.addEntry(fakePHID2, 11, 102, 0, 5);
1162 indexIntoFile.addEntry(fakePHID2, 11, 0, 0, 2);
1163 indexIntoFile.sortVector_Run_Or_Lumi_Entries();
1164
1165 std::vector<IndexIntoFile::EventEntry>& eventEntries = indexIntoFile.eventEntries();
1166 eventEntries.emplace_back(5, 4);
1167 eventEntries.emplace_back(4, 5);
1168 eventEntries.emplace_back(7, 0);
1169 eventEntries.emplace_back(6, 1);
1170 eventEntries.emplace_back(5, 2);
1171 eventEntries.emplace_back(4, 3);
1172 eventEntries.emplace_back(4, 6);
1173 indexIntoFile.sortEventEntries();
1174
1175 std::vector<LuminosityBlockNumber_t> lumis;
1176
1177 {
1178 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
1179 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
1180 int i = 0;
1181 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
1182 if (i == 0) {
1183 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, -1, 0, 0));
1184 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
1185 CPPUNIT_ASSERT(iterFirst.size() == 11);
1186 }
1187
1188 else if (i == 1)
1189 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, -1, 0, 0));
1190 else if (i == 2)
1191 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 3, 2, 0, 4));
1192 else if (i == 3)
1193 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 2, 0, 4));
1194 else if (i == 4)
1195 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 2, 1, 4));
1196 else if (i == 5)
1197 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 2, 2, 4));
1198 else if (i == 6)
1199 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 2, 3, 4));
1200 else if (i == 7)
1201 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 5, 4, 0, 1));
1202 else if (i == 8)
1203 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 5, 4, 0, 1));
1204 else if (i == 9)
1205 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 5, 5, 0, 1));
1206 else if (i == 10)
1207 CPPUNIT_ASSERT(check(iterFirst, kRun, 6, 8, -1, 0, 0));
1208 else if (i == 11)
1209 CPPUNIT_ASSERT(check(iterFirst, kRun, 7, 8, -1, 0, 0));
1210 else if (i == 12)
1211 CPPUNIT_ASSERT(check(iterFirst, kLumi, 7, 8, -1, 0, 0));
1212 else if (i == 13)
1213 CPPUNIT_ASSERT(check(iterFirst, kLumi, 7, 9, 10, 0, 1));
1214 else if (i == 14)
1215 CPPUNIT_ASSERT(check(iterFirst, kLumi, 7, 10, 10, 0, 1));
1216 else if (i == 15)
1217 CPPUNIT_ASSERT(check(iterFirst, kEvent, 7, 10, 10, 0, 1));
1218 else
1219 CPPUNIT_ASSERT(false);
1220
1221 switch (i) {
1222 case 1:
1223 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1224 break;
1225 case 9:
1226 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1227 break;
1228 case 11:
1229 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 6);
1230 break;
1231 }
1232
1233 switch (i) {
1234 case 2:
1235 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
1236 break;
1237 case 9:
1238 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 4);
1239 break;
1240 case 11:
1241 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == IndexIntoFile::invalidIndex);
1242 break;
1243 }
1244 }
1245 CPPUNIT_ASSERT(i == 16);
1246 }
1247 {
1248 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::numericalOrder);
1249 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::numericalOrder);
1250 int i = 0;
1251 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
1252
1253 if (i == 0) {
1254 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 2, 1, 0, 2));
1255
1256 iterFirst.getLumisInRun(lumis);
1257 std::vector<LuminosityBlockNumber_t> expected{102, 103, 104};
1258 CPPUNIT_ASSERT(lumis == expected);
1259 } else if (i == 1)
1260 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 2, 1, 0, 2));
1261 else if (i == 2)
1262 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 0, 2));
1263 else if (i == 3)
1264 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 1, 2));
1265 else if (i == 4)
1266 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 3, 0, 4));
1267 else if (i == 5)
1268 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 3, 0, 4));
1269 else if (i == 6)
1270 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 3, 1, 4));
1271 else if (i == 7)
1272 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 3, 2, 4));
1273 else if (i == 8)
1274 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 3, 3, 4));
1275 else if (i == 9)
1276 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 5, -1, 0, 0));
1277 else if (i == 10)
1278 CPPUNIT_ASSERT(check(iterFirst, kRun, 6, 8, -1, 0, 0));
1279 else if (i == 11)
1280 CPPUNIT_ASSERT(check(iterFirst, kRun, 7, 8, -1, 0, 0));
1281 else if (i == 12)
1282 CPPUNIT_ASSERT(check(iterFirst, kLumi, 7, 8, -1, 0, 0));
1283 else if (i == 13)
1284 CPPUNIT_ASSERT(check(iterFirst, kLumi, 7, 9, 9, 0, 1));
1285 else if (i == 14)
1286 CPPUNIT_ASSERT(check(iterFirst, kLumi, 7, 10, 9, 0, 1));
1287 else if (i == 15)
1288 CPPUNIT_ASSERT(check(iterFirst, kEvent, 7, 10, 9, 0, 1));
1289 else
1290 CPPUNIT_ASSERT(false);
1291 }
1292 CPPUNIT_ASSERT(i == 16);
1293 }
1294 {
1295 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::entryOrder);
1296 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::entryOrder);
1297 int i = 0;
1298 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
1299
1300 if (i == 0) {
1301 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, -1, 0, 0));
1302 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
1303 CPPUNIT_ASSERT(iterFirst.size() == 11);
1304 }
1305
1306 else if (i == 1)
1307 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, -1, 0, 0));
1308 else if (i == 2)
1309 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 3, 2, 0, 4));
1310 else if (i == 3)
1311 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 2, 0, 4));
1312 else if (i == 4)
1313 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 2, 1, 4));
1314 else if (i == 5)
1315 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 2, 2, 4));
1316 else if (i == 6)
1317 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 2, 3, 4));
1318 else if (i == 7)
1319 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 5, 4, 0, 1));
1320 else if (i == 8)
1321 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 5, 4, 0, 1));
1322 else if (i == 9)
1323 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 5, 5, 0, 1));
1324 else if (i == 10)
1325 CPPUNIT_ASSERT(check(iterFirst, kRun, 6, 8, -1, 0, 0));
1326 else if (i == 11)
1327 CPPUNIT_ASSERT(check(iterFirst, kRun, 7, 8, -1, 0, 0));
1328 else if (i == 12)
1329 CPPUNIT_ASSERT(check(iterFirst, kLumi, 7, 8, -1, 0, 0));
1330 else if (i == 13)
1331 CPPUNIT_ASSERT(check(iterFirst, kLumi, 7, 9, 10, 0, 1));
1332 else if (i == 14)
1333 CPPUNIT_ASSERT(check(iterFirst, kLumi, 7, 10, 10, 0, 1));
1334 else if (i == 15)
1335 CPPUNIT_ASSERT(check(iterFirst, kEvent, 7, 10, 10, 0, 1));
1336 else
1337 CPPUNIT_ASSERT(false);
1338
1339 switch (i) {
1340 case 1:
1341 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1342 break;
1343 case 9:
1344 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1345 break;
1346 case 11:
1347 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 6);
1348 break;
1349 }
1350
1351 switch (i) {
1352 case 2:
1353 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
1354 break;
1355 case 9:
1356 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 4);
1357 break;
1358 case 11:
1359 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == IndexIntoFile::invalidIndex);
1360 break;
1361 }
1362 }
1363 CPPUNIT_ASSERT(i == 16);
1364 }
1365
1366 {
1367 edm::IndexIntoFile::IndexIntoFileItr testIter = indexIntoFile.findPosition(11, 103, 7);
1368 CPPUNIT_ASSERT(check(testIter, kRun, 0, 4, 3, 3, 4));
1369 ++testIter;
1370 CPPUNIT_ASSERT(check(testIter, kLumi, 0, 4, 3, 3, 4));
1371 ++testIter;
1372 CPPUNIT_ASSERT(check(testIter, kEvent, 0, 4, 3, 3, 4));
1373 ++testIter;
1374 CPPUNIT_ASSERT(check(testIter, kLumi, 0, 5, -1, 0, 0));
1375 }
1376 {
1377 edm::IndexIntoFile::IndexIntoFileItr testIter = indexIntoFile.findPosition(11, 0, 7);
1378 CPPUNIT_ASSERT(check(testIter, kRun, 0, 4, 3, 3, 4));
1379 ++testIter;
1380 CPPUNIT_ASSERT(check(testIter, kLumi, 0, 4, 3, 3, 4));
1381 ++testIter;
1382 CPPUNIT_ASSERT(check(testIter, kEvent, 0, 4, 3, 3, 4));
1383 ++testIter;
1384 CPPUNIT_ASSERT(check(testIter, kLumi, 0, 5, -1, 0, 0));
1385 skipEventBackward(testIter);
1386 CPPUNIT_ASSERT(check(testIter, kLumi, 0, 4, 3, 3, 4));
1387 }
1388 }
1389
1390 void TestIndexIntoFile3::testOverlappingLumisMore() {
1391 edm::IndexIntoFile indexIntoFile;
1392 indexIntoFile.addEntry(fakePHID1, 11, 101, 7, 0);
1393 indexIntoFile.addEntry(fakePHID1, 11, 101, 6, 1);
1394 indexIntoFile.addEntry(fakePHID1, 11, 101, 5, 2);
1395
1396 indexIntoFile.addEntry(fakePHID1, 11, 102, 5, 4);
1397
1398 indexIntoFile.addEntry(fakePHID1, 11, 101, 4, 3);
1399 indexIntoFile.addEntry(fakePHID1, 11, 101, 0, 0);
1400
1401 indexIntoFile.addEntry(fakePHID1, 11, 102, 4, 5);
1402 indexIntoFile.addEntry(fakePHID1, 11, 102, 0, 1);
1403 indexIntoFile.addEntry(fakePHID1, 11, 0, 0, 0);
1404 indexIntoFile.addEntry(fakePHID2, 11, 0, 0, 1);
1405 indexIntoFile.addEntry(fakePHID2, 11, 101, 0, 2);
1406 indexIntoFile.addEntry(fakePHID2, 11, 102, 0, 3);
1407 indexIntoFile.addEntry(fakePHID2, 11, 102, 4, 6);
1408 indexIntoFile.addEntry(fakePHID2, 11, 102, 0, 4);
1409 indexIntoFile.addEntry(fakePHID2, 11, 0, 0, 2);
1410 indexIntoFile.sortVector_Run_Or_Lumi_Entries();
1411
1412 std::vector<LuminosityBlockNumber_t> lumis;
1413
1414 {
1415 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
1416 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
1417 int i = 0;
1418 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
1419 switch (i) {
1420 case 0: {
1421 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 2, 1, 0, 3));
1422 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
1423 CPPUNIT_ASSERT(iterFirst.size() == 10);
1424
1425 iterFirst.getLumisInRun(lumis);
1426 std::vector<LuminosityBlockNumber_t> expected{101, 102};
1427 CPPUNIT_ASSERT(lumis == expected);
1428 break;
1429 }
1430
1431 case 1: {
1432 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 2, 1, 0, 3));
1433 break;
1434 }
1435 case 2: {
1436 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 0, 3));
1437 break;
1438 }
1439 case 3: {
1440 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 1, 3));
1441 break;
1442 }
1443 case 4: {
1444 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 2, 3));
1445 break;
1446 }
1447 case 5: {
1448 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 2, 0, 1));
1449 break;
1450 }
1451 case 6: {
1452 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 3, 0, 1));
1453 break;
1454 }
1455 case 7: {
1456 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 3, 0, 1));
1457 break;
1458 }
1459 case 8: {
1460 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 0, 1));
1461 break;
1462 }
1463 case 9: {
1464 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
1465
1466 iterFirst.getLumisInRun(lumis);
1467 std::vector<LuminosityBlockNumber_t> expected{101, 102};
1468 CPPUNIT_ASSERT(lumis == expected);
1469 break;
1470 }
1471 case 10: {
1472 CPPUNIT_ASSERT(check(iterFirst, kRun, 6, 7, -1, 0, 0));
1473 break;
1474 }
1475 case 11: {
1476 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 7, -1, 0, 0));
1477 break;
1478 }
1479 case 12: {
1480 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 8, 9, 0, 1));
1481 break;
1482 }
1483 case 13: {
1484 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 9, 9, 0, 1));
1485 break;
1486 }
1487 case 14: {
1488 CPPUNIT_ASSERT(check(iterFirst, kEvent, 6, 9, 9, 0, 1));
1489 break;
1490 }
1491 default: {
1492 CPPUNIT_ASSERT(false);
1493 }
1494 }
1495
1496 switch (i) {
1497 case 0:
1498 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1499 break;
1500 case 8:
1501 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1502 break;
1503 case 10:
1504 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 6);
1505 break;
1506 }
1507
1508 switch (i) {
1509 case 0:
1510 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
1511 break;
1512 case 8:
1513 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 4);
1514 break;
1515 case 10:
1516 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == IndexIntoFile::invalidIndex);
1517 break;
1518 }
1519 }
1520 CPPUNIT_ASSERT(i == 15);
1521 }
1522
1523 {
1524 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::entryOrder);
1525 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::entryOrder);
1526 int i = 0;
1527 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
1528 switch (i) {
1529 case 0: {
1530 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 2, 1, 0, 3));
1531 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
1532 CPPUNIT_ASSERT(iterFirst.size() == 10);
1533
1534 iterFirst.getLumisInRun(lumis);
1535 std::vector<LuminosityBlockNumber_t> expected{101, 102};
1536 CPPUNIT_ASSERT(lumis == expected);
1537 break;
1538 }
1539
1540 case 1: {
1541 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 2, 1, 0, 3));
1542 break;
1543 }
1544 case 2: {
1545 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 0, 3));
1546 break;
1547 }
1548 case 3: {
1549 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 1, 3));
1550 break;
1551 }
1552 case 4: {
1553 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 2, 3));
1554 break;
1555 }
1556 case 5: {
1557 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 2, 0, 1));
1558 break;
1559 }
1560 case 6: {
1561 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 3, 0, 1));
1562 break;
1563 }
1564 case 7: {
1565 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 3, 0, 1));
1566 break;
1567 }
1568 case 8: {
1569 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 0, 1));
1570 break;
1571 }
1572 case 9: {
1573 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
1574
1575 iterFirst.getLumisInRun(lumis);
1576 std::vector<LuminosityBlockNumber_t> expected{101, 102};
1577 CPPUNIT_ASSERT(lumis == expected);
1578 break;
1579 }
1580 case 10: {
1581 CPPUNIT_ASSERT(check(iterFirst, kRun, 6, 7, -1, 0, 0));
1582 break;
1583 }
1584 case 11: {
1585 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 7, -1, 0, 0));
1586 break;
1587 }
1588 case 12: {
1589 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 8, 9, 0, 1));
1590 break;
1591 }
1592 case 13: {
1593 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 9, 9, 0, 1));
1594 break;
1595 }
1596 case 14: {
1597 CPPUNIT_ASSERT(check(iterFirst, kEvent, 6, 9, 9, 0, 1));
1598 break;
1599 }
1600 default:
1601 CPPUNIT_ASSERT(false);
1602 }
1603
1604 switch (i) {
1605 case 0:
1606 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1607 break;
1608 case 8:
1609 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1610 break;
1611 case 10:
1612 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 6);
1613 break;
1614 }
1615
1616 switch (i) {
1617 case 0:
1618 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
1619 break;
1620 case 8:
1621 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 4);
1622 break;
1623 case 10:
1624 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == IndexIntoFile::invalidIndex);
1625 break;
1626 }
1627 }
1628 CPPUNIT_ASSERT(i == 15);
1629 }
1630 }
1631
1632 void TestIndexIntoFile3::testOverlappingLumisOutOfOrderEvent() {
1633 edm::IndexIntoFile indexIntoFile;
1634 indexIntoFile.addEntry(fakePHID1, 11, 101, 7, 0);
1635 indexIntoFile.addEntry(fakePHID1, 11, 101, 6, 1);
1636 indexIntoFile.addEntry(fakePHID1, 11, 101, 5, 2);
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648 indexIntoFile.addEntry(fakePHID1, 11, 102, 5, 3);
1649
1650 indexIntoFile.addEntry(fakePHID1, 11, 101, 4, 4);
1651 indexIntoFile.addEntry(fakePHID1, 11, 101, 0, 0);
1652
1653 indexIntoFile.addEntry(fakePHID1, 11, 102, 4, 5);
1654 indexIntoFile.addEntry(fakePHID1, 11, 102, 0, 1);
1655 indexIntoFile.addEntry(fakePHID1, 11, 0, 0, 0);
1656 indexIntoFile.addEntry(fakePHID2, 11, 0, 0, 1);
1657 indexIntoFile.addEntry(fakePHID2, 11, 101, 0, 2);
1658 indexIntoFile.addEntry(fakePHID2, 11, 102, 0, 3);
1659 indexIntoFile.addEntry(fakePHID2, 11, 102, 4, 6);
1660 indexIntoFile.addEntry(fakePHID2, 11, 102, 0, 4);
1661 indexIntoFile.addEntry(fakePHID2, 11, 0, 0, 2);
1662 indexIntoFile.sortVector_Run_Or_Lumi_Entries();
1663
1664 std::vector<LuminosityBlockNumber_t> lumis;
1665
1666 {
1667 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
1668 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
1669 int i = 0;
1670 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
1671 switch (i) {
1672 case 0: {
1673 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 2, 1, 0, 3));
1674 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
1675 CPPUNIT_ASSERT(iterFirst.size() == 10);
1676
1677 iterFirst.getLumisInRun(lumis);
1678 std::vector<LuminosityBlockNumber_t> expected{101, 102};
1679 CPPUNIT_ASSERT(lumis == expected);
1680 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1681 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
1682 break;
1683 }
1684
1685 case 1: {
1686 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 2, 1, 0, 3));
1687 break;
1688 }
1689 case 2: {
1690 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 0, 3));
1691 break;
1692 }
1693 case 3: {
1694 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 1, 3));
1695 break;
1696 }
1697 case 4: {
1698 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 1, 2, 3));
1699 break;
1700 }
1701 case 5: {
1702 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 2, 0, 1));
1703 break;
1704 }
1705 case 6: {
1706 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 3, 0, 1));
1707 break;
1708 }
1709 case 7: {
1710 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 3, 0, 1));
1711 break;
1712 }
1713 case 8: {
1714 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 0, 1));
1715 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1716 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 3);
1717 break;
1718 }
1719 case 9: {
1720 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
1721
1722 iterFirst.getLumisInRun(lumis);
1723 std::vector<LuminosityBlockNumber_t> expected{101, 102};
1724 CPPUNIT_ASSERT(lumis == expected);
1725 break;
1726 }
1727 case 10: {
1728 CPPUNIT_ASSERT(check(iterFirst, kRun, 6, 7, -1, 0, 0));
1729 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 6);
1730 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == IndexIntoFile::invalidIndex);
1731 break;
1732 }
1733 case 11: {
1734 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 7, -1, 0, 0));
1735 break;
1736 }
1737 case 12: {
1738 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 8, 9, 0, 1));
1739 break;
1740 }
1741 case 13: {
1742 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 9, 9, 0, 1));
1743 break;
1744 }
1745 case 14: {
1746 CPPUNIT_ASSERT(check(iterFirst, kEvent, 6, 9, 9, 0, 1));
1747 break;
1748 }
1749 default: {
1750 CPPUNIT_ASSERT(false);
1751 }
1752 }
1753 }
1754 CPPUNIT_ASSERT(i == 15);
1755 }
1756
1757 {
1758 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::entryOrder);
1759 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::entryOrder);
1760 int i = 0;
1761 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
1762
1763
1764
1765 switch (i) {
1766 case 0: {
1767 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 1, 0, 3));
1768 CPPUNIT_ASSERT(iterFirst.processHistoryIDIndex() == 0);
1769 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
1770 CPPUNIT_ASSERT(iterFirst.size() == 10);
1771 CPPUNIT_ASSERT(iterFirst.shouldProcessRun());
1772
1773 iterFirst.getLumisInRun(lumis);
1774 std::vector<LuminosityBlockNumber_t> expected{101, 102};
1775 CPPUNIT_ASSERT(lumis == expected);
1776 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1777 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
1778 break;
1779 }
1780
1781 case 1: {
1782 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, 1, 0, 3));
1783 CPPUNIT_ASSERT(iterFirst.processHistoryIDIndex() == 0);
1784 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
1785 break;
1786 }
1787 case 2: {
1788 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 1, 1, 0, 3));
1789 CPPUNIT_ASSERT(iterFirst.processHistoryIDIndex() == 0);
1790 break;
1791 }
1792 case 3: {
1793 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 1, 1, 1, 3));
1794 break;
1795 }
1796 case 4: {
1797 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 1, 1, 2, 3));
1798 break;
1799 }
1800 case 5: {
1801 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 2, 2, 0, 1));
1802 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
1803 break;
1804 }
1805 case 6: {
1806 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 2, 0, 1));
1807 break;
1808 }
1809 case 7: {
1810 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 3, 3, 0, 1));
1811 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
1812 break;
1813 }
1814 case 8: {
1815 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 3, 0, 1));
1816 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1817 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 4);
1818 break;
1819 }
1820 case 9: {
1821 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 0, 1));
1822 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
1823 break;
1824 }
1825 case 10: {
1826 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 0, 1));
1827 CPPUNIT_ASSERT(iterFirst.processHistoryIDIndex() == 0);
1828 break;
1829 }
1830 case 11: {
1831 CPPUNIT_ASSERT(check(iterFirst, kRun, 5, 7, -1, 0, 0));
1832 CPPUNIT_ASSERT(iterFirst.shouldProcessRun());
1833
1834 iterFirst.getLumisInRun(lumis);
1835 std::vector<LuminosityBlockNumber_t> expected{101, 102};
1836 CPPUNIT_ASSERT(lumis == expected);
1837
1838 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 6);
1839 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == IndexIntoFile::invalidIndex);
1840 break;
1841 }
1842 case 12: {
1843 CPPUNIT_ASSERT(check(iterFirst, kRun, 6, 7, -1, 0, 0));
1844 CPPUNIT_ASSERT(iterFirst.processHistoryIDIndex() == 1);
1845 CPPUNIT_ASSERT(iterFirst.shouldProcessRun());
1846 break;
1847 }
1848 case 13: {
1849 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 7, -1, 0, 0));
1850 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
1851 break;
1852 }
1853 case 14: {
1854 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 8, 9, 0, 1));
1855 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
1856 break;
1857 }
1858 case 15: {
1859 CPPUNIT_ASSERT(check(iterFirst, kLumi, 6, 9, 9, 0, 1));
1860 CPPUNIT_ASSERT(iterFirst.processHistoryIDIndex() == 1);
1861 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
1862 break;
1863 }
1864 case 16: {
1865 CPPUNIT_ASSERT(check(iterFirst, kEvent, 6, 9, 9, 0, 1));
1866 CPPUNIT_ASSERT(iterFirst.processHistoryIDIndex() == 1);
1867 break;
1868 }
1869 default:
1870 CPPUNIT_ASSERT(false);
1871 }
1872 }
1873 CPPUNIT_ASSERT(i == 17);
1874 }
1875 }
1876
1877 void TestIndexIntoFile3::testOverlappingLumisWithEndWithEmptyLumi() {
1878
1879 edm::IndexIntoFile indexIntoFile;
1880 indexIntoFile.addEntry(fakePHID1, 1, 1, 2, 0);
1881 indexIntoFile.addEntry(fakePHID1, 1, 1, 5, 1);
1882 indexIntoFile.addEntry(fakePHID1, 1, 2, 8, 2);
1883 indexIntoFile.addEntry(fakePHID1, 1, 2, 6, 3);
1884 indexIntoFile.addEntry(fakePHID1, 1, 1, 3, 4);
1885 indexIntoFile.addEntry(fakePHID1, 1, 2, 9, 5);
1886 indexIntoFile.addEntry(fakePHID1, 1, 1, 4, 6);
1887 indexIntoFile.addEntry(fakePHID1, 1, 1, 1, 7);
1888 indexIntoFile.addEntry(fakePHID1, 1, 2, 7, 8);
1889 indexIntoFile.addEntry(fakePHID1, 1, 1, 0, 0);
1890 indexIntoFile.addEntry(fakePHID1, 1, 2, 10, 9);
1891 indexIntoFile.addEntry(fakePHID1, 1, 2, 0, 1);
1892 indexIntoFile.addEntry(fakePHID1, 1, 3, 12, 10);
1893 indexIntoFile.addEntry(fakePHID1, 1, 3, 11, 11);
1894 indexIntoFile.addEntry(fakePHID1, 1, 3, 15, 12);
1895 indexIntoFile.addEntry(fakePHID1, 1, 3, 14, 13);
1896 indexIntoFile.addEntry(fakePHID1, 1, 4, 18, 14);
1897 indexIntoFile.addEntry(fakePHID1, 1, 4, 17, 15);
1898 indexIntoFile.addEntry(fakePHID1, 1, 4, 20, 16);
1899 indexIntoFile.addEntry(fakePHID1, 1, 3, 13, 17);
1900 indexIntoFile.addEntry(fakePHID1, 1, 3, 0, 2);
1901 indexIntoFile.addEntry(fakePHID1, 1, 4, 19, 18);
1902 indexIntoFile.addEntry(fakePHID1, 1, 4, 16, 19);
1903 indexIntoFile.addEntry(fakePHID1, 1, 4, 0, 3);
1904 indexIntoFile.addEntry(fakePHID1, 1, 0, 0, 0);
1905 indexIntoFile.sortVector_Run_Or_Lumi_Entries();
1906
1907 std::vector<LuminosityBlockNumber_t> lumis;
1908
1909 {
1910 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
1911 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
1912 int i = 0;
1913 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
1914
1915
1916
1917 switch (i) {
1918 case 0: {
1919 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 4, 1, 0, 2));
1920 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
1921 CPPUNIT_ASSERT(iterFirst.size() == 13);
1922 iterFirst.getLumisInRun(lumis);
1923 std::vector<LuminosityBlockNumber_t> expected{1, 2, 3, 4};
1924 CPPUNIT_ASSERT(lumis == expected);
1925 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1926 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
1927 break;
1928 }
1929
1930 case 1: {
1931 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 1, 0, 2));
1932 break;
1933 }
1934 case 2: {
1935 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 1, 0, 2));
1936 break;
1937 }
1938 case 3: {
1939 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 1, 1, 2));
1940 break;
1941 }
1942 case 4: {
1943 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 2, 0, 1));
1944 break;
1945 }
1946 case 5: {
1947 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 3, 0, 2));
1948 break;
1949 }
1950 case 6: {
1951 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 3, 1, 2));
1952 break;
1953 }
1954 case 7: {
1955 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 8, 5, 0, 2));
1956 break;
1957 }
1958 case 8: {
1959 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 5, 0, 2));
1960 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
1961 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 2);
1962 break;
1963 }
1964 case 9: {
1965 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 5, 1, 2));
1966 break;
1967 }
1968 case 10: {
1969 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 6, 0, 1));
1970 break;
1971 }
1972 case 11: {
1973 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 7, 0, 1));
1974 break;
1975 }
1976 case 12: {
1977 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 8, 0, 1));
1978 break;
1979 }
1980 case 13: {
1981 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 10, 9, 0, 4));
1982 break;
1983 }
1984 case 14: {
1985 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 9, 0, 4));
1986 break;
1987 }
1988 case 15: {
1989 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 9, 1, 4));
1990 break;
1991 }
1992 case 16: {
1993 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 9, 2, 4));
1994 break;
1995 }
1996 case 17: {
1997 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 9, 3, 4));
1998 break;
1999 }
2000 case 18: {
2001 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 10, 0, 1));
2002 break;
2003 }
2004 case 19: {
2005 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 12, 11, 0, 3));
2006 break;
2007 }
2008 case 20: {
2009 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 12, 11, 0, 3));
2010 break;
2011 }
2012 case 21: {
2013 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 12, 11, 1, 3));
2014 break;
2015 }
2016 case 22: {
2017 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 12, 11, 2, 3));
2018 break;
2019 }
2020 case 23: {
2021 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 12, 12, 0, 2));
2022 break;
2023 }
2024 case 24: {
2025 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 12, 12, 1, 2));
2026 break;
2027 }
2028 default: {
2029 CPPUNIT_ASSERT(false);
2030 }
2031 }
2032 }
2033 CPPUNIT_ASSERT(i == 25);
2034 }
2035
2036 {
2037 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::entryOrder);
2038 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::entryOrder);
2039 int i = 0;
2040 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
2041
2042
2043
2044 switch (i) {
2045 case 0: {
2046 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 1, 0, 2));
2047 CPPUNIT_ASSERT(iterFirst.run() == 1);
2048 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
2049 CPPUNIT_ASSERT(iterFirst.size() == 13);
2050 CPPUNIT_ASSERT(iterFirst.shouldProcessRun());
2051
2052 iterFirst.getLumisInRun(lumis);
2053 std::vector<LuminosityBlockNumber_t> expected{1, 2, 3, 4};
2054
2055 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
2056 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
2057 break;
2058 }
2059
2060 case 1: {
2061 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, 1, 0, 2));
2062 CPPUNIT_ASSERT(iterFirst.lumi() == 1);
2063 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2064 break;
2065 }
2066 case 2: {
2067 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 1, 1, 0, 2));
2068 break;
2069 }
2070 case 3: {
2071 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 1, 1, 1, 2));
2072 break;
2073 }
2074 case 4: {
2075 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 2, 2, 0, 2));
2076 CPPUNIT_ASSERT(iterFirst.lumi() == 2);
2077 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2078 break;
2079 }
2080 case 5: {
2081 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 2, 0, 2));
2082 break;
2083 }
2084 case 6: {
2085 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 2, 1, 2));
2086 break;
2087 }
2088 case 7: {
2089 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 3, 3, 0, 1));
2090 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2091 CPPUNIT_ASSERT(iterFirst.lumi() == 1);
2092 break;
2093 }
2094 case 8: {
2095 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 3, 0, 1));
2096 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
2097 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 4);
2098 break;
2099 }
2100 case 9: {
2101 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 0, 1));
2102 CPPUNIT_ASSERT(iterFirst.lumi() == 2);
2103 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2104 break;
2105 }
2106 case 10: {
2107 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 0, 1));
2108 break;
2109 }
2110 case 11: {
2111 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 6, 5, 0, 2));
2112 CPPUNIT_ASSERT(iterFirst.lumi() == 1);
2113 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
2114 break;
2115 }
2116 case 12: {
2117 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 6, 5, 0, 2));
2118 break;
2119 }
2120 case 13: {
2121 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 6, 5, 1, 2));
2122 break;
2123 }
2124 case 14: {
2125 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 8, 7, 0, 1));
2126 CPPUNIT_ASSERT(iterFirst.lumi() == 2);
2127 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
2128 break;
2129 }
2130 case 15: {
2131 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 7, 0, 1));
2132 break;
2133 }
2134 case 16: {
2135 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 8, 0, 1));
2136 CPPUNIT_ASSERT(iterFirst.lumi() == 2);
2137 break;
2138 }
2139 case 17: {
2140 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 9, 9, 0, 4));
2141 CPPUNIT_ASSERT(iterFirst.lumi() == 3);
2142 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2143 break;
2144 }
2145 case 18: {
2146 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 9, 0, 4));
2147 break;
2148 }
2149 case 19: {
2150 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 9, 1, 4));
2151 break;
2152 }
2153 case 20: {
2154 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 9, 2, 4));
2155 break;
2156 }
2157 case 21: {
2158 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 9, 3, 4));
2159 break;
2160 }
2161 case 22: {
2162 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 10, 10, 0, 3));
2163 CPPUNIT_ASSERT(iterFirst.lumi() == 4);
2164 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2165 break;
2166 }
2167 case 23: {
2168 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 10, 0, 3));
2169 break;
2170 }
2171 case 24: {
2172 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 10, 1, 3));
2173 break;
2174 }
2175 case 25: {
2176 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 10, 2, 3));
2177 break;
2178 }
2179 case 26: {
2180 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 11, 11, 0, 1));
2181 CPPUNIT_ASSERT(iterFirst.lumi() == 3);
2182 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
2183 break;
2184 }
2185 case 27: {
2186 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 11, 11, 0, 1));
2187 break;
2188 }
2189 case 28: {
2190 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 12, 12, 0, 2));
2191 CPPUNIT_ASSERT(iterFirst.lumi() == 4);
2192 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
2193 break;
2194 }
2195 case 29: {
2196 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 12, 12, 0, 2));
2197 break;
2198 }
2199 case 30: {
2200 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 12, 12, 1, 2));
2201 break;
2202 }
2203
2204 default:
2205 CPPUNIT_ASSERT(false);
2206 }
2207 }
2208 CPPUNIT_ASSERT(i == 31);
2209 }
2210 }
2211
2212 void TestIndexIntoFile3::testOverlappingLumisWithLumiEndOrderChanged() {
2213
2214 edm::IndexIntoFile indexIntoFile;
2215 indexIntoFile.addEntry(fakePHID1, 1, 1, 2, 0);
2216 indexIntoFile.addEntry(fakePHID1, 1, 1, 5, 1);
2217 indexIntoFile.addEntry(fakePHID1, 1, 2, 8, 2);
2218 indexIntoFile.addEntry(fakePHID1, 1, 2, 6, 3);
2219 indexIntoFile.addEntry(fakePHID1, 1, 1, 3, 4);
2220 indexIntoFile.addEntry(fakePHID1, 1, 2, 9, 5);
2221 indexIntoFile.addEntry(fakePHID1, 1, 1, 4, 6);
2222 indexIntoFile.addEntry(fakePHID1, 1, 2, 7, 7);
2223 indexIntoFile.addEntry(fakePHID1, 1, 2, 10, 8);
2224 indexIntoFile.addEntry(fakePHID1, 1, 2, 0, 0);
2225 indexIntoFile.addEntry(fakePHID1, 1, 1, 1, 9);
2226 indexIntoFile.addEntry(fakePHID1, 1, 1, 0, 1);
2227 indexIntoFile.addEntry(fakePHID1, 1, 3, 12, 10);
2228 indexIntoFile.addEntry(fakePHID1, 1, 3, 11, 11);
2229 indexIntoFile.addEntry(fakePHID1, 1, 3, 15, 12);
2230 indexIntoFile.addEntry(fakePHID1, 1, 3, 14, 13);
2231 indexIntoFile.addEntry(fakePHID1, 1, 4, 18, 14);
2232 indexIntoFile.addEntry(fakePHID1, 1, 4, 17, 15);
2233 indexIntoFile.addEntry(fakePHID1, 1, 4, 20, 16);
2234 indexIntoFile.addEntry(fakePHID1, 1, 4, 19, 17);
2235 indexIntoFile.addEntry(fakePHID1, 1, 4, 16, 18);
2236 indexIntoFile.addEntry(fakePHID1, 1, 4, 0, 2);
2237 indexIntoFile.addEntry(fakePHID1, 1, 3, 13, 19);
2238 indexIntoFile.addEntry(fakePHID1, 1, 3, 0, 3);
2239 indexIntoFile.addEntry(fakePHID1, 1, 0, 0, 0);
2240 indexIntoFile.sortVector_Run_Or_Lumi_Entries();
2241
2242 std::vector<LuminosityBlockNumber_t> lumis;
2243
2244 {
2245 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::firstAppearanceOrder);
2246 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::firstAppearanceOrder);
2247 int i = 0;
2248 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
2249
2250
2251
2252 switch (i) {
2253 case 0: {
2254 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 4, 1, 0, 2));
2255 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
2256 CPPUNIT_ASSERT(iterFirst.size() == 11);
2257 iterFirst.getLumisInRun(lumis);
2258 std::vector<LuminosityBlockNumber_t> expected{1, 2, 3, 4};
2259 CPPUNIT_ASSERT(lumis == expected);
2260 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
2261 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
2262 break;
2263 }
2264
2265 case 1: {
2266 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 1, 0, 2));
2267 break;
2268 }
2269 case 2: {
2270 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 1, 0, 2));
2271 break;
2272 }
2273 case 3: {
2274 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 1, 1, 2));
2275 break;
2276 }
2277 case 4: {
2278 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 2, 0, 1));
2279 break;
2280 }
2281 case 5: {
2282 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 3, 0, 1));
2283 break;
2284 }
2285 case 6: {
2286 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 0, 1));
2287 break;
2288 }
2289 case 7: {
2290 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 7, 5, 0, 2));
2291 break;
2292 }
2293 case 8: {
2294 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 7, 5, 0, 2));
2295 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
2296 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 2);
2297 break;
2298 }
2299 case 9: {
2300 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 7, 5, 1, 2));
2301 break;
2302 }
2303 case 10: {
2304 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 7, 6, 0, 1));
2305 break;
2306 }
2307 case 11: {
2308 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 7, 7, 0, 2));
2309 break;
2310 }
2311 case 12: {
2312 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 7, 7, 1, 2));
2313 break;
2314 }
2315 case 13: {
2316 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 9, 8, 0, 4));
2317 break;
2318 }
2319 case 14: {
2320 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 8, 0, 4));
2321 break;
2322 }
2323 case 15: {
2324 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 8, 1, 4));
2325 break;
2326 }
2327 case 16: {
2328 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 8, 2, 4));
2329 break;
2330 }
2331 case 17: {
2332 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 8, 3, 4));
2333 break;
2334 }
2335 case 18: {
2336 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 9, 0, 1));
2337 break;
2338 }
2339 case 19: {
2340 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 10, 10, 0, 5));
2341 break;
2342 }
2343 case 20: {
2344 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 10, 0, 5));
2345 break;
2346 }
2347 case 21: {
2348 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 10, 1, 5));
2349 break;
2350 }
2351 case 22: {
2352 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 10, 2, 5));
2353 break;
2354 }
2355 case 23: {
2356 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 10, 3, 5));
2357 break;
2358 }
2359 case 24: {
2360 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 10, 4, 5));
2361 break;
2362 }
2363 default: {
2364 CPPUNIT_ASSERT(false);
2365 }
2366 }
2367 }
2368 CPPUNIT_ASSERT(i == 25);
2369 }
2370
2371 {
2372 edm::IndexIntoFile::IndexIntoFileItr iterFirst = indexIntoFile.begin(IndexIntoFile::entryOrder);
2373 edm::IndexIntoFile::IndexIntoFileItr iterFirstEnd = indexIntoFile.end(IndexIntoFile::entryOrder);
2374 int i = 0;
2375 for (i = 0; iterFirst != iterFirstEnd; ++iterFirst, ++i) {
2376
2377
2378
2379 switch (i) {
2380 case 0: {
2381 CPPUNIT_ASSERT(check(iterFirst, kRun, 0, 1, 1, 0, 2));
2382 CPPUNIT_ASSERT(iterFirst.shouldProcessRun());
2383 CPPUNIT_ASSERT(iterFirst.run() == 1);
2384 CPPUNIT_ASSERT(iterFirst.indexIntoFile() == &indexIntoFile);
2385 CPPUNIT_ASSERT(iterFirst.size() == 11);
2386
2387 iterFirst.getLumisInRun(lumis);
2388 std::vector<LuminosityBlockNumber_t> expected{1, 2, 3, 4};
2389
2390 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
2391 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 0);
2392 break;
2393 }
2394
2395 case 1: {
2396 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 1, 1, 0, 2));
2397 CPPUNIT_ASSERT(iterFirst.lumi() == 1);
2398 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2399 break;
2400 }
2401 case 2: {
2402 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 1, 1, 0, 2));
2403 break;
2404 }
2405 case 3: {
2406 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 1, 1, 1, 2));
2407 break;
2408 }
2409 case 4: {
2410 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 2, 2, 0, 2));
2411 CPPUNIT_ASSERT(iterFirst.lumi() == 2);
2412 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2413 break;
2414 }
2415 case 5: {
2416 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 2, 0, 2));
2417 break;
2418 }
2419 case 6: {
2420 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 2, 2, 1, 2));
2421 break;
2422 }
2423 case 7: {
2424 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 3, 3, 0, 1));
2425 CPPUNIT_ASSERT(iterFirst.lumi() == 1);
2426 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2427 break;
2428 }
2429 case 8: {
2430 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 3, 3, 0, 1));
2431 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisRun() == 0);
2432 CPPUNIT_ASSERT(iterFirst.firstEventEntryThisLumi() == 4);
2433 break;
2434 }
2435 case 9: {
2436 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 4, 4, 0, 1));
2437 CPPUNIT_ASSERT(iterFirst.lumi() == 2);
2438 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2439 break;
2440 }
2441 case 10: {
2442 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 4, 4, 0, 1));
2443 break;
2444 }
2445 case 11: {
2446 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 5, 5, 0, 1));
2447 CPPUNIT_ASSERT(iterFirst.lumi() == 1);
2448 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2449 break;
2450 }
2451 case 12: {
2452 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 5, 5, 0, 1));
2453 break;
2454 }
2455 case 13: {
2456 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 6, 6, 0, 2));
2457 CPPUNIT_ASSERT(iterFirst.lumi() == 2);
2458 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
2459 break;
2460 }
2461 case 14: {
2462 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 6, 6, 0, 2));
2463 break;
2464 }
2465 case 15: {
2466 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 6, 6, 1, 2));
2467 CPPUNIT_ASSERT(iterFirst.lumi() == 2);
2468 break;
2469 }
2470 case 16: {
2471 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 7, 7, 0, 1));
2472 CPPUNIT_ASSERT(iterFirst.lumi() == 1);
2473 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
2474 break;
2475 }
2476 case 17: {
2477 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 7, 7, 0, 1));
2478 break;
2479 }
2480 case 18: {
2481 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 8, 8, 0, 4));
2482 CPPUNIT_ASSERT(iterFirst.lumi() == 3);
2483 CPPUNIT_ASSERT(!iterFirst.shouldProcessLumi());
2484 break;
2485 }
2486 case 19: {
2487 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 8, 0, 4));
2488 break;
2489 }
2490 case 20: {
2491 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 8, 1, 4));
2492 break;
2493 }
2494 case 21: {
2495 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 8, 2, 4));
2496 break;
2497 }
2498 case 22: {
2499 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 8, 8, 3, 4));
2500 break;
2501 }
2502 case 23: {
2503 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 9, 9, 0, 5));
2504 CPPUNIT_ASSERT(iterFirst.lumi() == 4);
2505 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
2506 break;
2507 }
2508 case 24: {
2509 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 9, 0, 5));
2510 break;
2511 }
2512 case 25: {
2513 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 9, 1, 5));
2514 break;
2515 }
2516 case 26: {
2517 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 9, 2, 5));
2518 break;
2519 }
2520 case 27: {
2521 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 9, 3, 5));
2522 break;
2523 }
2524 case 28: {
2525 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 9, 9, 4, 5));
2526 break;
2527 }
2528 case 29: {
2529 CPPUNIT_ASSERT(check(iterFirst, kLumi, 0, 10, 10, 0, 1));
2530 CPPUNIT_ASSERT(iterFirst.lumi() == 3);
2531 CPPUNIT_ASSERT(iterFirst.shouldProcessLumi());
2532 break;
2533 }
2534 case 30: {
2535 CPPUNIT_ASSERT(check(iterFirst, kEvent, 0, 10, 10, 0, 1));
2536 break;
2537 }
2538
2539 default:
2540 CPPUNIT_ASSERT(false);
2541 }
2542 }
2543 CPPUNIT_ASSERT(i == 31);
2544 }
2545 }
2546
2547 void TestIndexIntoFile3::testNonContiguousRun() {
2548 edm::IndexIntoFile indexIntoFile;
2549 indexIntoFile.addEntry(fakePHID1, 1, 1, 1, 0);
2550 indexIntoFile.addEntry(fakePHID1, 2, 1, 1, 1);
2551 indexIntoFile.addEntry(fakePHID1, 1, 1, 2, 2);
2552 indexIntoFile.addEntry(fakePHID1, 1, 1, 0, 0);
2553 indexIntoFile.addEntry(fakePHID1, 1, 0, 0, 0);
2554 indexIntoFile.addEntry(fakePHID1, 2, 1, 0, 1);
2555 indexIntoFile.addEntry(fakePHID1, 2, 0, 0, 1);
2556
2557 indexIntoFile.addEntry(fakePHID1, 1, 1, 3, 3);
2558 indexIntoFile.addEntry(fakePHID1, 2, 1, 2, 4);
2559 indexIntoFile.addEntry(fakePHID1, 1, 1, 4, 5);
2560 indexIntoFile.addEntry(fakePHID1, 1, 1, 0, 2);
2561 indexIntoFile.addEntry(fakePHID1, 1, 0, 0, 2);
2562 indexIntoFile.addEntry(fakePHID1, 2, 1, 0, 3);
2563 indexIntoFile.addEntry(fakePHID1, 2, 0, 0, 3);
2564
2565 indexIntoFile.sortVector_Run_Or_Lumi_Entries();
2566 {
2567 edm::IndexIntoFile::IndexIntoFileItr iter = indexIntoFile.begin(IndexIntoFile::entryOrder);
2568 edm::IndexIntoFile::IndexIntoFileItr iterEnd = indexIntoFile.end(IndexIntoFile::entryOrder);
2569 int i = 0;
2570 for (i = 0; iter != iterEnd; ++iter, ++i) {
2571 switch (i) {
2572 case 0: {
2573 CPPUNIT_ASSERT(check(iter, kRun, 0, 1, 1, 0, 1));
2574 CPPUNIT_ASSERT(iter.size() == 12);
2575 CPPUNIT_ASSERT(iter.indexedSize() == 16);
2576 CPPUNIT_ASSERT(!iter.shouldProcessRun());
2577 CPPUNIT_ASSERT(iter.entry() == 0);
2578 break;
2579 }
2580 case 1: {
2581 CPPUNIT_ASSERT(check(iter, kLumi, 0, 1, 1, 0, 1));
2582 CPPUNIT_ASSERT(!iter.shouldProcessLumi());
2583
2584
2585 CPPUNIT_ASSERT(iter.entry() == 0);
2586 break;
2587 }
2588 case 2: {
2589 CPPUNIT_ASSERT(check(iter, kEvent, 0, 1, 1, 0, 1));
2590 CPPUNIT_ASSERT(iter.entry() == 0);
2591 break;
2592 }
2593 case 3: {
2594 CPPUNIT_ASSERT(check(iter, kRun, 2, 3, 3, 0, 1));
2595 CPPUNIT_ASSERT(!iter.shouldProcessRun());
2596 CPPUNIT_ASSERT(iter.entry() == 1);
2597 break;
2598 }
2599 case 4: {
2600 CPPUNIT_ASSERT(check(iter, kLumi, 2, 3, 3, 0, 1));
2601 CPPUNIT_ASSERT(!iter.shouldProcessLumi());
2602 CPPUNIT_ASSERT(iter.entry() == 1);
2603 break;
2604 }
2605 case 5: {
2606 CPPUNIT_ASSERT(check(iter, kEvent, 2, 3, 3, 0, 1));
2607 CPPUNIT_ASSERT(iter.entry() == 1);
2608 break;
2609 }
2610 case 6: {
2611 CPPUNIT_ASSERT(check(iter, kRun, 4, 5, 5, 0, 1));
2612 CPPUNIT_ASSERT(!iter.shouldProcessRun());
2613 CPPUNIT_ASSERT(iter.entry() == 0);
2614 break;
2615 }
2616 case 7: {
2617 CPPUNIT_ASSERT(check(iter, kLumi, 4, 5, 5, 0, 1));
2618 CPPUNIT_ASSERT(!iter.shouldProcessLumi());
2619 CPPUNIT_ASSERT(iter.entry() == 0);
2620 break;
2621 }
2622 case 8: {
2623 CPPUNIT_ASSERT(check(iter, kLumi, 4, 6, 5, 0, 1));
2624 CPPUNIT_ASSERT(!iter.shouldProcessLumi());
2625 CPPUNIT_ASSERT(iter.entry() == 0);
2626 break;
2627 }
2628 case 9: {
2629 CPPUNIT_ASSERT(check(iter, kEvent, 4, 6, 5, 0, 1));
2630 CPPUNIT_ASSERT(iter.entry() == 2);
2631 break;
2632 }
2633 case 10: {
2634 CPPUNIT_ASSERT(check(iter, kEvent, 4, 6, 6, 0, 1));
2635 CPPUNIT_ASSERT(iter.entry() == 3);
2636 break;
2637 }
2638 case 11: {
2639 CPPUNIT_ASSERT(check(iter, kRun, 7, 10, 9, 0, 1));
2640 CPPUNIT_ASSERT(iter.shouldProcessRun());
2641 CPPUNIT_ASSERT(iter.entry() == 1);
2642 break;
2643 }
2644 case 12: {
2645 CPPUNIT_ASSERT(check(iter, kRun, 8, 10, 9, 0, 1));
2646 CPPUNIT_ASSERT(iter.shouldProcessRun());
2647 CPPUNIT_ASSERT(iter.entry() == 3);
2648 break;
2649 }
2650 case 13: {
2651 CPPUNIT_ASSERT(check(iter, kLumi, 8, 10, 9, 0, 1));
2652 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2653 CPPUNIT_ASSERT(iter.entry() == 1);
2654 break;
2655 }
2656 case 14: {
2657 CPPUNIT_ASSERT(check(iter, kLumi, 8, 11, 9, 0, 1));
2658 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2659 CPPUNIT_ASSERT(iter.entry() == 3);
2660 break;
2661 }
2662 case 15: {
2663 CPPUNIT_ASSERT(check(iter, kEvent, 8, 11, 9, 0, 1));
2664 CPPUNIT_ASSERT(iter.entry() == 4);
2665 break;
2666 }
2667 case 16: {
2668 CPPUNIT_ASSERT(check(iter, kRun, 12, 14, 15, 0, 1));
2669 CPPUNIT_ASSERT(iter.shouldProcessRun());
2670 CPPUNIT_ASSERT(iter.entry() == 0);
2671 break;
2672 }
2673 case 17: {
2674 CPPUNIT_ASSERT(check(iter, kRun, 13, 14, 15, 0, 1));
2675 CPPUNIT_ASSERT(iter.shouldProcessRun());
2676 CPPUNIT_ASSERT(iter.entry() == 2);
2677 break;
2678 }
2679 case 18: {
2680 CPPUNIT_ASSERT(check(iter, kLumi, 13, 14, 15, 0, 1));
2681 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2682 CPPUNIT_ASSERT(iter.entry() == 0);
2683 break;
2684 }
2685 case 19: {
2686 CPPUNIT_ASSERT(check(iter, kLumi, 13, 15, 15, 0, 1));
2687 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2688 CPPUNIT_ASSERT(iter.entry() == 2);
2689 break;
2690 }
2691 case 20: {
2692 CPPUNIT_ASSERT(check(iter, kEvent, 13, 15, 15, 0, 1));
2693 CPPUNIT_ASSERT(iter.entry() == 5);
2694 break;
2695 }
2696 default:
2697 CPPUNIT_ASSERT(false);
2698 }
2699 }
2700 CPPUNIT_ASSERT(i == 21);
2701 }
2702 }
2703
2704 void TestIndexIntoFile3::testNonValidLumiInsideValidLumis() {
2705 edm::IndexIntoFile indexIntoFile;
2706 indexIntoFile.addEntry(fakePHID1, 1, 1, 1, 0);
2707 indexIntoFile.addEntry(fakePHID1, 1, 2, 0, 0);
2708 indexIntoFile.addEntry(fakePHID1, 1, 1, 2, 1);
2709 indexIntoFile.addEntry(fakePHID1, 1, 1, 0, 1);
2710 indexIntoFile.addEntry(fakePHID1, 1, 2, 0, 2);
2711 indexIntoFile.addEntry(fakePHID1, 1, 1, 3, 2);
2712 indexIntoFile.addEntry(fakePHID1, 1, 2, 0, 3);
2713 indexIntoFile.addEntry(fakePHID1, 1, 1, 4, 3);
2714 indexIntoFile.addEntry(fakePHID1, 1, 1, 0, 4);
2715 indexIntoFile.addEntry(fakePHID1, 2, 1, 1, 4);
2716 indexIntoFile.addEntry(fakePHID1, 2, 1, 0, 5);
2717 indexIntoFile.addEntry(fakePHID1, 2, 0, 0, 0);
2718 indexIntoFile.addEntry(fakePHID1, 1, 1, 5, 5);
2719 indexIntoFile.addEntry(fakePHID1, 1, 1, 0, 6);
2720 indexIntoFile.addEntry(fakePHID1, 1, 0, 0, 1);
2721
2722 indexIntoFile.sortVector_Run_Or_Lumi_Entries();
2723
2724 {
2725 edm::IndexIntoFile::IndexIntoFileItr iter = indexIntoFile.begin(IndexIntoFile::entryOrder);
2726 edm::IndexIntoFile::IndexIntoFileItr iterEnd = indexIntoFile.end(IndexIntoFile::entryOrder);
2727 int i = 0;
2728 for (i = 0; iter != iterEnd; ++iter, ++i) {
2729 switch (i) {
2730 case 0: {
2731 CPPUNIT_ASSERT(check(iter, kRun, 0, 2, 1, 0, 1));
2732 CPPUNIT_ASSERT(iter.size() == 11);
2733 CPPUNIT_ASSERT(iter.indexedSize() == 14);
2734 CPPUNIT_ASSERT(!iter.shouldProcessRun());
2735 break;
2736 }
2737 case 1: {
2738 CPPUNIT_ASSERT(check(iter, kLumi, 0, 2, 1, 0, 1));
2739 CPPUNIT_ASSERT(!iter.shouldProcessLumi());
2740 CPPUNIT_ASSERT(iter.lumiIterationStartingIndex(2));
2741 break;
2742 }
2743 case 2: {
2744 CPPUNIT_ASSERT(check(iter, kLumi, 0, 3, 1, 0, 1));
2745 CPPUNIT_ASSERT(!iter.shouldProcessLumi());
2746 CPPUNIT_ASSERT(!iter.lumiIterationStartingIndex(3));
2747 break;
2748 }
2749 case 3: {
2750 CPPUNIT_ASSERT(check(iter, kLumi, 0, 4, 1, 0, 1));
2751 CPPUNIT_ASSERT(!iter.shouldProcessLumi());
2752 CPPUNIT_ASSERT(iter.lumiIterationStartingIndex(4));
2753 break;
2754 }
2755 case 4: {
2756 CPPUNIT_ASSERT(check(iter, kEvent, 0, 4, 1, 0, 1));
2757 CPPUNIT_ASSERT(iter.entry() == 0);
2758 break;
2759 }
2760 case 5: {
2761 CPPUNIT_ASSERT(check(iter, kEvent, 0, 4, 2, 0, 1));
2762 CPPUNIT_ASSERT(iter.entry() == 1);
2763 break;
2764 }
2765 case 6: {
2766 CPPUNIT_ASSERT(check(iter, kEvent, 0, 4, 3, 0, 1));
2767 CPPUNIT_ASSERT(iter.entry() == 2);
2768 break;
2769 }
2770 case 7: {
2771 CPPUNIT_ASSERT(check(iter, kEvent, 0, 4, 4, 0, 1));
2772 CPPUNIT_ASSERT(iter.entry() == 3);
2773 break;
2774 }
2775 case 8: {
2776 CPPUNIT_ASSERT(check(iter, kRun, 5, 6, 6, 0, 1));
2777 CPPUNIT_ASSERT(iter.shouldProcessRun());
2778 break;
2779 }
2780 case 9: {
2781 CPPUNIT_ASSERT(check(iter, kLumi, 5, 6, 6, 0, 1));
2782 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2783 break;
2784 }
2785 case 10: {
2786 CPPUNIT_ASSERT(check(iter, kEvent, 5, 6, 6, 0, 1));
2787 CPPUNIT_ASSERT(iter.entry() == 4);
2788 break;
2789 }
2790 case 11: {
2791 CPPUNIT_ASSERT(check(iter, kRun, 7, 8, -1, 0, 0));
2792 CPPUNIT_ASSERT(iter.shouldProcessRun());
2793 break;
2794 }
2795 case 12: {
2796 CPPUNIT_ASSERT(check(iter, kLumi, 7, 8, -1, 0, 0));
2797 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2798 break;
2799 }
2800 case 13: {
2801 CPPUNIT_ASSERT(check(iter, kLumi, 7, 9, -1, 0, 0));
2802 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2803 break;
2804 }
2805 case 14: {
2806 CPPUNIT_ASSERT(check(iter, kLumi, 7, 10, -1, 0, 0));
2807 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2808 break;
2809 }
2810 case 15: {
2811 CPPUNIT_ASSERT(check(iter, kLumi, 7, 11, 13, 0, 1));
2812 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2813 CPPUNIT_ASSERT(iter.entry() == 1);
2814 break;
2815 }
2816 case 16: {
2817 CPPUNIT_ASSERT(check(iter, kLumi, 7, 12, 13, 0, 1));
2818 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2819 CPPUNIT_ASSERT(iter.entry() == 4);
2820 break;
2821 }
2822 case 17: {
2823 CPPUNIT_ASSERT(check(iter, kLumi, 7, 13, 13, 0, 1));
2824 CPPUNIT_ASSERT(iter.shouldProcessLumi());
2825 CPPUNIT_ASSERT(iter.entry() == 6);
2826 break;
2827 }
2828 case 18: {
2829 CPPUNIT_ASSERT(check(iter, kEvent, 7, 13, 13, 0, 1));
2830 CPPUNIT_ASSERT(iter.entry() == 5);
2831 break;
2832 }
2833 }
2834 }
2835 CPPUNIT_ASSERT(i == 19);
2836
2837 skipEventBackward(iter);
2838 checkSkipped(0, 1, 1, 5);
2839 CPPUNIT_ASSERT(check(iter, kRun, 7, 11, 13, 0, 1));
2840
2841 skipEventBackward(iter);
2842 checkSkipped(0, 2, 1, 4);
2843 CPPUNIT_ASSERT(check(iter, kRun, 5, 6, 6, 0, 1));
2844
2845 skipEventBackward(iter);
2846 checkSkipped(0, 1, 1, 3);
2847 CPPUNIT_ASSERT(check(iter, kRun, 0, 2, 4, 0, 1));
2848
2849 skipEventBackward(iter);
2850 checkSkipped(0, 1, 1, 2);
2851 CPPUNIT_ASSERT(check(iter, kRun, 0, 2, 3, 0, 1));
2852
2853 skipEventBackward(iter);
2854 checkSkipped(0, 1, 1, 1);
2855 CPPUNIT_ASSERT(check(iter, kRun, 0, 2, 2, 0, 1));
2856
2857 skipEventBackward(iter);
2858 checkSkipped(0, 1, 1, 0);
2859 CPPUNIT_ASSERT(check(iter, kRun, 0, 2, 1, 0, 1));
2860
2861 skipEventBackward(iter);
2862 checkSkipped(-1, 0, 0, -1);
2863 CPPUNIT_ASSERT(check(iter, kRun, 0, 2, 1, 0, 1));
2864
2865 iter.advanceToNextRun();
2866 CPPUNIT_ASSERT(check(iter, kRun, 5, 6, 6, 0, 1));
2867 iter.advanceToNextRun();
2868 CPPUNIT_ASSERT(check(iter, kRun, 7, 8, -1, 0, 0));
2869 iter.advanceToNextRun();
2870 CPPUNIT_ASSERT(check(iter, kEnd, -1, -1, -1, 0, 0));
2871
2872 iter = indexIntoFile.begin(IndexIntoFile::entryOrder);
2873 iter.advanceToNextLumiOrRun();
2874 CPPUNIT_ASSERT(check(iter, kLumi, 0, 2, 1, 0, 1));
2875 iter.advanceToNextLumiOrRun();
2876 CPPUNIT_ASSERT(check(iter, kRun, 5, 6, 6, 0, 1));
2877 iter.advanceToNextLumiOrRun();
2878 CPPUNIT_ASSERT(check(iter, kLumi, 5, 6, 6, 0, 1));
2879 iter.advanceToNextLumiOrRun();
2880 CPPUNIT_ASSERT(check(iter, kRun, 7, 8, -1, 0, 0));
2881 iter.advanceToNextLumiOrRun();
2882 CPPUNIT_ASSERT(check(iter, kLumi, 7, 8, -1, 0, 0));
2883 iter.advanceToNextLumiOrRun();
2884 CPPUNIT_ASSERT(check(iter, kLumi, 7, 11, 13, 0, 1));
2885 iter.advanceToNextLumiOrRun();
2886 CPPUNIT_ASSERT(check(iter, kEnd, -1, -1, -1, 0, 0));
2887 }
2888 }