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