Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-04-22 06:27:24 

0001 /*
0002  *  tsetprocessor_t.cc
0003  *  EDMProto
0004  *
0005  *  Created by Chris Jones on 5/1/18.
0006  *
0007  */
0008 
0009 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0010 #include "FWCore/TestProcessor/interface/TestProcessor.h"
0011 
0012 #include "DataFormats/TestObjects/interface/ToyProducts.h"
0013 #include "DataFormats/TestObjects/interface/ThingCollection.h"
0014 
0015 #include "FWCore/Integration/interface/ESTestData.h"
0016 #include "FWCore/Integration/interface/ESTestRecords.h"
0017 
0018 #include <cppunit/extensions/HelperMacros.h>
0019 
0020 #include <memory>
0021 
0022 #include <iostream>
0023 #include <sstream>
0024 #include <stdexcept>
0025 #include <string>
0026 #include <vector>
0027 #include <algorithm>
0028 #include <set>
0029 
0030 class testTestProcessor : public CppUnit::TestFixture {
0031   CPPUNIT_TEST_SUITE(testTestProcessor);
0032   CPPUNIT_TEST(simpleProcessTest);
0033   CPPUNIT_TEST(addProductTest);
0034   CPPUNIT_TEST(missingProductTest);
0035   CPPUNIT_TEST(filterTest);
0036   CPPUNIT_TEST(outputModuleTest);
0037   CPPUNIT_TEST(extraProcessTest);
0038   CPPUNIT_TEST(eventSetupTest);
0039   CPPUNIT_TEST(eventSetupPutTest);
0040   CPPUNIT_TEST(lumiTest);
0041   CPPUNIT_TEST(taskTest);
0042   CPPUNIT_TEST(emptyProcessBlockTest);
0043   CPPUNIT_TEST(emptyRunTest);
0044   CPPUNIT_TEST(emptyLumiTest);
0045   CPPUNIT_TEST(processBlockProductTest);
0046   CPPUNIT_TEST(processBlockEndProductTest);
0047   CPPUNIT_TEST(runProductTest);
0048   CPPUNIT_TEST(lumiProductTest);
0049   CPPUNIT_TEST(runStreamAnalyzerTest);
0050   CPPUNIT_TEST(lumiStreamAnalyzerTest);
0051 
0052   CPPUNIT_TEST_SUITE_END();
0053 
0054 public:
0055   void setUp() {}
0056   void tearDown() {}
0057   void simpleProcessTest();
0058   void addProductTest();
0059   void missingProductTest();
0060   void filterTest();
0061   void outputModuleTest();
0062   void extraProcessTest();
0063   void eventSetupTest();
0064   void eventSetupPutTest();
0065   void lumiTest();
0066   void taskTest();
0067   void emptyProcessBlockTest();
0068   void emptyRunTest();
0069   void emptyLumiTest();
0070   void processBlockProductTest();
0071   void processBlockEndProductTest();
0072   void runProductTest();
0073   void lumiProductTest();
0074   void runStreamAnalyzerTest();
0075   void lumiStreamAnalyzerTest();
0076 
0077 private:
0078 };
0079 
0080 ///registration of the test so that the runner can find it
0081 CPPUNIT_TEST_SUITE_REGISTRATION(testTestProcessor);
0082 
0083 void testTestProcessor::simpleProcessTest() {
0084   char const* kTest =
0085       "from FWCore.TestProcessor.TestProcess import *\n"
0086       "process = TestProcess()\n"
0087       "process.foo = cms.EDProducer('IntProducer', ivalue=cms.int32(1))\n"
0088       "process.moduleToTest(process.foo)\n";
0089   edm::test::TestProcessor::Config config(kTest);
0090   edm::test::TestProcessor tester(config);
0091   CPPUNIT_ASSERT(tester.labelOfTestModule() == "foo");
0092 
0093   auto event = tester.test();
0094 
0095   CPPUNIT_ASSERT(event.get<edmtest::IntProduct>()->value == 1);
0096 
0097   CPPUNIT_ASSERT(not event.get<edmtest::IntProduct>("doesNotExist"));
0098   CPPUNIT_ASSERT_THROW(*event.get<edmtest::IntProduct>("doesNotExist"), cms::Exception);
0099 }
0100 
0101 void testTestProcessor::addProductTest() {
0102   char const* kTest =
0103       "from FWCore.TestProcessor.TestProcess import *\n"
0104       "process = TestProcess()\n"
0105       "process.add = cms.EDProducer('AddIntsProducer', labels=cms.VInputTag('in'))\n"
0106       "process.moduleToTest(process.add)\n";
0107   edm::test::TestProcessor::Config config(kTest);
0108   auto token = config.produces<edmtest::IntProduct>("in");
0109 
0110   edm::test::TestProcessor tester(config);
0111 
0112   {
0113     auto event = tester.test(std::make_pair(token, std::make_unique<edmtest::IntProduct>(1)));
0114 
0115     CPPUNIT_ASSERT(event.get<edmtest::IntProduct>()->value == 1);
0116   }
0117 
0118   {
0119     auto event = tester.test(std::make_pair(token, std::make_unique<edmtest::IntProduct>(2)));
0120 
0121     CPPUNIT_ASSERT(event.get<edmtest::IntProduct>()->value == 2);
0122   }
0123 
0124   //Check that event gets reset so the data product is not available
0125   CPPUNIT_ASSERT_THROW(tester.test(), cms::Exception);
0126 }
0127 
0128 void testTestProcessor::missingProductTest() {
0129   char const* kTest =
0130       "from FWCore.TestProcessor.TestProcess import *\n"
0131       "process = TestProcess()\n"
0132       "process.add = cms.EDProducer('AddIntsProducer', labels=cms.VInputTag('in'))\n"
0133       "process.moduleToTest(process.add)\n";
0134   edm::test::TestProcessor::Config config(kTest);
0135 
0136   edm::test::TestProcessor tester(config);
0137 
0138   CPPUNIT_ASSERT_THROW(tester.test(), cms::Exception);
0139 }
0140 
0141 void testTestProcessor::filterTest() {
0142   char const* kTest =
0143       "from FWCore.TestProcessor.TestProcess import *\n"
0144       "process = TestProcess()\n"
0145       "process.foo = cms.EDFilter('TestFilterModule', acceptValue=cms.untracked.int32(2),\n"
0146       "   onlyOne = cms.untracked.bool(True))\n"
0147       "process.moduleToTest(process.foo)\n";
0148   edm::test::TestProcessor::Config config(kTest);
0149   edm::test::TestProcessor tester(config);
0150   CPPUNIT_ASSERT(tester.labelOfTestModule() == "foo");
0151 
0152   CPPUNIT_ASSERT(not tester.test().modulePassed());
0153   CPPUNIT_ASSERT(tester.test().modulePassed());
0154   CPPUNIT_ASSERT(not tester.test().modulePassed());
0155   CPPUNIT_ASSERT(tester.test().modulePassed());
0156 }
0157 
0158 void testTestProcessor::outputModuleTest() {
0159   char const* kTest =
0160       "from FWCore.TestProcessor.TestProcess import *\n"
0161       "process = TestProcess()\n"
0162       "process.MessageLogger.cerr.INFO.limit=10000\n"
0163       "process.foo = cms.OutputModule('GetProductCheckerOutputModule', verbose=cms.untracked.bool(True),"
0164       " outputCommands = cms.untracked.vstring('drop *','keep edmtestIntProduct_in__TEST'),\n"
0165       " crosscheck = cms.untracked.vstring('edmtestIntProduct_in__TEST'))\n"
0166       "process.moduleToTest(process.foo)\n";
0167   edm::test::TestProcessor::Config config(kTest);
0168   auto token = config.produces<edmtest::IntProduct>("in");
0169   edm::test::TestProcessor tester(config);
0170   tester.test(std::make_pair(token, std::make_unique<edmtest::IntProduct>(1)));
0171 }
0172 void testTestProcessor::extraProcessTest() {
0173   char const* kTest =
0174       "from FWCore.TestProcessor.TestProcess import *\n"
0175       "process = TestProcess()\n"
0176       "process.add = cms.EDProducer('AddIntsProducer', labels=cms.VInputTag('in'))\n"
0177       "process.moduleToTest(process.add)\n";
0178   edm::test::TestProcessor::Config config(kTest);
0179   auto processToken = config.addExtraProcess("HLT");
0180   auto token = config.produces<edmtest::IntProduct>("in", "", processToken);
0181 
0182   edm::test::TestProcessor tester(config);
0183 
0184   {
0185     auto event = tester.test(std::make_pair(token, std::make_unique<edmtest::IntProduct>(1)));
0186 
0187     CPPUNIT_ASSERT(event.get<edmtest::IntProduct>()->value == 1);
0188   }
0189 }
0190 
0191 void testTestProcessor::eventSetupTest() {
0192   char const* kTest =
0193       "from FWCore.TestProcessor.TestProcess import *\n"
0194       "process = TestProcess()\n"
0195       "process.emptyESSourceA1 = cms.ESSource('EmptyESSource',"
0196       "recordName = cms.string('ESTestRecordA'),"
0197       "firstValid = cms.vuint32(1,2),"
0198       "iovIsRunNotTime = cms.bool(True)"
0199       ")\n"
0200 
0201       "process.add_(cms.ESProducer('ESTestProducerA') )\n"
0202       "process.add = cms.EDAnalyzer('ESTestAnalyzerA', runsToGetDataFor = cms.vint32(1,2), "
0203       "expectedValues=cms.untracked.vint32(1,2))\n"
0204       "process.moduleToTest(process.add)\n";
0205   edm::test::TestProcessor::Config config(kTest);
0206 
0207   edm::test::TestProcessor tester(config);
0208 
0209   (void)tester.test();
0210 
0211   tester.setRunNumber(2);
0212   (void)tester.test();
0213 }
0214 
0215 void testTestProcessor::eventSetupPutTest() {
0216   char const* kTest =
0217       "from FWCore.TestProcessor.TestProcess import *\n"
0218       "process = TestProcess()\n"
0219       "process.add = cms.EDAnalyzer('ESTestAnalyzerA', runsToGetDataFor = cms.vint32(1,2,3), "
0220       "expectedValues=cms.untracked.vint32(1,2,2))\n"
0221       "process.moduleToTest(process.add)\n";
0222   edm::test::TestProcessor::Config config(kTest);
0223   auto estoken = config.esProduces<ESTestRecordA, edmtest::ESTestDataA>();
0224 
0225   edm::test::TestProcessor tester(config);
0226 
0227   (void)tester.test(std::make_pair(estoken, std::make_unique<edmtest::ESTestDataA>(1)));
0228 
0229   tester.setRunNumber(2);
0230   (void)tester.test(std::make_pair(estoken, std::make_unique<edmtest::ESTestDataA>(2)));
0231 
0232   tester.setRunNumber(3);
0233   CPPUNIT_ASSERT_THROW(tester.test(), cms::Exception);
0234 }
0235 
0236 void testTestProcessor::lumiTest() {
0237   auto const kTest = R"_(from FWCore.TestProcessor.TestProcess import *
0238 process = TestProcess()
0239 process.toTest = cms.EDProducer('ThingProducer')
0240 process.moduleToTest(process.toTest)
0241 )_";
0242   edm::test::TestProcessor::Config config(kTest);
0243 
0244   edm::test::TestProcessor tester(config);
0245   (void)tester.test();
0246   tester.setLuminosityBlockNumber(2);
0247   (void)tester.test();
0248 }
0249 
0250 void testTestProcessor::taskTest() {
0251   char const* kTest =
0252       "from FWCore.TestProcessor.TestProcess import *\n"
0253       "process = TestProcess()\n"
0254       "process.mid = cms.EDProducer('AddIntsProducer', labels=cms.VInputTag('in'))\n"
0255       "process.add = cms.EDProducer('AddIntsProducer', labels=cms.VInputTag('mid','in'))\n"
0256       "process.moduleToTest(process.add,cms.Task(process.mid))\n";
0257   edm::test::TestProcessor::Config config(kTest);
0258   auto token = config.produces<edmtest::IntProduct>("in");
0259 
0260   edm::test::TestProcessor tester(config);
0261 
0262   {
0263     auto event = tester.test(std::make_pair(token, std::make_unique<edmtest::IntProduct>(1)));
0264 
0265     CPPUNIT_ASSERT(event.get<edmtest::IntProduct>()->value == 2);
0266   }
0267 }
0268 
0269 void testTestProcessor::emptyProcessBlockTest() {
0270   auto const kTest = R"_(from FWCore.TestProcessor.TestProcess import *
0271 process = TestProcess()
0272 process.toTest = cms.EDAnalyzer('RunLumiEventChecker',
0273         eventSequence = cms.untracked.VEventID()
0274                                 )
0275 process.moduleToTest(process.toTest)
0276 )_";
0277   edm::test::TestProcessor::Config config(kTest);
0278   edm::test::TestProcessor tester(config);
0279 
0280   tester.testWithNoRuns();
0281 }
0282 void testTestProcessor::emptyRunTest() {
0283   auto const kTest = R"_(from FWCore.TestProcessor.TestProcess import *
0284 process = TestProcess()
0285 process.toTest = cms.EDAnalyzer('RunLumiEventChecker',
0286         eventSequence = cms.untracked.VEventID(cms.EventID(1,0,0), cms.EventID(1,0,0))
0287                                 )
0288 process.moduleToTest(process.toTest)
0289 )_";
0290   edm::test::TestProcessor::Config config(kTest);
0291 
0292   edm::test::TestProcessor tester(config);
0293 
0294   tester.testRunWithNoLuminosityBlocks();
0295 }
0296 void testTestProcessor::emptyLumiTest() {
0297   auto const kTest = R"_(from FWCore.TestProcessor.TestProcess import *
0298 process = TestProcess()
0299 process.toTest = cms.EDAnalyzer('RunLumiEventChecker',
0300                                   eventSequence = cms.untracked.VEventID(cms.EventID(1,0,0), cms.EventID(1,1,0),
0301                                                                          cms.EventID(1,1,0), cms.EventID(1,0,0))
0302                                   )
0303 process.moduleToTest(process.toTest)
0304 )_";
0305   edm::test::TestProcessor::Config config(kTest);
0306 
0307   edm::test::TestProcessor tester(config);
0308 
0309   tester.testLuminosityBlockWithNoEvents();
0310 }
0311 
0312 void testTestProcessor::processBlockProductTest() {
0313   auto const kTest = R"_(from FWCore.TestProcessor.TestProcess import *
0314 process = TestProcess()
0315 process.intProducerBeginProcessBlock = cms.EDProducer("IntProducerBeginProcessBlock", ivalue = cms.int32(10000))
0316 process.moduleToTest(process.intProducerBeginProcessBlock)
0317 )_";
0318   edm::test::TestProcessor::Config config(kTest);
0319 
0320   edm::test::TestProcessor tester(config);
0321   {
0322     auto processBlock = tester.testBeginProcessBlock();
0323     CPPUNIT_ASSERT(processBlock.get<edmtest::IntProduct>()->value == 10000);
0324   }
0325   {
0326     auto processBlock = tester.testEndProcessBlock();
0327     CPPUNIT_ASSERT(processBlock.get<edmtest::IntProduct>()->value == 10000);
0328   }
0329 }
0330 
0331 void testTestProcessor::processBlockEndProductTest() {
0332   auto const kTest = R"_(from FWCore.TestProcessor.TestProcess import *
0333 process = TestProcess()
0334 process.intProducerEndProcessBlock = cms.EDProducer("IntProducerEndProcessBlock", ivalue = cms.int32(10001))
0335 process.moduleToTest(process.intProducerEndProcessBlock)
0336 )_";
0337   edm::test::TestProcessor::Config config(kTest);
0338 
0339   edm::test::TestProcessor tester(config);
0340   {
0341     auto processBlock = tester.testBeginProcessBlock();
0342     CPPUNIT_ASSERT_THROW(*processBlock.get<edmtest::IntProduct>(), cms::Exception);
0343   }
0344   {
0345     auto processBlock = tester.testEndProcessBlock();
0346     CPPUNIT_ASSERT(processBlock.get<edmtest::IntProduct>()->value == 10001);
0347   }
0348 }
0349 
0350 void testTestProcessor::runProductTest() {
0351   auto const kTest = R"_(from FWCore.TestProcessor.TestProcess import *
0352 process = TestProcess()
0353 process.toTest = cms.EDProducer('ThingProducer')
0354 process.moduleToTest(process.toTest)
0355 )_";
0356   edm::test::TestProcessor::Config config(kTest);
0357 
0358   edm::test::TestProcessor tester(config);
0359   {
0360     auto run = tester.testBeginRun(1);
0361     CPPUNIT_ASSERT(run.get<edmtest::ThingCollection>("beginRun")->size() == 20);
0362   }
0363 
0364   {
0365     auto run = tester.testEndRun();
0366     CPPUNIT_ASSERT(run.get<edmtest::ThingCollection>("beginRun")->size() == 20);
0367     CPPUNIT_ASSERT(run.get<edmtest::ThingCollection>("endRun")->size() == 20);
0368   }
0369 
0370   {
0371     auto run = tester.testBeginRun(2);
0372     CPPUNIT_ASSERT(run.get<edmtest::ThingCollection>("beginRun")->size() == 20);
0373   }
0374 }
0375 
0376 void testTestProcessor::lumiProductTest() {
0377   auto const kTest = R"_(from FWCore.TestProcessor.TestProcess import *
0378 process = TestProcess()
0379 process.toTest = cms.EDProducer('ThingProducer')
0380 process.moduleToTest(process.toTest)
0381 )_";
0382   edm::test::TestProcessor::Config config(kTest);
0383 
0384   edm::test::TestProcessor tester(config);
0385   {
0386     auto lumi = tester.testBeginLuminosityBlock(1);
0387     CPPUNIT_ASSERT(lumi.get<edmtest::ThingCollection>("beginLumi")->size() == 20);
0388   }
0389 
0390   {
0391     auto lumi = tester.testEndLuminosityBlock();
0392     CPPUNIT_ASSERT(lumi.get<edmtest::ThingCollection>("beginLumi")->size() == 20);
0393     CPPUNIT_ASSERT(lumi.get<edmtest::ThingCollection>("endLumi")->size() == 20);
0394   }
0395 
0396   {
0397     auto lumi = tester.testBeginLuminosityBlock(2);
0398     CPPUNIT_ASSERT(lumi.get<edmtest::ThingCollection>("beginLumi")->size() == 20);
0399   }
0400 }
0401 
0402 void testTestProcessor::runStreamAnalyzerTest() {
0403   auto const kTest = R"_(from FWCore.TestProcessor.TestProcess import *
0404 process = TestProcess()
0405 process.toTest = cms.EDAnalyzer('edmtest::stream::RunIntAnalyzer',
0406     transitions = cms.int32(2)
0407     ,cachevalue = cms.int32(0)
0408 )
0409 
0410 process.moduleToTest(process.toTest)
0411 )_";
0412   edm::test::TestProcessor::Config config(kTest);
0413   edm::test::TestProcessor tester(config);
0414   tester.testBeginLuminosityBlock(1);
0415   tester.testEndLuminosityBlock();
0416   tester.testBeginLuminosityBlock(2);
0417 }
0418 
0419 void testTestProcessor::lumiStreamAnalyzerTest() {
0420   auto const kTest = R"_(from FWCore.TestProcessor.TestProcess import *
0421 process = TestProcess()
0422 process.toTest = cms.EDAnalyzer('edmtest::stream::LumiIntAnalyzer',
0423     transitions = cms.int32(4)
0424     ,cachevalue = cms.int32(0)
0425     ,moduleLabel = cms.InputTag("")
0426 )
0427 
0428 process.moduleToTest(process.toTest)
0429 )_";
0430   edm::test::TestProcessor::Config config(kTest);
0431   edm::test::TestProcessor tester(config);
0432   tester.testBeginLuminosityBlock(1);
0433   tester.testEndLuminosityBlock();
0434   tester.testBeginLuminosityBlock(2);
0435 }
0436 
0437 #include <Utilities/Testing/interface/CppUnit_testdriver.icpp>
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!