Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-07-19 01:44:01

0001 
0002 #include "FWCore/Framework/interface/FileBlock.h"
0003 #include "FWCore/Framework/interface/one/OutputModule.h"
0004 #include "FWCore/Framework/interface/MakerMacros.h"
0005 #include "FWCore/Framework/interface/ProcessBlockForOutput.h"
0006 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0007 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0008 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0009 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0010 #include "FWCore/Framework/interface/ConstProductRegistry.h"
0011 #include "FWCore/ServiceRegistry/interface/Service.h"
0012 #include "FWCore/Utilities/interface/Exception.h"
0013 
0014 #include "TTree.h"
0015 
0016 #include <memory>
0017 #include <string>
0018 #include <vector>
0019 
0020 constexpr unsigned int kDoNotTest = 0xffffffff;
0021 
0022 namespace edm {
0023 
0024   class TestOneOutput : public one::OutputModule<WatchInputFiles, RunCache<int>, LuminosityBlockCache<int>> {
0025   public:
0026     explicit TestOneOutput(ParameterSet const& pset);
0027     ~TestOneOutput() override;
0028     static void fillDescriptions(ConfigurationDescriptions& descriptions);
0029 
0030   private:
0031     void write(EventForOutput const& e) override;
0032     void writeLuminosityBlock(LuminosityBlockForOutput const&) override;
0033     void writeRun(RunForOutput const&) override;
0034     void writeProcessBlock(ProcessBlockForOutput const&) override;
0035 
0036     void respondToOpenInputFile(FileBlock const&) override;
0037     void respondToCloseInputFile(FileBlock const&) override;
0038     void testFileBlock(FileBlock const&);
0039 
0040     std::shared_ptr<int> globalBeginRun(RunForOutput const&) const override;
0041     void globalEndRun(RunForOutput const&) override;
0042 
0043     std::shared_ptr<int> globalBeginLuminosityBlock(LuminosityBlockForOutput const&) const override;
0044     void globalEndLuminosityBlock(LuminosityBlockForOutput const&) override;
0045     void endJob() override;
0046 
0047     bool verbose_;
0048     std::vector<std::string> expectedProcessesWithProcessBlockProducts_;
0049     std::vector<std::string> expectedTopProcessesWithProcessBlockProducts_;
0050     std::vector<std::string> expectedAddedProcesses_;
0051     std::vector<std::string> expectedTopAddedProcesses_;
0052     std::vector<unsigned int> expectedTopCacheIndices0_;
0053     std::vector<unsigned int> expectedTopCacheIndices1_;
0054     std::vector<unsigned int> expectedTopCacheIndices2_;
0055     std::vector<std::string> expectedProcessNamesAtWrite_;
0056     int expectedWriteProcessBlockTransitions_;
0057     unsigned int countWriteProcessBlockTransitions_ = 0;
0058     unsigned int countInputFiles_ = 0;
0059     bool requireNullTTreesInFileBlock_;
0060     bool testTTreesInFileBlock_;
0061     std::vector<unsigned int> expectedCacheIndexSize_;
0062     unsigned int expectedProcessesInFirstFile_;
0063     std::vector<unsigned int> expectedCacheIndexVectorsPerFile_;
0064     std::vector<unsigned int> expectedNEntries0_;
0065     std::vector<unsigned int> expectedNEntries1_;
0066     std::vector<unsigned int> expectedNEntries2_;
0067     std::vector<unsigned int> expectedCacheEntriesPerFile0_;
0068     std::vector<unsigned int> expectedCacheEntriesPerFile1_;
0069     std::vector<unsigned int> expectedCacheEntriesPerFile2_;
0070     std::vector<unsigned int> expectedOuterOffset_;
0071     std::vector<unsigned int> expectedTranslateFromStoredIndex_;
0072     unsigned int expectedNAddedProcesses_;
0073     bool expectedProductsFromInputKept_;
0074   };
0075 
0076   TestOneOutput::TestOneOutput(ParameterSet const& pset)
0077       : one::OutputModuleBase(pset),
0078         one::OutputModule<WatchInputFiles, RunCache<int>, LuminosityBlockCache<int>>(pset),
0079         verbose_(pset.getUntrackedParameter<bool>("verbose")),
0080         expectedProcessesWithProcessBlockProducts_(
0081             pset.getUntrackedParameter<std::vector<std::string>>("expectedProcessesWithProcessBlockProducts")),
0082         expectedTopProcessesWithProcessBlockProducts_(
0083             pset.getUntrackedParameter<std::vector<std::string>>("expectedTopProcessesWithProcessBlockProducts")),
0084         expectedAddedProcesses_(pset.getUntrackedParameter<std::vector<std::string>>("expectedAddedProcesses")),
0085         expectedTopAddedProcesses_(pset.getUntrackedParameter<std::vector<std::string>>("expectedTopAddedProcesses")),
0086         expectedTopCacheIndices0_(pset.getUntrackedParameter<std::vector<unsigned int>>("expectedTopCacheIndices0")),
0087         expectedTopCacheIndices1_(pset.getUntrackedParameter<std::vector<unsigned int>>("expectedTopCacheIndices1")),
0088         expectedTopCacheIndices2_(pset.getUntrackedParameter<std::vector<unsigned int>>("expectedTopCacheIndices2")),
0089         expectedProcessNamesAtWrite_(
0090             pset.getUntrackedParameter<std::vector<std::string>>("expectedProcessNamesAtWrite")),
0091         expectedWriteProcessBlockTransitions_(pset.getUntrackedParameter<int>("expectedWriteProcessBlockTransitions")),
0092         requireNullTTreesInFileBlock_(pset.getUntrackedParameter<bool>("requireNullTTreesInFileBlock")),
0093         testTTreesInFileBlock_(pset.getUntrackedParameter<bool>("testTTreesInFileBlock")),
0094         expectedCacheIndexSize_(pset.getUntrackedParameter<std::vector<unsigned int>>("expectedCacheIndexSize")),
0095         expectedProcessesInFirstFile_(pset.getUntrackedParameter<unsigned int>("expectedProcessesInFirstFile")),
0096         expectedCacheIndexVectorsPerFile_(
0097             pset.getUntrackedParameter<std::vector<unsigned int>>("expectedCacheIndexVectorsPerFile")),
0098         expectedNEntries0_(pset.getUntrackedParameter<std::vector<unsigned int>>("expectedNEntries0")),
0099         expectedNEntries1_(pset.getUntrackedParameter<std::vector<unsigned int>>("expectedNEntries1")),
0100         expectedNEntries2_(pset.getUntrackedParameter<std::vector<unsigned int>>("expectedNEntries2")),
0101         expectedCacheEntriesPerFile0_(
0102             pset.getUntrackedParameter<std::vector<unsigned int>>("expectedCacheEntriesPerFile0")),
0103         expectedCacheEntriesPerFile1_(
0104             pset.getUntrackedParameter<std::vector<unsigned int>>("expectedCacheEntriesPerFile1")),
0105         expectedCacheEntriesPerFile2_(
0106             pset.getUntrackedParameter<std::vector<unsigned int>>("expectedCacheEntriesPerFile2")),
0107         expectedOuterOffset_(pset.getUntrackedParameter<std::vector<unsigned int>>("expectedOuterOffset")),
0108         expectedTranslateFromStoredIndex_(
0109             pset.getUntrackedParameter<std::vector<unsigned int>>("expectedTranslateFromStoredIndex")),
0110         expectedNAddedProcesses_(pset.getUntrackedParameter<unsigned int>("expectedNAddedProcesses")),
0111         expectedProductsFromInputKept_(pset.getUntrackedParameter<bool>("expectedProductsFromInputKept")) {}
0112 
0113   TestOneOutput::~TestOneOutput() {}
0114 
0115   void TestOneOutput::write(EventForOutput const& e) {
0116     if (verbose_) {
0117       LogAbsolute("TestOneOutput") << "one write event";
0118     }
0119   }
0120 
0121   void TestOneOutput::writeLuminosityBlock(LuminosityBlockForOutput const&) {
0122     if (verbose_) {
0123       LogAbsolute("TestOneOutput") << "one writeLuminosityBlock";
0124     }
0125   }
0126 
0127   void TestOneOutput::writeRun(RunForOutput const&) {
0128     if (verbose_) {
0129       LogAbsolute("TestOneOutput") << "one writeRun";
0130     }
0131   }
0132 
0133   void TestOneOutput::writeProcessBlock(ProcessBlockForOutput const& pb) {
0134     if (verbose_) {
0135       LogAbsolute("TestOneOutput") << "one writeProcessBlock";
0136     }
0137     if (countWriteProcessBlockTransitions_ < expectedProcessNamesAtWrite_.size()) {
0138       if (expectedProcessNamesAtWrite_[countWriteProcessBlockTransitions_] != pb.processName()) {
0139         throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected process name";
0140       }
0141     }
0142     if (!expectedProcessesWithProcessBlockProducts_.empty()) {
0143       if (verbose_) {
0144         for (auto const& process : outputProcessBlockHelper().processesWithProcessBlockProducts()) {
0145           LogAbsolute("TestOneOutput") << "    " << process;
0146         }
0147       }
0148       if (expectedProcessesWithProcessBlockProducts_ !=
0149           outputProcessBlockHelper().processesWithProcessBlockProducts()) {
0150         throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected process name list";
0151       }
0152     }
0153     if (!(!expectedAddedProcesses_.empty() && expectedAddedProcesses_[0] == "DONOTTEST")) {
0154       if (expectedAddedProcesses_ != outputProcessBlockHelper().processBlockHelper()->addedProcesses()) {
0155         throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected addedProcesses list";
0156       }
0157     }
0158     if (!(!expectedTopAddedProcesses_.empty() && expectedTopAddedProcesses_[0] == "DONOTTEST")) {
0159       if (expectedTopAddedProcesses_ !=
0160           outputProcessBlockHelper().processBlockHelper()->topProcessBlockHelper()->addedProcesses()) {
0161         throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected top addedProcesses list";
0162       }
0163     }
0164     if (!expectedTopProcessesWithProcessBlockProducts_.empty()) {
0165       // Same test as the previous except check the list of names in
0166       // the top level process name list from the EventProcessor
0167       if (expectedTopProcessesWithProcessBlockProducts_ != outputProcessBlockHelper()
0168                                                                .processBlockHelper()
0169                                                                ->topProcessBlockHelper()
0170                                                                ->topProcessesWithProcessBlockProducts()) {
0171         throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected top process name list";
0172       }
0173       // Almost the same as the previous test, should get the same result
0174       if (expectedTopProcessesWithProcessBlockProducts_ !=
0175           outputProcessBlockHelper().processBlockHelper()->topProcessesWithProcessBlockProducts()) {
0176         throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected top process name list 2";
0177       }
0178 
0179       std::vector<unsigned int> const* expectedTopCacheIndices = nullptr;
0180       if (countInputFiles_ == 1 && !expectedTopCacheIndices0_.empty()) {
0181         expectedTopCacheIndices = &expectedTopCacheIndices0_;
0182       } else if (countInputFiles_ == 2 && !expectedTopCacheIndices1_.empty()) {
0183         expectedTopCacheIndices = &expectedTopCacheIndices1_;
0184       } else if (countInputFiles_ == 3 && !expectedTopCacheIndices2_.empty()) {
0185         expectedTopCacheIndices = &expectedTopCacheIndices2_;
0186       }
0187       if (expectedTopCacheIndices != nullptr) {
0188         unsigned int expectedInputProcesses =
0189             expectedTopProcessesWithProcessBlockProducts_.size() -
0190             outputProcessBlockHelper().processBlockHelper()->topProcessBlockHelper()->addedProcesses().size();
0191 
0192         std::vector<std::vector<unsigned int>> const& topProcessBlockCacheIndices =
0193             outputProcessBlockHelper().processBlockHelper()->processBlockCacheIndices();
0194         if (expectedTopCacheIndices->size() != expectedInputProcesses * topProcessBlockCacheIndices.size()) {
0195           throw cms::Exception("TestFailure")
0196               << "TestOneOutput::writeProcessBlock unexpected sizes related to top cache indices on input file "
0197               << (countInputFiles_ - 1);
0198         }
0199         unsigned int iStored = 0;
0200         for (unsigned int i = 0; i < topProcessBlockCacheIndices.size(); ++i) {
0201           if (topProcessBlockCacheIndices[i].size() != expectedInputProcesses) {
0202             throw cms::Exception("TestFailure")
0203                 << "TestOneOutput::writeProcessBlock unexpected size of inner cache indices vector on input file "
0204                 << (countInputFiles_ - 1);
0205           }
0206           for (unsigned int j = 0; j < topProcessBlockCacheIndices[i].size(); ++j) {
0207             if (topProcessBlockCacheIndices[i][j] != (*expectedTopCacheIndices)[iStored]) {
0208               throw cms::Exception("TestFailure")
0209                   << "TestOneOutput::writeProcessBlock unexpected cache index value on input file "
0210                   << (countInputFiles_ - 1);
0211             }
0212             ++iStored;
0213           }
0214         }
0215       }
0216     }
0217     if (expectedProcessesInFirstFile_ != 0) {
0218       if (expectedProcessesInFirstFile_ != outputProcessBlockHelper().processBlockHelper()->nProcessesInFirstFile()) {
0219         throw cms::Exception("TestFailure")
0220             << "TestOneOutput::writeProcessBlock unexpected value for nProcessesInFirstFile";
0221       }
0222     }
0223     for (unsigned int i = 0; i < expectedCacheIndexVectorsPerFile_.size(); ++i) {
0224       if (i < countInputFiles_) {
0225         if (expectedCacheIndexVectorsPerFile_[i] !=
0226             outputProcessBlockHelper().processBlockHelper()->cacheIndexVectorsPerFile()[i]) {
0227           throw cms::Exception("TestFailure")
0228               << "TestOneOutput::writeProcessBlock unexpected value for cacheIndexVectorsPerFile, element " << i;
0229         }
0230       }
0231     }
0232     if (countInputFiles_ >= 1 && !expectedNEntries0_.empty()) {
0233       if (expectedNEntries0_ != outputProcessBlockHelper().processBlockHelper()->nEntries()[0]) {
0234         throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected value for nEntries 0";
0235       }
0236     }
0237     if (countInputFiles_ >= 2 && !expectedNEntries1_.empty()) {
0238       if (expectedNEntries1_ != outputProcessBlockHelper().processBlockHelper()->nEntries()[1]) {
0239         throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected value for nEntries 1";
0240       }
0241     }
0242     if (countInputFiles_ >= 3 && !expectedNEntries2_.empty()) {
0243       if (expectedNEntries2_ != outputProcessBlockHelper().processBlockHelper()->nEntries()[2]) {
0244         throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected value for nEntries 2";
0245       }
0246     }
0247 
0248     if (countInputFiles_ == 1 && !expectedCacheEntriesPerFile0_.empty()) {
0249       if (expectedCacheEntriesPerFile0_ != outputProcessBlockHelper().processBlockHelper()->cacheEntriesPerFile()) {
0250         throw cms::Exception("TestFailure")
0251             << "TestOneOutput::writeProcessBlock unexpected value for cacheEntriesPerFile 0";
0252       }
0253     } else if (countInputFiles_ == 2 && !expectedCacheEntriesPerFile1_.empty()) {
0254       if (expectedCacheEntriesPerFile1_ != outputProcessBlockHelper().processBlockHelper()->cacheEntriesPerFile()) {
0255         throw cms::Exception("TestFailure")
0256             << "TestOneOutput::writeProcessBlock unexpected value for cacheEntriesPerFile 1";
0257       }
0258     } else if (countInputFiles_ == 3 && !expectedCacheEntriesPerFile2_.empty()) {
0259       if (expectedCacheEntriesPerFile2_ != outputProcessBlockHelper().processBlockHelper()->cacheEntriesPerFile()) {
0260         throw cms::Exception("TestFailure")
0261             << "TestOneOutput::writeProcessBlock unexpected value for cacheEntriesPerFile 2";
0262       }
0263     }
0264 
0265     if (!expectedOuterOffset_.empty() && (countInputFiles_ - 1) < expectedOuterOffset_.size()) {
0266       if (expectedOuterOffset_[countInputFiles_ - 1] !=
0267           outputProcessBlockHelper().processBlockHelper()->outerOffset()) {
0268         throw cms::Exception("TestFailure")
0269             << "TestOneOutput::writeProcessBlock unexpected value for outerOffset, file " << (countInputFiles_ - 1);
0270       }
0271     }
0272     if (countWriteProcessBlockTransitions_ < expectedCacheIndexSize_.size()) {
0273       if (expectedCacheIndexSize_[countWriteProcessBlockTransitions_] !=
0274           outputProcessBlockHelper().processBlockHelper()->processBlockCacheIndices().size()) {
0275         throw cms::Exception("TestFailure")
0276             << "TestOneOutput::writeProcessBlock unexpected cache index size "
0277             << outputProcessBlockHelper().processBlockHelper()->processBlockCacheIndices().size();
0278       }
0279     }
0280     if (!expectedTranslateFromStoredIndex_.empty()) {
0281       if (expectedTranslateFromStoredIndex_ != outputProcessBlockHelper().translateFromStoredIndex()) {
0282         throw cms::Exception("TestFailure")
0283             << "TestOneOutput::writeProcessBlock unexpected value for translateFromStoredIndex";
0284       }
0285     }
0286     if (expectedNAddedProcesses_ != kDoNotTest) {
0287       if (expectedNAddedProcesses_ != outputProcessBlockHelper().nAddedProcesses()) {
0288         throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected value for nAddedProcesses";
0289       }
0290     }
0291     if (expectedProductsFromInputKept_ != outputProcessBlockHelper().productsFromInputKept()) {
0292       throw cms::Exception("TestFailure")
0293           << "TestOneOutput::writeProcessBlock unexpected value for productsFromInputKept";
0294     }
0295     ++countWriteProcessBlockTransitions_;
0296   }
0297 
0298   void TestOneOutput::respondToOpenInputFile(FileBlock const& fb) {
0299     if (verbose_) {
0300       LogAbsolute("TestOneOutput") << "one respondToOpenInputFile";
0301     }
0302     testFileBlock(fb);
0303     ++countInputFiles_;
0304   }
0305 
0306   void TestOneOutput::respondToCloseInputFile(FileBlock const& fb) {
0307     if (verbose_) {
0308       LogAbsolute("TestOneOutput") << "one respondToCloseInputFile";
0309     }
0310     testFileBlock(fb);
0311   }
0312 
0313   void TestOneOutput::testFileBlock(FileBlock const& fb) {
0314     if (requireNullTTreesInFileBlock_) {
0315       if (fb.tree() != nullptr || fb.lumiTree() != nullptr || fb.runTree() != nullptr ||
0316           !fb.processBlockTrees().empty() || !fb.processesWithProcessBlockTrees().empty() ||
0317           fb.processBlockTree(std::string("DoesNotExist")) != nullptr) {
0318         throw cms::Exception("TestFailure")
0319             << "TestOneOutput::respondToOpenInputFile expected null TTree pointers in FileBlock";
0320       }
0321     } else if (testTTreesInFileBlock_) {
0322       if (fb.tree() == nullptr || std::string("Events") != fb.tree()->GetName() ||
0323           std::string("LuminosityBlocks") != fb.lumiTree()->GetName() ||
0324           std::string("Runs") != fb.runTree()->GetName() || fb.processesWithProcessBlockTrees().size() != 2 ||
0325           fb.processesWithProcessBlockTrees()[0] != "PROD1" || fb.processesWithProcessBlockTrees()[1] != "MERGE" ||
0326           fb.processBlockTrees().size() != 2 ||
0327           std::string("ProcessBlocksPROD1") != fb.processBlockTrees()[0]->GetName() ||
0328           std::string("ProcessBlocksMERGE") != fb.processBlockTrees()[1]->GetName() ||
0329           std::string("ProcessBlocksPROD1") != fb.processBlockTree("PROD1")->GetName() ||
0330           std::string("ProcessBlocksMERGE") != fb.processBlockTree("MERGE")->GetName() ||
0331           fb.processBlockTree("DOESNOTEXIST") != nullptr) {
0332         throw cms::Exception("TestFailure") << "TestOneOutput::testFileBlock failed. Testing tree pointers";
0333       }
0334     }
0335   }
0336 
0337   std::shared_ptr<int> TestOneOutput::globalBeginRun(RunForOutput const&) const {
0338     if (verbose_) {
0339       LogAbsolute("TestOneOutput") << "one globalBeginRun";
0340       edm::Service<edm::ConstProductRegistry> reg;
0341       for (auto const& it : reg->productList()) {
0342         LogAbsolute("TestOneOutput") << it.second;
0343       }
0344     }
0345     return std::make_shared<int>(0);
0346   }
0347 
0348   void TestOneOutput::globalEndRun(RunForOutput const&) {
0349     if (verbose_) {
0350       LogAbsolute("TestOneOutput") << "one globalEndRun";
0351     }
0352   }
0353 
0354   std::shared_ptr<int> TestOneOutput::globalBeginLuminosityBlock(LuminosityBlockForOutput const&) const {
0355     if (verbose_) {
0356       LogAbsolute("TestOneOutput") << "one globalBeginLuminosityBlock";
0357     }
0358     return std::make_shared<int>(0);
0359   }
0360 
0361   void TestOneOutput::globalEndLuminosityBlock(LuminosityBlockForOutput const&) {
0362     if (verbose_) {
0363       LogAbsolute("TestOneOutput") << "one globalEndLuminosityBlock";
0364     }
0365   }
0366 
0367   void TestOneOutput::endJob() {
0368     if (expectedWriteProcessBlockTransitions_ >= 0) {
0369       if (static_cast<unsigned int>(expectedWriteProcessBlockTransitions_) != countWriteProcessBlockTransitions_) {
0370         throw cms::Exception("TestFailure")
0371             << "TestOneOutput::writeProcessBlock unexpected number of writeProcessBlock transitions";
0372       }
0373     }
0374   }
0375 
0376   void TestOneOutput::fillDescriptions(ConfigurationDescriptions& descriptions) {
0377     ParameterSetDescription desc;
0378     OutputModule::fillDescription(desc);
0379     desc.addUntracked<bool>("verbose", true);
0380     desc.addUntracked<std::vector<std::string>>("expectedProcessesWithProcessBlockProducts",
0381                                                 std::vector<std::string>());
0382     desc.addUntracked<std::vector<std::string>>("expectedTopProcessesWithProcessBlockProducts",
0383                                                 std::vector<std::string>());
0384     desc.addUntracked<std::vector<std::string>>("expectedAddedProcesses",
0385                                                 std::vector<std::string>(1, std::string("DONOTTEST")));
0386     desc.addUntracked<std::vector<std::string>>("expectedTopAddedProcesses",
0387                                                 std::vector<std::string>(1, std::string("DONOTTEST")));
0388     desc.addUntracked<std::vector<unsigned int>>("expectedTopCacheIndices0", std::vector<unsigned int>());
0389     desc.addUntracked<std::vector<unsigned int>>("expectedTopCacheIndices1", std::vector<unsigned int>());
0390     desc.addUntracked<std::vector<unsigned int>>("expectedTopCacheIndices2", std::vector<unsigned int>());
0391     desc.addUntracked<std::vector<std::string>>("expectedProcessNamesAtWrite", std::vector<std::string>());
0392     desc.addUntracked<int>("expectedWriteProcessBlockTransitions", -1);
0393     desc.addUntracked<bool>("requireNullTTreesInFileBlock", false);
0394     desc.addUntracked<bool>("testTTreesInFileBlock", false);
0395     desc.addUntracked<std::vector<unsigned int>>("expectedCacheIndexSize", std::vector<unsigned int>());
0396     desc.addUntracked<unsigned int>("expectedProcessesInFirstFile", 0);
0397     desc.addUntracked<std::vector<unsigned int>>("expectedCacheIndexVectorsPerFile", std::vector<unsigned int>());
0398     desc.addUntracked<std::vector<unsigned int>>("expectedNEntries0", std::vector<unsigned int>());
0399     desc.addUntracked<std::vector<unsigned int>>("expectedNEntries1", std::vector<unsigned int>());
0400     desc.addUntracked<std::vector<unsigned int>>("expectedNEntries2", std::vector<unsigned int>());
0401     desc.addUntracked<std::vector<unsigned int>>("expectedCacheEntriesPerFile0", std::vector<unsigned int>());
0402     desc.addUntracked<std::vector<unsigned int>>("expectedCacheEntriesPerFile1", std::vector<unsigned int>());
0403     desc.addUntracked<std::vector<unsigned int>>("expectedCacheEntriesPerFile2", std::vector<unsigned int>());
0404     desc.addUntracked<std::vector<unsigned int>>("expectedOuterOffset", std::vector<unsigned int>());
0405     desc.addUntracked<std::vector<unsigned int>>("expectedTranslateFromStoredIndex", std::vector<unsigned int>());
0406     desc.addUntracked<unsigned int>("expectedNAddedProcesses", kDoNotTest);
0407     desc.addUntracked<bool>("expectedProductsFromInputKept", true);
0408 
0409     descriptions.addDefault(desc);
0410   }
0411 }  // namespace edm
0412 
0413 using edm::TestOneOutput;
0414 DEFINE_FWK_MODULE(TestOneOutput);