Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 13:28:49

0001 #include "FWCore/TestProcessor/interface/TestProcessor.h"
0002 #include "FWCore/Utilities/interface/Exception.h"
0003 #include "DataFormats/Common/interface/ErrorSummaryEntry.h"
0004 
0005 #include <vector>
0006 #include "catch.hpp"
0007 
0008 static constexpr auto s_tag = "[LogErrorFilter]";
0009 TEST_CASE("Tests of LogErrorFilter", s_tag) {
0010   const std::string baseConfig{
0011       R"_(from FWCore.TestProcessor.TestProcess import *
0012 process = TestProcess()
0013 process.errorFilter = cms.EDFilter('LogErrorFilter',
0014                       harvesterTag = cms.InputTag('in'),
0015                       atLeastOneError = cms.bool(True),
0016                       atLeastOneWarning = cms.bool(True),
0017                       useThresholdsPerKind = cms.bool(False),
0018                       maxErrorKindsPerLumi = cms.uint32(1),
0019                       maxWarningKindsPerLumi = cms.uint32(1),
0020                       avoidCategories = cms.vstring()
0021 )
0022 
0023 process.moduleToTest(process.errorFilter)
0024 )_"};
0025 
0026   SECTION("No threshhold, both warnings and errors") {
0027     edm::test::TestProcessor::Config config{baseConfig};
0028 
0029     using ESVec = std::vector<edm::ErrorSummaryEntry>;
0030     auto const putToken = config.produces<ESVec>("in");
0031 
0032     edm::test::TestProcessor tester(config);
0033     REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>())).modulePassed());
0034 
0035     {
0036       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_error}};
0037       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0038       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0039     }
0040     {
0041       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_warning}};
0042       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0043       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0044     }
0045     {
0046       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_fwkInfo}};
0047       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0048       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0049     }
0050     {
0051       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_info}};
0052       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0053       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0054     }
0055   }
0056 
0057   SECTION("No threshhold, just errors") {
0058     edm::test::TestProcessor::Config config{baseConfig +
0059                                             R"_(
0060 process.errorFilter.atLeastOneWarning = False
0061 )_"};
0062 
0063     using ESVec = std::vector<edm::ErrorSummaryEntry>;
0064     auto const putToken = config.produces<ESVec>("in");
0065 
0066     edm::test::TestProcessor tester(config);
0067     REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>())).modulePassed());
0068 
0069     {
0070       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_error}};
0071       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0072       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0073     }
0074     {
0075       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_warning}};
0076       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0077       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0078     }
0079     {
0080       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_fwkInfo}};
0081       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0082       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0083     }
0084     {
0085       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_info}};
0086       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0087       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0088     }
0089   }
0090 
0091   SECTION("No threshhold, just warnings") {
0092     edm::test::TestProcessor::Config config{baseConfig +
0093                                             R"_(
0094 process.errorFilter.atLeastOneError = False
0095 )_"};
0096 
0097     using ESVec = std::vector<edm::ErrorSummaryEntry>;
0098     auto const putToken = config.produces<ESVec>("in");
0099 
0100     edm::test::TestProcessor tester(config);
0101     REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>())).modulePassed());
0102 
0103     {
0104       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_error}};
0105       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0106       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0107     }
0108     {
0109       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_warning}};
0110       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0111       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0112     }
0113     {
0114       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_fwkInfo}};
0115       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0116       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0117     }
0118     {
0119       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_info}};
0120       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0121       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0122     }
0123   }
0124 
0125   SECTION("No threshhold, errors, warnings, and categories") {
0126     edm::test::TestProcessor::Config config{baseConfig +
0127                                             R"_(
0128 process.errorFilter.avoidCategories = ["IgnoreCat"]
0129 )_"};
0130 
0131     using ESVec = std::vector<edm::ErrorSummaryEntry>;
0132     auto const putToken = config.produces<ESVec>("in");
0133 
0134     edm::test::TestProcessor tester(config);
0135     REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>())).modulePassed());
0136 
0137     {
0138       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_error}};
0139       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0140       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0141     }
0142     {
0143       ESVec errors = {{"IgnoreCat", "mod", edm::ELseverityLevel::ELsev_error}};
0144       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0145     }
0146     {
0147       ESVec errors = {{"IgnoreCat", "mod", edm::ELseverityLevel::ELsev_error},
0148                       {"Cat", "mod", edm::ELseverityLevel::ELsev_error}};
0149       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0150     }
0151     {
0152       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_warning}};
0153       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0154       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0155     }
0156     {
0157       ESVec errors = {{"IgnoreCat", "mod", edm::ELseverityLevel::ELsev_warning}};
0158       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0159     }
0160     {
0161       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_fwkInfo}};
0162       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0163       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0164     }
0165     {
0166       ESVec errors = {{"IgnoreCat", "mod", edm::ELseverityLevel::ELsev_fwkInfo}};
0167       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0168     }
0169     {
0170       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_info}};
0171       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0172       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0173     }
0174     {
0175       ESVec errors = {{"IgnoreCat", "mod", edm::ELseverityLevel::ELsev_info}};
0176       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0177     }
0178   };
0179   SECTION("threshhold of 1, both warnings and errors") {
0180     edm::test::TestProcessor::Config config{baseConfig +
0181                                             R"_(
0182 process.errorFilter.useThresholdsPerKind = True
0183 )_"
0184 
0185     };
0186 
0187     using ESVec = std::vector<edm::ErrorSummaryEntry>;
0188     auto const putToken = config.produces<ESVec>("in");
0189 
0190     edm::test::TestProcessor tester(config);
0191     REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>())).modulePassed());
0192 
0193     {
0194       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_error}};
0195       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0196       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0197     }
0198     {
0199       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_warning}};
0200       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0201       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0202     }
0203     {
0204       ESVec errors = {{"Cat2", "mod", edm::ELseverityLevel::ELsev_error}};
0205       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0206       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0207     }
0208     {
0209       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_fwkInfo}};
0210       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0211       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0212     }
0213     {
0214       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_info}};
0215       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0216       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0217     }
0218     tester.setLuminosityBlockNumber(2);
0219     {
0220       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_error}};
0221       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0222       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0223     }
0224     {
0225       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_warning}};
0226       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0227       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0228     }
0229     {
0230       ESVec errors = {{"Cat2", "mod", edm::ELseverityLevel::ELsev_error}};
0231       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0232       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0233     }
0234   }
0235 
0236   SECTION("threshhold of 1, both warnings and errors, and categories") {
0237     edm::test::TestProcessor::Config config{baseConfig +
0238                                             R"_(
0239 process.errorFilter.useThresholdsPerKind = True
0240 process.errorFilter.avoidCategories = ["IgnoreCat"]
0241 )_"
0242 
0243     };
0244 
0245     using ESVec = std::vector<edm::ErrorSummaryEntry>;
0246     auto const putToken = config.produces<ESVec>("in");
0247 
0248     edm::test::TestProcessor tester(config);
0249     REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>())).modulePassed());
0250 
0251     {
0252       ESVec errors = {{"IgnoreCat", "mod", edm::ELseverityLevel::ELsev_error}};
0253       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0254     }
0255     {
0256       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_error}};
0257       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0258       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0259     }
0260     {
0261       ESVec errors = {{"IgnoreCat", "mod", edm::ELseverityLevel::ELsev_warning}};
0262       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0263     }
0264     {
0265       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_warning}};
0266       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0267       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0268     }
0269     {
0270       ESVec errors = {{"Cat2", "mod", edm::ELseverityLevel::ELsev_error}};
0271       REQUIRE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0272       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0273     }
0274     {
0275       ESVec errors = {{"IgnoreCat", "mod", edm::ELseverityLevel::ELsev_fwkInfo}};
0276       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0277     }
0278     {
0279       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_fwkInfo}};
0280       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0281       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0282     }
0283     {
0284       ESVec errors = {{"IgnoreCat", "mod", edm::ELseverityLevel::ELsev_info}};
0285       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0286     }
0287     {
0288       ESVec errors = {{"Cat", "mod", edm::ELseverityLevel::ELsev_info}};
0289       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0290       REQUIRE_FALSE(tester.test(std::make_pair(putToken, std::make_unique<ESVec>(errors))).modulePassed());
0291     }
0292   }
0293 
0294   SECTION("Missing data") {
0295     edm::test::TestProcessor::Config config{baseConfig};
0296     edm::test::TestProcessor tester(config);
0297 
0298     REQUIRE_FALSE(tester.test().modulePassed());
0299   }
0300 }