File indexing completed on 2023-10-25 09:47:24
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
0166
0167 if (expectedTopProcessesWithProcessBlockProducts_ != outputProcessBlockHelper()
0168 .processBlockHelper()
0169 ->topProcessBlockHelper()
0170 ->topProcessesWithProcessBlockProducts()) {
0171 throw cms::Exception("TestFailure") << "TestOneOutput::writeProcessBlock unexpected top process name list";
0172 }
0173
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 }
0412
0413 using edm::TestOneOutput;
0414 DEFINE_FWK_MODULE(TestOneOutput);
