File indexing completed on 2024-05-23 03:13:16
0001
0002
0003
0004
0005 #include "catch.hpp"
0006
0007 #include "DataFormats/Provenance/interface/EventID.h"
0008 #include "DataFormats/Provenance/interface/LuminosityBlockID.h"
0009 #include "FWCore/ParameterSet/interface/AllowedLabelsDescription.h"
0010 #include "FWCore/ParameterSet/interface/IfExistsDescription.h"
0011 #include "FWCore/Utilities/interface/FileInPath.h"
0012 #include "FWCore/ParameterSet/interface/ParameterDescriptionBase.h"
0013 #include "FWCore/ParameterSet/interface/ParameterDescriptionNode.h"
0014 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0015 #include "FWCore/ParameterSet/interface/ParameterWildcardWithSpecifics.h"
0016 #include "FWCore/ParameterSet/interface/allowedValues.h"
0017 #include "FWCore/ParameterSet/interface/PluginDescription.h"
0018 #include "FWCore/ParameterSet/interface/ValidatedPluginMacros.h"
0019 #include "FWCore/ParameterSet/interface/ValidatedPluginFactoryMacros.h"
0020 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0021 #include "FWCore/PluginManager/interface/PluginManager.h"
0022 #include "FWCore/PluginManager/interface/standard.h"
0023 #include "FWCore/Utilities/interface/EDMException.h"
0024 #include "FWCore/Utilities/interface/Exception.h"
0025 #include "FWCore/Utilities/interface/InputTag.h"
0026
0027 #include <cassert>
0028 #include <iostream>
0029 #include <string>
0030 #include <vector>
0031
0032 namespace testParameterSetDescription {
0033
0034 void testDesc(edm::ParameterDescriptionNode const& node,
0035 edm::ParameterSetDescription const& psetDesc,
0036 edm::ParameterSet& pset,
0037 bool exists,
0038 bool validates) {
0039 CHECK(node.exists(pset) == exists);
0040 CHECK(node.partiallyExists(pset) == exists);
0041 CHECK(node.howManyXORSubNodesExist(pset) == (exists ? 1 : 0));
0042 if (validates) {
0043 psetDesc.validate(pset);
0044 } else {
0045 REQUIRE_THROWS_AS(psetDesc.validate(pset), edm::Exception);
0046 }
0047 }
0048
0049 struct TestPluginBase {
0050 virtual ~TestPluginBase() = default;
0051 };
0052
0053 struct ATestPlugin : public TestPluginBase {
0054 static void fillPSetDescription(edm::ParameterSetDescription& iPS) { iPS.add<int>("anInt", 5); }
0055 };
0056
0057 struct BTestPlugin : public TestPluginBase {
0058 static void fillPSetDescription(edm::ParameterSetDescription& iPS) { iPS.add<double>("aDouble", 0.5); }
0059 };
0060
0061 using TestPluginFactory = edmplugin::PluginFactory<testParameterSetDescription::TestPluginBase*()>;
0062
0063 }
0064
0065 using TestPluginFactory = testParameterSetDescription::TestPluginFactory;
0066
0067 using testParameterSetDescription::testDesc;
0068
0069 TEST_CASE("test ParameterSetDescription", "[ParameterSetDescription]") {
0070 SECTION("testWildcards") {
0071 using Catch::Matchers::Equals;
0072 {
0073 edm::ParameterSetDescription set;
0074 edm::ParameterWildcard<int> w("*", edm::RequireZeroOrMore, true);
0075 set.addNode(w);
0076 edm::ParameterSet pset;
0077 testDesc(w, set, pset, true, true);
0078 pset.addParameter<int>("x", 1);
0079 testDesc(w, set, pset, true, true);
0080 pset.addParameter<int>("y", 1);
0081 testDesc(w, set, pset, true, true);
0082 pset.addParameter<unsigned>("z", 1);
0083 testDesc(w, set, pset, true, false);
0084
0085 SECTION("cfi generation") {
0086 std::ostringstream os;
0087 bool startWithComma = false;
0088 bool wroteSomething = false;
0089 edm::CfiOptions ops = edm::cfi::Typed{};
0090 w.writeCfi(os, false, startWithComma, 0, ops, wroteSomething);
0091
0092 REQUIRE_THAT(os.str(), Equals("\nallowAnyLabel_ = cms.required.int32"));
0093 }
0094 }
0095
0096 {
0097 edm::ParameterSetDescription set;
0098 edm::ParameterWildcard<unsigned> w("*", edm::RequireExactlyOne, false);
0099 set.addNode(w);
0100 edm::ParameterSet pset;
0101 testDesc(w, set, pset, false, false);
0102 pset.addUntrackedParameter<unsigned>("x", 1);
0103 testDesc(w, set, pset, true, true);
0104 pset.addUntrackedParameter<unsigned>("y", 1);
0105 testDesc(w, set, pset, false, false);
0106
0107 SECTION("cfi generation") {
0108 std::ostringstream os;
0109 bool startWithComma = false;
0110 bool wroteSomething = false;
0111 edm::CfiOptions ops = edm::cfi::Typed{};
0112
0113 w.writeCfi(os, false, startWithComma, 0, ops, wroteSomething);
0114
0115 REQUIRE_THAT(os.str(), Equals("\nallowAnyLabel_ = cms.required.untracked.uint32"));
0116 }
0117 }
0118
0119 {
0120 edm::ParameterSetDescription set;
0121 edm::ParameterWildcard<unsigned> w("*", edm::RequireExactlyOne, false);
0122 set.addOptionalNode(w, false);
0123 edm::ParameterSet pset;
0124 testDesc(w, set, pset, false, true);
0125 pset.addUntrackedParameter<unsigned>("x", 1);
0126 testDesc(w, set, pset, true, true);
0127 pset.addUntrackedParameter<unsigned>("y", 1);
0128 testDesc(w, set, pset, false, false);
0129 }
0130
0131 {
0132 edm::ParameterSetDescription set;
0133 edm::ParameterWildcard<unsigned> w("*", edm::RequireAtLeastOne, false);
0134 set.addOptionalNode(w, false);
0135 edm::ParameterSet pset;
0136 testDesc(w, set, pset, false, true);
0137 pset.addUntrackedParameter<unsigned>("x", 1);
0138 testDesc(w, set, pset, true, true);
0139 pset.addUntrackedParameter<unsigned>("y", 1);
0140 testDesc(w, set, pset, true, true);
0141 }
0142
0143 {
0144 edm::ParameterSetDescription set;
0145 edm::ParameterWildcard<double> w("*", edm::RequireAtLeastOne, true);
0146 set.addNode(w);
0147 edm::ParameterSet pset;
0148 testDesc(w, set, pset, false, false);
0149 pset.addParameter<double>("x", 1);
0150 testDesc(w, set, pset, true, true);
0151 pset.addParameter<double>("y", 1);
0152 testDesc(w, set, pset, true, true);
0153
0154 SECTION("cfi generation") {
0155 std::ostringstream os;
0156 bool startWithComma = false;
0157 bool wroteSomething = false;
0158 edm::CfiOptions ops = edm::cfi::Typed{};
0159
0160 w.writeCfi(os, false, startWithComma, 0, ops, wroteSomething);
0161
0162 REQUIRE_THAT(os.str(), Equals("\nallowAnyLabel_ = cms.required.double"));
0163 }
0164 }
0165
0166 {
0167 edm::ParameterSetDescription set;
0168 edm::ParameterWildcard<double> w("*", edm::RequireAtLeastOne, true);
0169 set.addNode(w);
0170 set.add<int>("testTypeChecking1", 11);
0171 REQUIRE_THROWS_AS(set.add<double>("testTypeChecking2", 11.0), edm::Exception);
0172 }
0173
0174 REQUIRE_THROWS_AS(edm::ParameterWildcard<int>("a*", edm::RequireZeroOrMore, true), edm::Exception);
0175
0176 edm::ParameterSet nestedPset;
0177 nestedPset.addUntrackedParameter<unsigned>("n1", 1);
0178
0179 {
0180 edm::ParameterSetDescription set;
0181 edm::ParameterWildcard<edm::ParameterSetDescription> w("*", edm::RequireZeroOrMore, true);
0182 set.addNode(w);
0183 edm::ParameterSet pset;
0184 testDesc(w, set, pset, true, true);
0185 pset.addParameter<edm::ParameterSet>("nested1", nestedPset);
0186 testDesc(w, set, pset, true, true);
0187 pset.addParameter<edm::ParameterSet>("nested2", nestedPset);
0188 testDesc(w, set, pset, true, true);
0189
0190 SECTION("cfi generation") {
0191 std::ostringstream os;
0192 bool startWithComma = false;
0193 bool wroteSomething = false;
0194 edm::CfiOptions ops = edm::cfi::Typed{};
0195 w.writeCfi(os, false, startWithComma, 0, ops, wroteSomething);
0196
0197 REQUIRE_THAT(os.str(), Equals("\nallowAnyLabel_ = cms.required.PSetTemplate()"));
0198 }
0199 }
0200
0201 {
0202 edm::ParameterSetDescription set;
0203 edm::ParameterWildcard<edm::ParameterSetDescription> w(std::string("*"), edm::RequireZeroOrMore, true);
0204 set.addNode(w);
0205 edm::ParameterSet pset;
0206 testDesc(w, set, pset, true, true);
0207 pset.addParameter<edm::ParameterSet>("nested1", nestedPset);
0208 testDesc(w, set, pset, true, true);
0209 pset.addParameter<edm::ParameterSet>("nested2", nestedPset);
0210 testDesc(w, set, pset, true, true);
0211 }
0212
0213 {
0214 edm::ParameterSetDescription set;
0215 edm::ParameterWildcard<edm::ParameterSetDescription> w(
0216 "*", edm::RequireZeroOrMore, true, edm::ParameterSetDescription());
0217 set.addNode(w);
0218 edm::ParameterSet pset;
0219 testDesc(w, set, pset, true, true);
0220 pset.addParameter<edm::ParameterSet>("nested1", nestedPset);
0221 testDesc(w, set, pset, true, false);
0222 pset.addParameter<edm::ParameterSet>("nested2", nestedPset);
0223 testDesc(w, set, pset, true, false);
0224 }
0225
0226 edm::ParameterSetDescription nestedDesc;
0227 nestedDesc.addUntracked<unsigned>("n1", 1);
0228
0229 {
0230 edm::ParameterSetDescription set;
0231 edm::ParameterWildcard<edm::ParameterSetDescription> w("*", edm::RequireZeroOrMore, true, nestedDesc);
0232 set.addNode(w);
0233 edm::ParameterSet pset;
0234 testDesc(w, set, pset, true, true);
0235 pset.addParameter<edm::ParameterSet>("nested1", nestedPset);
0236 testDesc(w, set, pset, true, true);
0237 pset.addParameter<edm::ParameterSet>("nested2", nestedPset);
0238 testDesc(w, set, pset, true, true);
0239
0240 SECTION("cfi generation") {
0241 std::ostringstream os;
0242 bool startWithComma = false;
0243 bool wroteSomething = false;
0244 edm::CfiOptions ops = edm::cfi::Typed{};
0245 w.writeCfi(os, false, startWithComma, 0, ops, wroteSomething);
0246
0247 REQUIRE_THAT(os.str(),
0248 Equals("\nallowAnyLabel_ = cms.required.PSetTemplate(\n n1 = cms.untracked.uint32(1)\n)"));
0249 }
0250 }
0251
0252 {
0253 edm::ParameterSetDescription set;
0254 edm::ParameterWildcard<edm::ParameterSetDescription> w(
0255 std::string("*"), edm::RequireExactlyOne, true, nestedDesc);
0256 set.addNode(w);
0257 edm::ParameterSet pset;
0258 testDesc(w, set, pset, false, false);
0259 pset.addParameter<edm::ParameterSet>("nested1", nestedPset);
0260 testDesc(w, set, pset, true, true);
0261 pset.addParameter<edm::ParameterSet>("nested2", nestedPset);
0262 testDesc(w, set, pset, false, false);
0263 }
0264
0265 {
0266 edm::ParameterSetDescription set;
0267 edm::ParameterWildcard<edm::ParameterSetDescription> w("*", edm::RequireAtLeastOne, true, nestedDesc);
0268 set.addNode(w);
0269 edm::ParameterSet pset;
0270 testDesc(w, set, pset, false, false);
0271 pset.addParameter<edm::ParameterSet>("nested1", nestedPset);
0272 testDesc(w, set, pset, true, true);
0273 pset.addParameter<edm::ParameterSet>("nested2", nestedPset);
0274 testDesc(w, set, pset, true, true);
0275 }
0276
0277 std::vector<edm::ParameterSet> nestedVPset;
0278 edm::ParameterSet vectorElement;
0279 vectorElement.addUntrackedParameter<unsigned>("n11", 1);
0280 nestedVPset.push_back(vectorElement);
0281 nestedVPset.push_back(vectorElement);
0282
0283 {
0284 edm::ParameterSetDescription set;
0285 edm::ParameterWildcard<std::vector<edm::ParameterSet>> w("*", edm::RequireZeroOrMore, true);
0286 set.addNode(w);
0287 edm::ParameterSet pset;
0288 testDesc(w, set, pset, true, true);
0289 pset.addParameter<std::vector<edm::ParameterSet>>("nested1", nestedVPset);
0290 testDesc(w, set, pset, true, true);
0291 pset.addParameter<std::vector<edm::ParameterSet>>("nested2", nestedVPset);
0292 testDesc(w, set, pset, true, true);
0293 SECTION("cfi generation") {
0294 std::ostringstream os;
0295 bool startWithComma = false;
0296 bool wroteSomething = false;
0297 edm::CfiOptions ops = edm::cfi::Typed{};
0298 w.writeCfi(os, false, startWithComma, 0, ops, wroteSomething);
0299
0300 REQUIRE_THAT(os.str(), Equals("\nallowAnyLabel_ = cms.required.VPSet"));
0301 }
0302 }
0303
0304 {
0305 edm::ParameterSetDescription set;
0306 edm::ParameterWildcard<std::vector<edm::ParameterSet>> w(std::string("*"), edm::RequireZeroOrMore, true);
0307 set.addNode(w);
0308 edm::ParameterSet pset;
0309 testDesc(w, set, pset, true, true);
0310 pset.addParameter<std::vector<edm::ParameterSet>>("nested1", nestedVPset);
0311 testDesc(w, set, pset, true, true);
0312 pset.addParameter<std::vector<edm::ParameterSet>>("nested2", nestedVPset);
0313 testDesc(w, set, pset, true, true);
0314 }
0315
0316 {
0317 edm::ParameterSetDescription set;
0318 edm::ParameterWildcard<std::vector<edm::ParameterSet>> w(
0319 "*", edm::RequireZeroOrMore, true, edm::ParameterSetDescription());
0320 set.addNode(w);
0321 edm::ParameterSet pset;
0322 testDesc(w, set, pset, true, true);
0323 pset.addParameter<std::vector<edm::ParameterSet>>("nested1", nestedVPset);
0324 testDesc(w, set, pset, true, false);
0325 pset.addParameter<std::vector<edm::ParameterSet>>("nested2", nestedVPset);
0326 testDesc(w, set, pset, true, false);
0327 }
0328
0329 edm::ParameterSetDescription descElement;
0330 descElement.addUntracked<unsigned>("n11", 1);
0331 {
0332 edm::ParameterSetDescription set;
0333 edm::ParameterWildcard<std::vector<edm::ParameterSet>> w("*", edm::RequireZeroOrMore, true, descElement);
0334 set.addNode(w);
0335 edm::ParameterSet pset;
0336 testDesc(w, set, pset, true, true);
0337 pset.addParameter<std::vector<edm::ParameterSet>>("nested1", nestedVPset);
0338 testDesc(w, set, pset, true, true);
0339 pset.addParameter<std::vector<edm::ParameterSet>>("nested2", nestedVPset);
0340 testDesc(w, set, pset, true, true);
0341 }
0342
0343 {
0344 edm::ParameterSetDescription set;
0345 edm::ParameterWildcard<std::vector<edm::ParameterSet>> w(
0346 std::string("*"), edm::RequireExactlyOne, true, descElement);
0347 set.addNode(w);
0348 edm::ParameterSet pset;
0349 testDesc(w, set, pset, false, false);
0350 pset.addParameter<std::vector<edm::ParameterSet>>("nested1", nestedVPset);
0351 testDesc(w, set, pset, true, true);
0352 pset.addParameter<std::vector<edm::ParameterSet>>("nested2", nestedVPset);
0353 testDesc(w, set, pset, false, false);
0354 }
0355
0356 {
0357 edm::ParameterSetDescription set;
0358 edm::ParameterWildcard<std::vector<edm::ParameterSet>> w("*", edm::RequireAtLeastOne, true, descElement);
0359 set.addNode(w);
0360 edm::ParameterSet pset;
0361 testDesc(w, set, pset, false, false);
0362 pset.addParameter<std::vector<edm::ParameterSet>>("nested1", nestedVPset);
0363 testDesc(w, set, pset, true, true);
0364 pset.addParameter<std::vector<edm::ParameterSet>>("nested2", nestedVPset);
0365 testDesc(w, set, pset, true, true);
0366 }
0367 }
0368
0369 SECTION("testWildcardWithExceptions") {
0370 {
0371 edm::ParameterSetDescription set;
0372
0373 edm::ParameterSetDescription wild;
0374 wild.addUntracked<unsigned>("n11", 1);
0375
0376 edm::ParameterSetDescription except_;
0377 except_.addUntracked<double>("f", 3.14);
0378 std::map<std::string, edm::ParameterSetDescription> excptions = {{"special", except_}};
0379 edm::ParameterWildcardWithSpecifics w("*", edm::RequireZeroOrMore, true, wild, std::move(excptions));
0380 set.addNode(w);
0381 edm::ParameterSet pset;
0382 testDesc(w, set, pset, true, true);
0383 edm::ParameterSet nested1;
0384 nested1.addUntrackedParameter<unsigned>("n11", 3);
0385 pset.addParameter<edm::ParameterSet>("nested1", nested1);
0386 testDesc(w, set, pset, true, true);
0387 edm::ParameterSet special;
0388 special.addUntrackedParameter<double>("f", 5);
0389 pset.addParameter<edm::ParameterSet>("special", special);
0390 testDesc(w, set, pset, true, true);
0391 }
0392
0393 {
0394 edm::ParameterSetDescription set;
0395
0396 edm::ParameterSetDescription wild;
0397 wild.add<unsigned>("n11", 1);
0398
0399 edm::ParameterSetDescription except_;
0400 except_.add<double>("f", 3.14);
0401 std::map<std::string, edm::ParameterSetDescription> excptions = {{"special", except_}};
0402 edm::ParameterWildcardWithSpecifics w("*", edm::RequireZeroOrMore, true, wild, std::move(excptions));
0403 set.addNode(w);
0404 edm::ParameterSet pset;
0405 testDesc(w, set, pset, true, true);
0406 edm::ParameterSet nested1;
0407 nested1.addParameter<unsigned>("n11", 3);
0408 pset.addParameter<edm::ParameterSet>("nested1", nested1);
0409 testDesc(w, set, pset, true, true);
0410 edm::ParameterSet special;
0411 special.addParameter<double>("f", 5);
0412 pset.addParameter<edm::ParameterSet>("special", special);
0413 testDesc(w, set, pset, true, true);
0414 }
0415 }
0416
0417
0418
0419 SECTION("testAllowedValues") {
0420
0421 edm::ParameterSetDescription psetDesc;
0422 psetDesc.ifValue(edm::ParameterDescription<std::string>("sswitch", "a", true),
0423 edm::allowedValues<std::string>("a", "h", "z"));
0424 }
0425
0426 SECTION("testSwitch") {
0427
0428 edm::ParameterSetDescription psetDesc;
0429 REQUIRE_THROWS_AS(psetDesc.ifValue(edm::ParameterDescription<int>("oiswitch", 1, true),
0430 0 >> edm::ParameterDescription<int>("oivalue", 100, true) or
0431 1 >> (edm::ParameterDescription<double>("oivalue1", 101.0, true) and
0432 edm::ParameterDescription<double>("oivalue2", 101.0, true)) or
0433 1 >> edm::ParameterDescription<std::string>("oivalue", "102", true)),
0434 edm::Exception);
0435
0436
0437 edm::ParameterSetDescription psetDesc1;
0438 edm::ParameterWildcard<double> w("*", edm::RequireAtLeastOne, true);
0439 psetDesc1.addNode(w);
0440
0441 REQUIRE_THROWS_AS(psetDesc1.ifValue(edm::ParameterDescription<int>("oiswitch", 1, true),
0442 0 >> edm::ParameterDescription<int>("oivalue", 100, true) or
0443 1 >> (edm::ParameterDescription<double>("oivalue1", 101.0, true) and
0444 edm::ParameterDescription<double>("oivalue2", 101.0, true)) or
0445 2 >> edm::ParameterDescription<std::string>("oivalue", "102", true)),
0446 edm::Exception);
0447
0448
0449 edm::ParameterSetDescription psetDesc2;
0450 edm::ParameterWildcard<int> w1("*", edm::RequireAtLeastOne, true);
0451 psetDesc2.addNode(w1);
0452
0453 REQUIRE_THROWS_AS(psetDesc2.ifValue(edm::ParameterDescription<int>("aswitch", 1, true),
0454 1 >> (edm::ParameterDescription<unsigned>("avalue1", 101, true) and
0455 edm::ParameterDescription<unsigned>("avalue2", 101, true)) or
0456 2 >> edm::ParameterDescription<std::string>("avalue", "102", true)),
0457 edm::Exception);
0458
0459
0460 edm::ParameterSetDescription psetDesc3;
0461 REQUIRE_THROWS_AS(psetDesc3.ifValue(edm::ParameterDescription<int>("xswitch", 1, true),
0462 0 >> edm::ParameterWildcard<int>("*", edm::RequireAtLeastOne, true) or
0463 1 >> (edm::ParameterDescription<double>("xvalue1", 101.0, true) and
0464 edm::ParameterDescription<double>("xvalue2", 101.0, true))),
0465 edm::Exception);
0466
0467
0468 edm::ParameterSetDescription psetDesc4;
0469 psetDesc4.add<unsigned>("testunsigned", 1U);
0470 REQUIRE_THROWS_AS(psetDesc4.ifValue(edm::ParameterDescription<int>("xswitch", 1, true),
0471 0 >> edm::ParameterWildcard<unsigned>("*", edm::RequireAtLeastOne, true) or
0472 1 >> (edm::ParameterDescription<double>("xvalue1", 101.0, true) and
0473 edm::ParameterDescription<double>("xvalue2", 101.0, true))),
0474 edm::Exception);
0475
0476
0477 edm::ParameterSetDescription psetDesc5;
0478 psetDesc5.ifValue(edm::ParameterDescription<int>("uswitch", 1, true),
0479 0 >> edm::ParameterWildcard<unsigned>("*", edm::RequireAtLeastOne, true) or
0480 1 >> (edm::ParameterDescription<unsigned>("uvalue1", 101, true) and
0481 edm::ParameterDescription<unsigned>("uvalue2", 101, true)));
0482
0483
0484 edm::ParameterSetDescription psetDesc6;
0485 psetDesc6.add<unsigned>("xswitch", 1U);
0486 REQUIRE_THROWS_AS(psetDesc6.ifValue(edm::ParameterDescription<int>("xswitch", 1, true),
0487 0 >> edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true) or
0488 1 >> (edm::ParameterDescription<double>("xvalue1", 101.0, true) and
0489 edm::ParameterDescription<double>("xvalue2", 101.0, true))),
0490 edm::Exception);
0491
0492
0493 edm::ParameterSetDescription psetDesc7;
0494 psetDesc7.add<unsigned>("xvalue1", 1U);
0495 REQUIRE_THROWS_AS(psetDesc7.ifValue(edm::ParameterDescription<int>("xswitch", 1, true),
0496 0 >> edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true) or
0497 1 >> (edm::ParameterDescription<double>("xvalue1", 101.0, true) and
0498 edm::ParameterDescription<double>("xvalue2", 101.0, true))),
0499 edm::Exception);
0500
0501
0502 edm::ParameterSetDescription psetDesc8;
0503 REQUIRE_THROWS_AS(psetDesc8.ifValue(edm::ParameterDescription<int>("xswitch", 1, true),
0504 0 >> edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true) or
0505 1 >> (edm::ParameterDescription<double>("xswitch", 101.0, true) and
0506 edm::ParameterDescription<double>("xvalue2", 101.0, true))),
0507 edm::Exception);
0508
0509
0510 edm::ParameterSetDescription psetDesc9;
0511
0512 psetDesc9.ifValue(edm::ParameterDescription<int>("xswitch", 1, true),
0513 0 >> edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true) or
0514 1 >> (edm::ParameterDescription<double>("xvalue1", 101.0, true) and
0515 edm::ParameterDescription<double>("xvalue2", 101.0, true)));
0516 edm::ParameterSet pset;
0517 pset.addParameter<int>("xswitch", 5);
0518 REQUIRE_THROWS_AS(psetDesc9.validate(pset), edm::Exception);
0519
0520 edm::ParameterSwitch<int> pswitch(edm::ParameterDescription<int>("xswitch", 1, true),
0521 0 >> edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true) or
0522 1 >> (edm::ParameterDescription<double>("xvalue1", 101.0, true) and
0523 edm::ParameterDescription<double>("xvalue2", 101.0, true)));
0524 edm::ParameterSetDescription psetDesc10;
0525 psetDesc10.addNode(pswitch);
0526 edm::ParameterSet pset10;
0527 testDesc(pswitch, psetDesc10, pset10, false, true);
0528 pset10.addParameter<int>("xswitch", 1);
0529 testDesc(pswitch, psetDesc10, pset10, true, true);
0530 }
0531
0532
0533
0534 SECTION("testXor") {
0535 edm::ParameterSetDescription psetDesc1;
0536 std::unique_ptr<edm::ParameterDescriptionNode> node1(
0537 edm::ParameterDescription<double>("x1", 101.0, true) xor
0538 (edm::ParameterDescription<double>("x1", 101.0, true) and
0539 edm::ParameterDescription<double>("x2", 101.0, true)) xor
0540 edm::ParameterDescription<double>("x1", 101.0, true) xor
0541 (edm::ParameterDescription<double>("x1", 101.0, true) or edm::ParameterDescription<double>("x2", 101.0, true)));
0542
0543 edm::ParameterSet pset1;
0544
0545 edm::ParameterSet pset2;
0546 pset2.addParameter("x1", 11.0);
0547 pset2.addParameter("x2", 12.0);
0548
0549 CHECK(node1->exists(pset1) == false);
0550 CHECK(node1->partiallyExists(pset1) == false);
0551 CHECK(node1->howManyXORSubNodesExist(pset1) == 0);
0552
0553 CHECK(node1->exists(pset2) == false);
0554 CHECK(node1->partiallyExists(pset2) == false);
0555 CHECK(node1->howManyXORSubNodesExist(pset2) == 4);
0556
0557
0558 psetDesc1.addNode(std::move(node1));
0559 REQUIRE_THROWS_AS(psetDesc1.validate(pset1), edm::Exception);
0560
0561
0562 REQUIRE_THROWS_AS(psetDesc1.validate(pset2), edm::Exception);
0563
0564
0565 edm::ParameterSetDescription psetDesc2;
0566 psetDesc2.add<unsigned>("xvalue1", 1U);
0567 std::unique_ptr<edm::ParameterDescriptionNode> node2(edm::ParameterDescription<double>("x1", 101.0, true) xor
0568 (edm::ParameterDescription<double>("x1", 101.0, true) and
0569 edm::ParameterDescription<double>("x2", 101.0, true)) xor
0570 edm::ParameterDescription<double>("x1", 101.0, true) xor
0571 (edm::ParameterDescription<double>("xvalue1", 101.0, true) or
0572 edm::ParameterDescription<double>("x2", 101.0, true)));
0573 REQUIRE_THROWS_AS(psetDesc2.addNode(std::move(node2)), edm::Exception);
0574
0575
0576 edm::ParameterSetDescription psetDesc3;
0577 std::unique_ptr<edm::ParameterDescriptionNode> node3(edm::ParameterDescription<double>("x1", 101.0, true) xor
0578 (edm::ParameterDescription<double>("x1", 101.0, true) and
0579 edm::ParameterDescription<double>("x2", 101.0, true)) xor
0580 edm::ParameterDescription<double>("x1", 101.0, true) xor
0581 (edm::ParameterDescription<double>("xvalue1", 101.0, true) or
0582 edm::ParameterDescription<double>("x2", 101.0, true)));
0583 psetDesc3.addNode(std::move(node3));
0584 REQUIRE_THROWS_AS(psetDesc3.add<unsigned>("xvalue1", 1U), edm::Exception);
0585
0586
0587 edm::ParameterSetDescription psetDesc4;
0588 std::unique_ptr<edm::ParameterDescriptionNode> node4(
0589 edm::ParameterDescription<double>("x1", 101.0, true) xor
0590 (edm::ParameterDescription<double>("x1", 101.0, true) and
0591 edm::ParameterDescription<unsigned>("x2", 101, true)) xor
0592 edm::ParameterDescription<double>("x1", 101.0, true) xor
0593 (edm::ParameterDescription<double>("x1", 101.0, true) or edm::ParameterDescription<double>("x2", 101.0, true)));
0594 psetDesc4.addNode(std::move(node4));
0595
0596 edm::ParameterWildcard<unsigned> w4("*", edm::RequireAtLeastOne, true);
0597 REQUIRE_THROWS_AS(psetDesc4.addNode(w4), edm::Exception);
0598
0599
0600 edm::ParameterSetDescription psetDesc5;
0601 std::unique_ptr<edm::ParameterDescriptionNode> node5(
0602 edm::ParameterDescription<double>("x1", 101.0, true) xor
0603 (edm::ParameterDescription<double>("x1", 101.0, true) and
0604 edm::ParameterWildcard<unsigned>("*", edm::RequireAtLeastOne, true)) xor
0605 edm::ParameterDescription<double>("x1", 101.0, true) xor
0606 (edm::ParameterDescription<double>("x1", 101.0, true) or
0607 edm::ParameterWildcard<unsigned>("*", edm::RequireAtLeastOne, true)));
0608 psetDesc5.addNode(std::move(node5));
0609
0610 edm::ParameterDescription<unsigned> n5("z5", edm::RequireAtLeastOne, true);
0611 REQUIRE_THROWS_AS(psetDesc5.addNode(n5), edm::Exception);
0612 }
0613
0614
0615
0616 SECTION("testOr") {
0617 edm::ParameterSetDescription psetDesc1;
0618 std::unique_ptr<edm::ParameterDescriptionNode> node1(edm::ParameterDescription<double>("x1", 101.0, true) or
0619 (edm::ParameterDescription<double>("x2", 101.0, true) and
0620 edm::ParameterDescription<double>("x3", 101.0, true)) or
0621 edm::ParameterDescription<double>("x4", 101.0, true) or
0622 (edm::ParameterDescription<double>("x5", 101.0, true) xor
0623 edm::ParameterDescription<double>("x6", 101.0, true)));
0624
0625 edm::ParameterSet pset1;
0626
0627 edm::ParameterSet pset2;
0628 pset2.addParameter("x1", 11.0);
0629 pset2.addParameter("x2", 12.0);
0630 pset2.addParameter("x3", 13.0);
0631 pset2.addParameter("x4", 14.0);
0632 pset2.addParameter("x5", 15.0);
0633
0634 CHECK(node1->exists(pset1) == false);
0635 CHECK(node1->partiallyExists(pset1) == false);
0636 CHECK(node1->howManyXORSubNodesExist(pset1) == 0);
0637
0638 CHECK(node1->exists(pset2) == true);
0639 CHECK(node1->partiallyExists(pset2) == true);
0640 CHECK(node1->howManyXORSubNodesExist(pset2) == 1);
0641
0642
0643 psetDesc1.addNode(std::move(node1));
0644 psetDesc1.validate(pset1);
0645
0646
0647 psetDesc1.validate(pset2);
0648
0649
0650 edm::ParameterSetDescription psetDesc2;
0651 psetDesc2.add<unsigned>("x1", 1U);
0652 std::unique_ptr<edm::ParameterDescriptionNode> node2(edm::ParameterDescription<double>("x1", 101.0, true) or
0653 (edm::ParameterDescription<double>("x2", 101.0, true) and
0654 edm::ParameterDescription<double>("x3", 101.0, true)) or
0655 edm::ParameterDescription<double>("x4", 101.0, true));
0656 REQUIRE_THROWS_AS(psetDesc2.addNode(std::move(node2)), edm::Exception);
0657
0658
0659 edm::ParameterSetDescription psetDesc3;
0660 std::unique_ptr<edm::ParameterDescriptionNode> node3(edm::ParameterDescription<double>("x1", 101.0, true) or
0661 (edm::ParameterDescription<double>("x2", 101.0, true) and
0662 edm::ParameterDescription<double>("x3", 101.0, true)) or
0663 edm::ParameterDescription<double>("x4", 101.0, true));
0664 psetDesc3.addNode(std::move(node3));
0665
0666 REQUIRE_THROWS_AS(psetDesc3.add<unsigned>("x1", 1U), edm::Exception);
0667
0668
0669 edm::ParameterSetDescription psetDesc4;
0670 std::unique_ptr<edm::ParameterDescriptionNode> node4(edm::ParameterDescription<double>("x1", 101.0, true) or
0671 (edm::ParameterDescription<double>("x2", 101.0, true) and
0672 edm::ParameterDescription<double>("x3", 101.0, true)) or
0673 edm::ParameterDescription<double>("x1", 101.0, true));
0674 REQUIRE_THROWS_AS(psetDesc4.addNode(std::move(node4)), edm::Exception);
0675
0676
0677
0678 edm::ParameterSetDescription psetDesc5;
0679 std::unique_ptr<edm::ParameterDescriptionNode> node5(
0680 edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true) or
0681 (edm::ParameterDescription<double>("x2", 101.0, true) and
0682 edm::ParameterDescription<unsigned>("x3", 101U, true)) or
0683 edm::ParameterDescription<unsigned>("x1", 101U, true));
0684 REQUIRE_THROWS_AS(psetDesc5.addNode(std::move(node5)), edm::Exception);
0685
0686
0687
0688 edm::ParameterSetDescription psetDesc6;
0689 psetDesc6.add<double>("x0", 1.0);
0690 std::unique_ptr<edm::ParameterDescriptionNode> node6(
0691 edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true) or
0692 (edm::ParameterDescription<unsigned>("x2", 101U, true) and
0693 edm::ParameterDescription<unsigned>("x3", 101U, true)) or
0694 edm::ParameterDescription<unsigned>("x1", 101U, true));
0695 REQUIRE_THROWS_AS(psetDesc6.addNode(std::move(node6)), edm::Exception);
0696
0697
0698
0699 edm::ParameterSetDescription psetDesc7;
0700 psetDesc7.addWildcard<double>("*");
0701 std::unique_ptr<edm::ParameterDescriptionNode> node7(edm::ParameterDescription<double>("x0", 1.0, true) or
0702 (edm::ParameterDescription<unsigned>("x2", 101U, true) and
0703 edm::ParameterDescription<unsigned>("x3", 101U, true)) or
0704 edm::ParameterDescription<unsigned>("x1", 101U, true));
0705 REQUIRE_THROWS_AS(psetDesc7.addNode(std::move(node7)), edm::Exception);
0706 }
0707
0708
0709
0710 SECTION("testAnd") {
0711 edm::ParameterSetDescription psetDesc1;
0712 std::unique_ptr<edm::ParameterDescriptionNode> node1(edm::ParameterDescription<double>("x1", 101.0, true) and
0713 (edm::ParameterDescription<double>("x2", 101.0, true) or
0714 edm::ParameterDescription<double>("x3", 101.0, true)) and
0715 edm::ParameterDescription<double>("x4", 101.0, true) and
0716 (edm::ParameterDescription<double>("x5", 101.0, true) xor
0717 edm::ParameterDescription<double>("x6", 101.0, true)));
0718
0719 edm::ParameterSet pset1;
0720
0721 edm::ParameterSet pset2;
0722 pset2.addParameter("x1", 11.0);
0723 pset2.addParameter("x2", 12.0);
0724 pset2.addParameter("x3", 13.0);
0725 pset2.addParameter("x4", 14.0);
0726 pset2.addParameter("x5", 15.0);
0727
0728 edm::ParameterSet pset3;
0729 pset3.addParameter("x3", 13.0);
0730
0731 CHECK(node1->exists(pset1) == false);
0732 CHECK(node1->partiallyExists(pset1) == false);
0733 CHECK(node1->howManyXORSubNodesExist(pset1) == 0);
0734
0735 CHECK(node1->exists(pset2) == true);
0736 CHECK(node1->partiallyExists(pset2) == true);
0737 CHECK(node1->howManyXORSubNodesExist(pset2) == 1);
0738
0739 CHECK(node1->exists(pset3) == false);
0740 CHECK(node1->partiallyExists(pset3) == true);
0741 CHECK(node1->howManyXORSubNodesExist(pset3) == 0);
0742
0743 psetDesc1.addNode(std::move(node1));
0744 psetDesc1.validate(pset1);
0745 psetDesc1.validate(pset2);
0746 psetDesc1.validate(pset3);
0747
0748
0749 edm::ParameterSetDescription psetDesc2;
0750 psetDesc2.add<unsigned>("x1", 1U);
0751 std::unique_ptr<edm::ParameterDescriptionNode> node2(edm::ParameterDescription<double>("x1", 101.0, true) and
0752 (edm::ParameterDescription<double>("x2", 101.0, true) or
0753 edm::ParameterDescription<double>("x3", 101.0, true)) and
0754 edm::ParameterDescription<double>("x4", 101.0, true));
0755 REQUIRE_THROWS_AS(psetDesc2.addNode(std::move(node2)), edm::Exception);
0756
0757
0758 edm::ParameterSetDescription psetDesc3;
0759 std::unique_ptr<edm::ParameterDescriptionNode> node3(edm::ParameterDescription<double>("x1", 101.0, true) and
0760 (edm::ParameterDescription<double>("x2", 101.0, true) or
0761 edm::ParameterDescription<double>("x3", 101.0, true)) and
0762 edm::ParameterDescription<double>("x4", 101.0, true));
0763 psetDesc3.addNode(std::move(node3));
0764
0765 REQUIRE_THROWS_AS(psetDesc3.add<unsigned>("x1", 1U), edm::Exception);
0766
0767
0768 edm::ParameterSetDescription psetDesc4;
0769 std::unique_ptr<edm::ParameterDescriptionNode> node4(edm::ParameterDescription<double>("x1", 101.0, true) and
0770 (edm::ParameterDescription<double>("x2", 101.0, true) or
0771 edm::ParameterDescription<double>("x3", 101.0, true)) and
0772 edm::ParameterDescription<double>("x1", 101.0, true));
0773 REQUIRE_THROWS_AS(psetDesc4.addNode(std::move(node4)), edm::Exception);
0774
0775
0776
0777 edm::ParameterSetDescription psetDesc5;
0778 std::unique_ptr<edm::ParameterDescriptionNode> node5(
0779 edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true) and
0780 (edm::ParameterDescription<double>("x2", 101.0, true) or
0781 edm::ParameterDescription<unsigned>("x3", 101U, true)) and
0782 edm::ParameterDescription<unsigned>("x1", 101U, true));
0783 REQUIRE_THROWS_AS(psetDesc5.addNode(std::move(node5)), edm::Exception);
0784
0785
0786
0787 edm::ParameterSetDescription psetDesc6;
0788 psetDesc6.add<double>("x0", 1.0);
0789 std::unique_ptr<edm::ParameterDescriptionNode> node6(
0790 edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true) and
0791 (edm::ParameterDescription<unsigned>("x2", 101U, true) or
0792 edm::ParameterDescription<unsigned>("x3", 101U, true)) and
0793 edm::ParameterDescription<unsigned>("x1", 101U, true));
0794 REQUIRE_THROWS_AS(psetDesc6.addNode(std::move(node6)), edm::Exception);
0795
0796
0797
0798 edm::ParameterSetDescription psetDesc7;
0799 psetDesc7.addWildcard<double>("*");
0800 std::unique_ptr<edm::ParameterDescriptionNode> node7(edm::ParameterDescription<double>("x0", 1.0, true) and
0801 (edm::ParameterDescription<unsigned>("x2", 101U, true) or
0802 edm::ParameterDescription<unsigned>("x3", 101U, true)) and
0803 edm::ParameterDescription<unsigned>("x1", 101U, true));
0804 REQUIRE_THROWS_AS(psetDesc7.addNode(std::move(node7)), edm::Exception);
0805 }
0806
0807
0808
0809 SECTION("testIfExists") {
0810 edm::ParameterSetDescription psetDesc1;
0811 std::unique_ptr<edm::ParameterDescriptionNode> node1(
0812 std::make_unique<edm::IfExistsDescription>(edm::ParameterDescription<double>("x1", 101.0, true),
0813 (edm::ParameterDescription<double>("x2", 101.0, true) and
0814 edm::ParameterDescription<double>("x3", 101.0, true))));
0815
0816 std::unique_ptr<edm::ParameterDescriptionNode> node1a(std::make_unique<edm::IfExistsDescription>(
0817 (edm::ParameterDescription<double>("x2", 101.0, true) and edm::ParameterDescription<double>("x3", 101.0, true)),
0818 edm::ParameterDescription<double>("x1", 101.0, true)));
0819
0820 std::unique_ptr<edm::ParameterDescriptionNode> node1b(std::make_unique<edm::IfExistsDescription>(
0821 (edm::ParameterDescription<double>("x1", 101.0, true) xor edm::ParameterDescription<int>("x1", 101, true)),
0822 (edm::ParameterDescription<double>("x2", 101.0, true) and
0823 edm::ParameterDescription<double>("x3", 101.0, true))));
0824
0825 edm::ParameterSet pset1;
0826
0827 edm::ParameterSet pset2;
0828 pset2.addParameter("x1", 11.0);
0829 pset2.addParameter("x2", 12.0);
0830 pset2.addParameter("x3", 13.0);
0831
0832 edm::ParameterSet pset3;
0833 pset3.addParameter("x1", 14.0);
0834
0835 edm::ParameterSet pset4;
0836 pset4.addParameter("x2", 15.0);
0837 pset4.addParameter("x3", 16.0);
0838
0839 CHECK(node1->exists(pset1) == true);
0840 CHECK(node1->partiallyExists(pset1) == true);
0841 CHECK(node1->howManyXORSubNodesExist(pset1) == 1);
0842 CHECK(node1a->exists(pset1) == true);
0843 CHECK(node1b->exists(pset1) == true);
0844
0845 CHECK(node1->exists(pset2) == true);
0846 CHECK(node1->partiallyExists(pset2) == true);
0847 CHECK(node1->howManyXORSubNodesExist(pset2) == 1);
0848 CHECK(node1a->exists(pset2) == true);
0849 CHECK(node1b->exists(pset2) == true);
0850
0851 CHECK(node1->exists(pset3) == false);
0852 CHECK(node1->partiallyExists(pset3) == false);
0853 CHECK(node1->howManyXORSubNodesExist(pset3) == 0);
0854 CHECK(node1a->exists(pset3) == false);
0855 CHECK(node1b->exists(pset3) == false);
0856
0857 CHECK(node1->exists(pset4) == false);
0858 CHECK(node1->partiallyExists(pset4) == false);
0859 CHECK(node1->howManyXORSubNodesExist(pset4) == 0);
0860 CHECK(node1a->exists(pset4) == false);
0861 CHECK(node1b->exists(pset4) == false);
0862
0863 psetDesc1.addNode(std::move(node1));
0864 psetDesc1.validate(pset1);
0865 psetDesc1.validate(pset2);
0866 psetDesc1.validate(pset3);
0867 psetDesc1.validate(pset3);
0868
0869
0870 edm::ParameterSetDescription psetDesc2;
0871 psetDesc2.add<unsigned>("x1", 1U);
0872 std::unique_ptr<edm::ParameterDescriptionNode> node2(
0873 std::make_unique<edm::IfExistsDescription>(edm::ParameterDescription<double>("x1", 101.0, true),
0874 (edm::ParameterDescription<double>("x2", 101.0, true) and
0875 edm::ParameterDescription<double>("x3", 101.0, true))));
0876
0877 REQUIRE_THROWS_AS(psetDesc2.addNode(std::move(node2)), edm::Exception);
0878
0879
0880 edm::ParameterSetDescription psetDesc3;
0881 std::unique_ptr<edm::ParameterDescriptionNode> node3(
0882 std::make_unique<edm::IfExistsDescription>(edm::ParameterDescription<double>("x1", 101.0, true),
0883 (edm::ParameterDescription<double>("x2", 101.0, true) and
0884 edm::ParameterDescription<double>("x3", 101.0, true))));
0885 psetDesc3.addNode(std::move(node3));
0886
0887 REQUIRE_THROWS_AS(psetDesc3.add<unsigned>("x1", 1U), edm::Exception);
0888
0889
0890 edm::ParameterSetDescription psetDesc4;
0891 std::unique_ptr<edm::ParameterDescriptionNode> node4(
0892 std::make_unique<edm::IfExistsDescription>(edm::ParameterDescription<double>("x1", 101.0, true),
0893 (edm::ParameterDescription<double>("x2", 101.0, true) and
0894 edm::ParameterDescription<double>("x1", 101.0, true))));
0895 REQUIRE_THROWS_AS(psetDesc4.addNode(std::move(node4)), edm::Exception);
0896
0897
0898
0899 edm::ParameterSetDescription psetDesc5;
0900 std::unique_ptr<edm::ParameterDescriptionNode> node5(std::make_unique<edm::IfExistsDescription>(
0901 edm::ParameterDescription<double>("x1", 101.0, true),
0902 (edm::ParameterDescription<unsigned>("x2", 101U, true) and
0903 edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true))));
0904 REQUIRE_THROWS_AS(psetDesc5.addNode(std::move(node5)), edm::Exception);
0905
0906
0907
0908 edm::ParameterSetDescription psetDesc6;
0909 psetDesc6.add<double>("x0", 1.0);
0910 std::unique_ptr<edm::ParameterDescriptionNode> node6(
0911 std::make_unique<edm::IfExistsDescription>(edm::ParameterWildcard<double>("*", edm::RequireAtLeastOne, true),
0912 (edm::ParameterDescription<unsigned>("x2", 101U, true) and
0913 edm::ParameterDescription<unsigned>("x3", 102U, true))));
0914 REQUIRE_THROWS_AS(psetDesc6.addNode(std::move(node6)), edm::Exception);
0915
0916
0917
0918 edm::ParameterSetDescription psetDesc7;
0919 psetDesc7.addWildcard<double>("*");
0920 std::unique_ptr<edm::ParameterDescriptionNode> node7(
0921 std::make_unique<edm::IfExistsDescription>(edm::ParameterDescription<double>("x1", 11.0, true),
0922 (edm::ParameterDescription<unsigned>("x2", 101U, true) and
0923 edm::ParameterDescription<unsigned>("x3", 102U, true))));
0924 REQUIRE_THROWS_AS(psetDesc7.addNode(std::move(node7)), edm::Exception);
0925 }
0926
0927
0928
0929 SECTION("testAllowedLabels") {
0930 {
0931 std::unique_ptr<edm::ParameterDescriptionNode> node(
0932 std::make_unique<edm::AllowedLabelsDescription<int>>("allowedLabels", true));
0933
0934 const edm::ParameterSet emptyPset;
0935
0936 edm::ParameterSet pset;
0937 std::vector<std::string> labels;
0938 pset.addParameter<std::vector<std::string>>("allowedLabels", labels);
0939
0940 CHECK(node->exists(emptyPset) == false);
0941 CHECK(node->partiallyExists(emptyPset) == false);
0942 CHECK(node->howManyXORSubNodesExist(emptyPset) == 0);
0943
0944 CHECK(node->exists(pset) == true);
0945 CHECK(node->partiallyExists(pset) == true);
0946 CHECK(node->howManyXORSubNodesExist(pset) == 1);
0947 }
0948
0949 {
0950
0951 edm::ParameterSetDescription psetDesc;
0952 psetDesc.add<unsigned>("x1", 1U);
0953 std::unique_ptr<edm::ParameterDescriptionNode> node(
0954 std::make_unique<edm::AllowedLabelsDescription<int>>("x1", true));
0955
0956 REQUIRE_THROWS_AS(psetDesc.addNode(std::move(node)), edm::Exception);
0957 }
0958
0959 {
0960
0961
0962 edm::ParameterSetDescription psetDesc;
0963 psetDesc.addWildcard<std::vector<std::string>>("*");
0964 std::unique_ptr<edm::ParameterDescriptionNode> node(
0965 std::make_unique<edm::AllowedLabelsDescription<int>>("x1", true));
0966 REQUIRE_THROWS_AS(psetDesc.addNode(std::move(node)), edm::Exception);
0967 }
0968 {
0969 edm::ParameterSet pset;
0970 edm::ParameterSet nestedPset;
0971 nestedPset.addParameter<int>("x", 1);
0972 pset.addParameter<edm::ParameterSet>("nestedPset", nestedPset);
0973
0974 {
0975 edm::ParameterSetDescription psetDesc;
0976 psetDesc.labelsFrom<edm::ParameterSetDescription>("allowedLabelsA");
0977
0978
0979 REQUIRE_THROWS_AS(psetDesc.validate(pset), edm::Exception);
0980
0981 std::vector<std::string> labels;
0982 labels.push_back(std::string("nestedPset"));
0983 pset.addParameter<std::vector<std::string>>("allowedLabelsA", labels);
0984
0985
0986 psetDesc.validate(pset);
0987 }
0988
0989
0990
0991
0992 {
0993 edm::ParameterSetDescription psetDesc;
0994 psetDesc.labelsFrom<edm::ParameterSetDescription>("allowedLabelsA", edm::ParameterSetDescription());
0995
0996
0997 REQUIRE_THROWS_AS(psetDesc.validate(pset), edm::Exception);
0998 }
0999
1000
1001 edm::ParameterSetDescription nestedPsetDesc;
1002 nestedPsetDesc.add<int>("x", 1);
1003
1004 {
1005 edm::ParameterSetDescription psetDesc;
1006 psetDesc.labelsFrom<edm::ParameterSetDescription>("allowedLabelsA", nestedPsetDesc);
1007 psetDesc.validate(pset);
1008 }
1009
1010 {
1011 edm::ParameterSetDescription psetDesc;
1012 psetDesc.labelsFrom<edm::ParameterSetDescription>(std::string("allowedLabelsA"));
1013 psetDesc.validate(pset);
1014 }
1015 {
1016 edm::ParameterSetDescription psetDesc;
1017 psetDesc.labelsFrom<edm::ParameterSetDescription>(std::string("allowedLabelsA"),
1018 edm::ParameterSetDescription());
1019 REQUIRE_THROWS_AS(psetDesc.validate(pset), edm::Exception);
1020 }
1021 {
1022 edm::ParameterSetDescription psetDesc;
1023 psetDesc.labelsFrom<edm::ParameterSetDescription>(std::string("allowedLabelsA"), nestedPsetDesc);
1024 psetDesc.validate(pset);
1025 }
1026 }
1027
1028
1029 {
1030 edm::ParameterSet pset;
1031
1032 edm::ParameterSet elementOfVPset;
1033 elementOfVPset.addParameter<int>("y", 1);
1034 std::vector<edm::ParameterSet> vpset;
1035 vpset.push_back(elementOfVPset);
1036 vpset.push_back(elementOfVPset);
1037
1038 pset.addParameter<std::vector<edm::ParameterSet>>("nestedVPSet", vpset);
1039
1040 {
1041 edm::ParameterSetDescription psetDesc;
1042 psetDesc.labelsFrom<std::vector<edm::ParameterSet>>("allowedLabelsC");
1043
1044
1045 REQUIRE_THROWS_AS(psetDesc.validate(pset), edm::Exception);
1046
1047 std::vector<std::string> labels;
1048 labels.push_back(std::string("nestedVPSet"));
1049 pset.addParameter<std::vector<std::string>>("allowedLabelsC", labels);
1050
1051
1052 psetDesc.validate(pset);
1053 }
1054
1055
1056
1057 {
1058 edm::ParameterSetDescription psetDesc;
1059 psetDesc.labelsFrom<std::vector<edm::ParameterSet>>("allowedLabelsC", edm::ParameterSetDescription());
1060
1061
1062 REQUIRE_THROWS_AS(psetDesc.validate(pset), edm::Exception);
1063 }
1064
1065
1066 edm::ParameterSetDescription nestedPSetDesc;
1067 nestedPSetDesc.add<int>("y", 1);
1068
1069 {
1070 edm::ParameterSetDescription psetDesc;
1071 psetDesc.labelsFrom<std::vector<edm::ParameterSet>>("allowedLabelsC", nestedPSetDesc);
1072 psetDesc.validate(pset);
1073 }
1074
1075
1076 {
1077 edm::ParameterSetDescription psetDesc;
1078 psetDesc.labelsFrom<std::vector<edm::ParameterSet>>(std::string("allowedLabelsC"));
1079 psetDesc.validate(pset);
1080 }
1081 {
1082 edm::ParameterSetDescription psetDesc;
1083 psetDesc.labelsFrom<std::vector<edm::ParameterSet>>(std::string("allowedLabelsC"),
1084 edm::ParameterSetDescription());
1085 REQUIRE_THROWS_AS(psetDesc.validate(pset), edm::Exception);
1086 }
1087 {
1088 edm::ParameterSetDescription psetDesc;
1089 psetDesc.labelsFrom<std::vector<edm::ParameterSet>>(std::string("allowedLabelsC"), nestedPSetDesc);
1090 psetDesc.validate(pset);
1091 }
1092 }
1093 }
1094
1095
1096 SECTION("testNoDefault") {
1097 edm::ParameterSetDescription psetDesc;
1098 psetDesc.add<int>("x");
1099 edm::ParameterSet pset;
1100
1101 REQUIRE_THROWS_AS(psetDesc.validate(pset), edm::Exception);
1102
1103 pset.addParameter<int>("x", 1);
1104 psetDesc.validate(pset);
1105
1106 psetDesc.addVPSet("y", edm::ParameterSetDescription());
1107 REQUIRE_THROWS_AS(psetDesc.validate(pset), edm::Exception);
1108 }
1109
1110
1111
1112 SECTION("testWrongTrackiness") {
1113 edm::ParameterSet pset1;
1114 pset1.addParameter<int>("test1", 1);
1115
1116 edm::ParameterSetDescription psetDesc1;
1117 psetDesc1.addUntracked<int>("test1", 1);
1118 REQUIRE_THROWS_AS(psetDesc1.validate(pset1), edm::Exception);
1119
1120 edm::ParameterSet pset2;
1121 pset2.addParameter<edm::ParameterSet>("test2", edm::ParameterSet());
1122
1123 edm::ParameterSetDescription psetDesc2;
1124 psetDesc2.addUntracked<edm::ParameterSetDescription>("test2", edm::ParameterSetDescription());
1125 REQUIRE_THROWS_AS(psetDesc2.validate(pset2), edm::Exception);
1126
1127 edm::ParameterSet pset3;
1128 pset3.addParameter<std::vector<edm::ParameterSet>>("test3", std::vector<edm::ParameterSet>());
1129
1130 edm::ParameterSetDescription psetDesc3;
1131 psetDesc3.addVPSetUntracked("test3", edm::ParameterSetDescription());
1132 REQUIRE_THROWS_AS(psetDesc3.validate(pset3), edm::Exception);
1133 }
1134
1135
1136
1137 SECTION("testWrongType") {
1138 edm::ParameterSet pset1;
1139 pset1.addParameter<unsigned int>("test1", 1);
1140
1141 edm::ParameterSetDescription psetDesc1;
1142 psetDesc1.add<int>("test1", 1);
1143 REQUIRE_THROWS_AS(psetDesc1.validate(pset1), edm::Exception);
1144
1145 edm::ParameterSet pset2;
1146 pset2.addParameter<int>("test2", 1);
1147
1148 edm::ParameterSetDescription psetDesc2;
1149 psetDesc2.add<edm::ParameterSetDescription>("test2", edm::ParameterSetDescription());
1150 REQUIRE_THROWS_AS(psetDesc2.validate(pset2), edm::Exception);
1151
1152 edm::ParameterSet pset3;
1153 pset3.addParameter<int>("test3", 1);
1154
1155 edm::ParameterSetDescription psetDesc3;
1156 psetDesc3.addVPSetUntracked("test3", edm::ParameterSetDescription());
1157 REQUIRE_THROWS_AS(psetDesc3.validate(pset3), edm::Exception);
1158 }
1159
1160
1161
1162 SECTION("testPlugin") {
1163 static std::once_flag flag;
1164 std::call_once(flag, []() { edmplugin::PluginManager::configure(edmplugin::standard::config()); });
1165 {
1166 edm::ParameterSetDescription desc;
1167 desc.addNode(edm::PluginDescription<TestPluginFactory>("type", true));
1168
1169 edm::ParameterSet pset1;
1170 pset1.addParameter<std::string>("type", "ATestPlugin");
1171 pset1.addParameter<int>("anInt", 3);
1172
1173 desc.validate(pset1);
1174 }
1175
1176 {
1177 edm::ParameterSetDescription desc;
1178 desc.addNode(edm::PluginDescription<TestPluginFactory>("type", true));
1179
1180 edm::ParameterSet pset1;
1181 pset1.addParameter<std::string>("type", "BTestPlugin");
1182 pset1.addParameter<double>("aDouble", 0.2);
1183
1184 desc.validate(pset1);
1185 }
1186
1187 {
1188
1189 edm::ParameterSetDescription desc;
1190 desc.addNode(edm::PluginDescription<TestPluginFactory>("type", true));
1191
1192 edm::ParameterSet pset1;
1193 pset1.addParameter<std::string>("type", "ATestPlugin");
1194 desc.validate(pset1);
1195 CHECK(pset1.getParameter<int>("anInt") == 5);
1196 }
1197
1198 {
1199
1200 edm::ParameterSetDescription desc;
1201 desc.addNode(edm::PluginDescription<TestPluginFactory>("type", "ATestPlugin", true));
1202
1203 edm::ParameterSet pset1;
1204 desc.validate(pset1);
1205 CHECK(pset1.getParameter<int>("anInt") == 5);
1206 CHECK(pset1.getParameter<std::string>("type") == "ATestPlugin");
1207 }
1208
1209 {
1210
1211 edm::ParameterSetDescription desc;
1212 desc.addNode(edm::PluginDescription<TestPluginFactory>("type", true));
1213
1214 edm::ParameterSet pset1;
1215 pset1.addParameter<std::string>("type", "ATestPlugin");
1216 pset1.addParameter<int>("anInt", 3);
1217 pset1.addParameter<int>("NotRight", 3);
1218
1219 REQUIRE_THROWS_AS(desc.validate(pset1), edm::Exception);
1220 }
1221
1222 SECTION("wildcard") {
1223
1224 edm::ParameterSetDescription desc;
1225 desc.addNode(edm::PluginDescription<TestPluginFactory>("type", true));
1226 edm::ParameterWildcard<edm::ParameterSetDescription> w("*", edm::RequireExactlyOne, true, desc);
1227
1228 edm::ParameterSetDescription top;
1229 top.addNode(w);
1230
1231 edm::ParameterSet pset1;
1232 pset1.addParameter<std::string>("type", "ATestPlugin");
1233
1234 edm::ParameterSet psetTop;
1235 psetTop.addParameter<edm::ParameterSet>("foo", pset1);
1236
1237 top.validate(psetTop);
1238 }
1239
1240 {
1241
1242 edm::ParameterSetDescription desc;
1243 desc.addNode(edm::PluginDescription<TestPluginFactory>("type", true));
1244
1245 edm::ParameterSet pset1;
1246 pset1.addParameter<int>("anInt", 3);
1247
1248 REQUIRE_THROWS_AS(desc.validate(pset1), edm::Exception);
1249 }
1250
1251 {
1252
1253 edm::ParameterSetDescription desc;
1254 desc.addNode(edm::PluginDescription<TestPluginFactory>("type", true));
1255
1256 edm::ParameterSet pset1;
1257 pset1.addParameter<std::string>("type", "ZTestPlugin");
1258
1259 REQUIRE_THROWS_AS(desc.validate(pset1), cms::Exception);
1260 }
1261 }
1262
1263 SECTION("VPSet with defaults") {
1264 edm::ParameterSetDescription psetDesc;
1265
1266 std::vector<edm::ParameterSet> defaults{1};
1267 {
1268 auto& d = defaults.front();
1269 edm::ParameterSetDescription templte;
1270
1271 templte.add<int>("i");
1272 d.addParameter<int>("i", 1);
1273
1274 templte.add<std::vector<int>>("vi");
1275 d.addParameter<std::vector<int>>("vi", std::vector<int>({1}));
1276
1277 templte.add<unsigned int>("ui");
1278 d.addParameter<unsigned int>("ui", 1);
1279
1280 templte.add<std::vector<unsigned int>>("vui");
1281 d.addParameter<std::vector<unsigned int>>("vui", std::vector<unsigned int>({1}));
1282
1283 templte.add<long long>("l");
1284 d.addParameter<long long>("l", 1);
1285
1286 templte.add<std::vector<long long>>("vl");
1287 d.addParameter<std::vector<long long>>("vl", std::vector<long long>({1}));
1288
1289 templte.add<unsigned long long>("ul");
1290 d.addParameter<unsigned long long>("ul", 1);
1291
1292 templte.add<std::vector<unsigned long long>>("vul");
1293 d.addParameter<std::vector<unsigned long long>>("vul", std::vector<unsigned long long>({1}));
1294
1295 templte.add<bool>("b");
1296 d.addParameter<bool>("b", true);
1297
1298 templte.add<double>("d");
1299 d.addParameter<double>("d", 1.0);
1300
1301 templte.add<std::vector<double>>("vd");
1302 d.addParameter<std::vector<double>>("vd", std::vector<double>({1.0}));
1303
1304 templte.add<std::string>("s");
1305 d.addParameter<std::string>("s", "a");
1306
1307 templte.add<std::vector<std::string>>("vs");
1308 d.addParameter<std::vector<std::string>>("vs", std::vector<std::string>({"a"}));
1309
1310 templte.add<edm::InputTag>("t");
1311 d.addParameter<edm::InputTag>("t", edm::InputTag("foo"));
1312
1313 templte.add<std::vector<edm::InputTag>>("vt");
1314 d.addParameter<std::vector<edm::InputTag>>("vt", std::vector<edm::InputTag>({edm::InputTag("foo")}));
1315
1316 templte.add<edm::ESInputTag>("et");
1317 d.addParameter<edm::ESInputTag>("et", edm::ESInputTag(":foo"));
1318
1319 templte.add<std::vector<edm::ESInputTag>>("vet");
1320 d.addParameter<std::vector<edm::ESInputTag>>("vet", std::vector<edm::ESInputTag>({edm::ESInputTag(":foo")}));
1321
1322 edm::FileInPath::disableFileLookup();
1323 templte.add<edm::FileInPath>("f");
1324 d.addParameter<edm::FileInPath>("f", edm::FileInPath());
1325
1326 templte.add<edm::EventID>("e");
1327 d.addParameter<edm::EventID>("e", edm::EventID(1, 2, 3));
1328
1329 templte.add<std::vector<edm::EventID>>("ve");
1330 d.addParameter<std::vector<edm::EventID>>("ve", std::vector<edm::EventID>({edm::EventID(1, 2, 3)}));
1331
1332 templte.add<edm::LuminosityBlockID>("L");
1333 d.addParameter<edm::LuminosityBlockID>("L", edm::LuminosityBlockID(1, 2));
1334
1335 templte.add<std::vector<edm::LuminosityBlockID>>("vL");
1336 d.addParameter<std::vector<edm::LuminosityBlockID>>(
1337 "vL", std::vector<edm::LuminosityBlockID>({edm::LuminosityBlockID(1, 2)}));
1338
1339 templte.add<edm::EventRange>("er");
1340 d.addParameter<edm::EventRange>("er", edm::EventRange(1, 2, 3, 4, 5, 6));
1341
1342 templte.add<std::vector<edm::EventRange>>("ver");
1343 d.addParameter<std::vector<edm::EventRange>>("ver",
1344 std::vector<edm::EventRange>({edm::EventRange(1, 2, 3, 4, 5, 6)}));
1345
1346 templte.add<edm::LuminosityBlockRange>("Lr");
1347 d.addParameter<edm::LuminosityBlockRange>("Lr", edm::LuminosityBlockRange(1, 2, 3, 4));
1348
1349 templte.add<std::vector<edm::LuminosityBlockRange>>("vLr");
1350 d.addParameter<std::vector<edm::LuminosityBlockRange>>(
1351 "vLr", std::vector<edm::LuminosityBlockRange>({edm::LuminosityBlockRange(1, 2, 3, 4)}));
1352
1353 templte.add<edm::ParameterSetDescription>("p", edm::ParameterSetDescription());
1354 d.addParameter<edm::ParameterSet>("p", edm::ParameterSet());
1355
1356 templte.addVPSet("vp", edm::ParameterSetDescription());
1357 d.addParameter<std::vector<edm::ParameterSet>>("vp", std::vector<edm::ParameterSet>());
1358
1359 psetDesc.addVPSet("vp", templte, defaults);
1360 }
1361 SECTION("writeCfi full") {
1362 edm::ParameterSet test;
1363 test.addParameter("vp", defaults);
1364 psetDesc.validate(test);
1365
1366 std::ostringstream s;
1367 edm::CfiOptions fullOps = edm::cfi::Typed{};
1368 psetDesc.writeCfi(s, false, 0, fullOps);
1369 std::string expected = R"-(
1370 vp = cms.VPSet(
1371 cms.PSet(
1372 L = cms.LuminosityBlockID(1, 2),
1373 Lr = cms.LuminosityBlockRange('1:2-3:4'),
1374 b = cms.bool(True),
1375 d = cms.double(1),
1376 e = cms.EventID(1, 2, 3),
1377 er = cms.EventRange('1:2:3-4:5:6'),
1378 et = cms.ESInputTag('', 'foo'),
1379 f = cms.FileInPath(''),
1380 i = cms.int32(1),
1381 l = cms.int64(1),
1382 s = cms.string('a'),
1383 t = cms.InputTag('foo'),
1384 ui = cms.uint32(1),
1385 ul = cms.uint64(1),
1386 vL = cms.VLuminosityBlockID('1:2'),
1387 vLr = cms.VLuminosityBlockRange('1:2-3:4'),
1388 vd = cms.vdouble(1),
1389 ve = cms.VEventID('1:2:3'),
1390 ver = cms.VEventRange('1:2:3-4:5:6'),
1391 vet = cms.VESInputTag(':foo'),
1392 vi = cms.vint32(1),
1393 vl = cms.vint64(1),
1394 vs = cms.vstring('a'),
1395 vt = cms.VInputTag('foo'),
1396 vui = cms.vuint32(1),
1397 vul = cms.vuint64(1),
1398 p = cms.PSet(),
1399 vp = cms.VPSet(
1400 )
1401 )
1402 )
1403 )-";
1404
1405 CHECK(expected == s.str());
1406 }
1407 SECTION("writeCfi Untyped") {
1408 edm::ParameterSet test;
1409 test.addParameter("vp", defaults);
1410 psetDesc.validate(test);
1411
1412 std::ostringstream s;
1413 edm::CfiOptions fullOps = edm::cfi::Untyped{edm::cfi::Paths{}};
1414 psetDesc.writeCfi(s, false, 0, fullOps);
1415 std::string expected = R"-(
1416 vp = [
1417 cms.PSet(
1418 L = cms.LuminosityBlockID(1, 2),
1419 Lr = cms.LuminosityBlockRange('1:2-3:4'),
1420 b = cms.bool(True),
1421 d = cms.double(1),
1422 e = cms.EventID(1, 2, 3),
1423 er = cms.EventRange('1:2:3-4:5:6'),
1424 et = cms.ESInputTag('', 'foo'),
1425 f = cms.FileInPath(''),
1426 i = cms.int32(1),
1427 l = cms.int64(1),
1428 s = cms.string('a'),
1429 t = cms.InputTag('foo'),
1430 ui = cms.uint32(1),
1431 ul = cms.uint64(1),
1432 vL = cms.VLuminosityBlockID('1:2'),
1433 vLr = cms.VLuminosityBlockRange('1:2-3:4'),
1434 vd = cms.vdouble(1),
1435 ve = cms.VEventID('1:2:3'),
1436 ver = cms.VEventRange('1:2:3-4:5:6'),
1437 vet = cms.VESInputTag(':foo'),
1438 vi = cms.vint32(1),
1439 vl = cms.vint64(1),
1440 vs = cms.vstring('a'),
1441 vt = cms.VInputTag('foo'),
1442 vui = cms.vuint32(1),
1443 vul = cms.vuint64(1),
1444 p = cms.PSet(),
1445 vp = cms.VPSet(
1446 )
1447 )
1448 ]
1449 )-";
1450
1451 CHECK(expected == s.str());
1452 }
1453 }
1454
1455 SECTION("PSet with default") {
1456 edm::ParameterSetDescription psetDesc;
1457
1458 {
1459 edm::ParameterSetDescription templte;
1460
1461 templte.add<int>("i", 1);
1462 templte.add<std::vector<int>>("vi", std::vector<int>({1}));
1463 templte.add<unsigned int>("ui", 1);
1464 templte.add<std::vector<unsigned int>>("vui", std::vector<unsigned int>({1}));
1465 templte.add<long long>("l", 1);
1466 templte.add<std::vector<long long>>("vl", std::vector<long long>({1}));
1467 templte.add<unsigned long long>("ul", 1);
1468 templte.add<std::vector<unsigned long long>>("vul", std::vector<unsigned long long>({1}));
1469 templte.add<bool>("b", true);
1470 templte.add<double>("d", 1.0);
1471 templte.add<std::vector<double>>("vd", std::vector<double>({1.0}));
1472 templte.add<std::string>("s", "a");
1473 templte.add<std::vector<std::string>>("vs", std::vector<std::string>({"a"}));
1474 templte.add<edm::InputTag>("t", edm::InputTag("foo"));
1475 templte.add<std::vector<edm::InputTag>>("vt", std::vector<edm::InputTag>({edm::InputTag("foo")}));
1476 templte.add<edm::ESInputTag>("et", edm::ESInputTag(":foo"));
1477 templte.add<std::vector<edm::ESInputTag>>("vet", std::vector<edm::ESInputTag>({edm::ESInputTag(":foo")}));
1478 edm::FileInPath::disableFileLookup();
1479 templte.add<edm::FileInPath>("f", edm::FileInPath());
1480 templte.add<edm::EventID>("e", edm::EventID(1, 2, 3));
1481 templte.add<std::vector<edm::EventID>>("ve", std::vector<edm::EventID>({edm::EventID(1, 2, 3)}));
1482 templte.add<edm::LuminosityBlockID>("L", edm::LuminosityBlockID(1, 2));
1483 templte.add<std::vector<edm::LuminosityBlockID>>(
1484 "vL", std::vector<edm::LuminosityBlockID>({edm::LuminosityBlockID(1, 2)}));
1485 templte.add<edm::EventRange>("er", edm::EventRange(1, 2, 3, 4, 5, 6));
1486 templte.add<std::vector<edm::EventRange>>("ver",
1487 std::vector<edm::EventRange>({edm::EventRange(1, 2, 3, 4, 5, 6)}));
1488 templte.add<edm::LuminosityBlockRange>("Lr", edm::LuminosityBlockRange(1, 2, 3, 4));
1489 templte.add<std::vector<edm::LuminosityBlockRange>>(
1490 "vLr", std::vector<edm::LuminosityBlockRange>({edm::LuminosityBlockRange(1, 2, 3, 4)}));
1491 templte.add<edm::ParameterSetDescription>("p", edm::ParameterSetDescription());
1492 templte.addVPSet("vp", edm::ParameterSetDescription(), std::vector<edm::ParameterSet>());
1493 psetDesc.add<edm::ParameterSetDescription>("p", templte);
1494 }
1495 SECTION("writeCfi full") {
1496 edm::ParameterSet test;
1497 test.addParameter("p", edm::ParameterSet());
1498 psetDesc.validate(test);
1499
1500 std::ostringstream s;
1501 edm::CfiOptions fullOps = edm::cfi::Typed{};
1502 psetDesc.writeCfi(s, false, 0, fullOps);
1503 std::string expected = R"-(
1504 p = cms.PSet(
1505 i = cms.int32(1),
1506 vi = cms.vint32(1),
1507 ui = cms.uint32(1),
1508 vui = cms.vuint32(1),
1509 l = cms.int64(1),
1510 vl = cms.vint64(1),
1511 ul = cms.uint64(1),
1512 vul = cms.vuint64(1),
1513 b = cms.bool(True),
1514 d = cms.double(1),
1515 vd = cms.vdouble(1),
1516 s = cms.string('a'),
1517 vs = cms.vstring('a'),
1518 t = cms.InputTag('foo'),
1519 vt = cms.VInputTag('foo'),
1520 et = cms.ESInputTag('', 'foo'),
1521 vet = cms.VESInputTag(':foo'),
1522 f = cms.FileInPath(''),
1523 e = cms.EventID(1, 2, 3),
1524 ve = cms.VEventID('1:2:3'),
1525 L = cms.LuminosityBlockID(1, 2),
1526 vL = cms.VLuminosityBlockID('1:2'),
1527 er = cms.EventRange('1:2:3-4:5:6'),
1528 ver = cms.VEventRange('1:2:3-4:5:6'),
1529 Lr = cms.LuminosityBlockRange('1:2-3:4'),
1530 vLr = cms.VLuminosityBlockRange('1:2-3:4'),
1531 p = cms.PSet(),
1532 vp = cms.VPSet(
1533 )
1534 )
1535 )-";
1536
1537 CHECK(expected == s.str());
1538 }
1539 SECTION("writeCfi Untyped") {
1540 std::ostringstream s;
1541 edm::CfiOptions fullOps = edm::cfi::Untyped{edm::cfi::Paths{}};
1542 psetDesc.writeCfi(s, false, 0, fullOps);
1543 std::string expected = R"-(
1544 p = dict(
1545 i = 1,
1546 vi = [1],
1547 ui = 1,
1548 vui = [1],
1549 l = 1,
1550 vl = [1],
1551 ul = 1,
1552 vul = [1],
1553 b = True,
1554 d = 1,
1555 vd = [1],
1556 s = 'a',
1557 vs = ['a'],
1558 t = ('foo'),
1559 vt = ['foo'],
1560 et = ('', 'foo'),
1561 vet = [':foo'],
1562 f = '',
1563 e = (1, 2, 3),
1564 ve = ['1:2:3'],
1565 L = (1, 2),
1566 vL = ['1:2'],
1567 er = ('1:2:3-4:5:6'),
1568 ver = ['1:2:3-4:5:6'],
1569 Lr = ('1:2-3:4'),
1570 vLr = ['1:2-3:4'],
1571 p = dict(),
1572 vp = [
1573 ]
1574 )
1575 )-";
1576
1577 CHECK(expected == s.str());
1578 }
1579 }
1580
1581 SECTION("setAllowAnything") {
1582 edm::ParameterSetDescription psetDesc;
1583 CHECK(!psetDesc.anythingAllowed());
1584 CHECK(!psetDesc.isUnknown());
1585 CHECK(psetDesc.begin() == psetDesc.end());
1586
1587 edm::ParameterSet params;
1588 psetDesc.validate(params);
1589
1590 params.addParameter<std::string>("testname", std::string("testvalue"));
1591
1592
1593 REQUIRE_THROWS_AS(psetDesc.validate(params), edm::Exception);
1594
1595 psetDesc.setAllowAnything();
1596 CHECK(psetDesc.anythingAllowed());
1597
1598 psetDesc.validate(params);
1599
1600 psetDesc.add<int>("testInt", 11);
1601 psetDesc.validate(params);
1602 CHECK(params.exists("testInt"));
1603 }
1604
1605 SECTION("unknown") {
1606 edm::ParameterSetDescription psetDesc;
1607
1608 edm::ParameterSet params;
1609 params.addParameter<std::string>("testname", std::string("testvalue"));
1610 psetDesc.setUnknown();
1611 CHECK(psetDesc.isUnknown());
1612
1613 psetDesc.validate(params);
1614 }
1615
1616 SECTION("FileInPath") {
1617
1618
1619
1620 edm::ParameterSetDescription psetDesc;
1621 edm::ParameterDescriptionBase* par = psetDesc.add<edm::FileInPath>("fileInPath", edm::FileInPath());
1622 CHECK(par->type() == edm::k_FileInPath);
1623 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("FileInPath"));
1624 }
1625
1626 SECTION("main") {
1627 edm::ParameterSetDescription psetDesc;
1628 edm::ParameterSet pset;
1629
1630 psetDesc.reserve(2);
1631
1632 int a = 1;
1633 edm::ParameterDescriptionBase* par = psetDesc.add<int>(std::string("ivalue"), a);
1634 CHECK(par->exists(pset) == false);
1635 CHECK(par->partiallyExists(pset) == false);
1636 CHECK(par->howManyXORSubNodesExist(pset) == 0);
1637 pset.addParameter<int>("ivalue", a);
1638 CHECK(par != 0);
1639 CHECK(par->label() == std::string("ivalue"));
1640 CHECK(par->type() == edm::k_int32);
1641 CHECK(par->isTracked() == true);
1642 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("int32"));
1643 CHECK(par->exists(pset) == true);
1644 CHECK(par->partiallyExists(pset) == true);
1645 CHECK(par->howManyXORSubNodesExist(pset) == 1);
1646
1647 edm::ParameterSet psetWrongTrackiness;
1648 psetWrongTrackiness.addUntrackedParameter("ivalue", a);
1649 REQUIRE_THROWS_AS(psetDesc.validate(psetWrongTrackiness), edm::Exception);
1650
1651 edm::ParameterSet psetWrongType;
1652 psetWrongType.addUntrackedParameter("ivalue", 1U);
1653 REQUIRE_THROWS_AS(psetDesc.validate(psetWrongType), edm::Exception);
1654
1655 edm::ParameterSetDescription::const_iterator parIter = psetDesc.begin();
1656 CHECK(parIter->node().operator->() == par);
1657
1658 unsigned b = 2;
1659 par = psetDesc.add<unsigned>("uvalue", b);
1660 pset.addParameter<unsigned>("uvalue", b);
1661 CHECK(par != 0);
1662 CHECK(par->label() == std::string("uvalue"));
1663 CHECK(par->type() == edm::k_uint32);
1664 CHECK(par->isTracked() == true);
1665 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("uint32"));
1666
1667 parIter = psetDesc.begin();
1668 ++parIter;
1669 CHECK(parIter->node().operator->() == par);
1670
1671 long long c = 3;
1672 par = psetDesc.addUntracked<long long>(std::string("i64value"), c);
1673 pset.addUntrackedParameter<long long>("i64value", c);
1674 CHECK(par != 0);
1675 CHECK(par->label() == std::string("i64value"));
1676 CHECK(par->type() == edm::k_int64);
1677 CHECK(par->isTracked() == false);
1678 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("int64"));
1679
1680 unsigned long long d = 4;
1681 par = psetDesc.addUntracked<unsigned long long>("u64value", d);
1682 pset.addUntrackedParameter<unsigned long long>("u64value", d);
1683 CHECK(par != 0);
1684 CHECK(par->label() == std::string("u64value"));
1685 CHECK(par->type() == edm::k_uint64);
1686 CHECK(par->isTracked() == false);
1687 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("uint64"));
1688
1689 double e = 5;
1690 par = psetDesc.addOptional<double>(std::string("dvalue"), e);
1691 pset.addParameter<double>("dvalue", e);
1692 CHECK(par != 0);
1693 CHECK(par->label() == std::string("dvalue"));
1694 CHECK(par->type() == edm::k_double);
1695 CHECK(par->isTracked() == true);
1696 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("double"));
1697
1698 bool f = true;
1699 par = psetDesc.addOptional<bool>("bvalue", f);
1700 pset.addParameter<bool>("bvalue", f);
1701 CHECK(par != 0);
1702 CHECK(par->label() == std::string("bvalue"));
1703 CHECK(par->type() == edm::k_bool);
1704 CHECK(par->isTracked() == true);
1705 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("bool"));
1706
1707 std::string g;
1708 par = psetDesc.addOptionalUntracked<std::string>(std::string("svalue"), g);
1709 pset.addUntrackedParameter<std::string>("svalue", g);
1710 CHECK(par != 0);
1711 CHECK(par->label() == std::string("svalue"));
1712 CHECK(par->type() == edm::k_stringRaw);
1713 CHECK(par->isTracked() == false);
1714 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("string"));
1715
1716 edm::EventID h;
1717 par = psetDesc.addOptionalUntracked<edm::EventID>("evalue", h);
1718 pset.addUntrackedParameter<edm::EventID>("evalue", h);
1719 CHECK(par != 0);
1720 CHECK(par->label() == std::string("evalue"));
1721 CHECK(par->type() == edm::k_EventID);
1722 CHECK(par->isTracked() == false);
1723 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("EventID"));
1724
1725 edm::LuminosityBlockID i;
1726 par = psetDesc.add<edm::LuminosityBlockID>("lvalue", i);
1727 pset.addParameter<edm::LuminosityBlockID>("lvalue", i);
1728 CHECK(par->type() == edm::k_LuminosityBlockID);
1729 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("LuminosityBlockID"));
1730
1731 edm::InputTag j;
1732 par = psetDesc.add<edm::InputTag>("input", j);
1733 pset.addParameter<edm::InputTag>("input", j);
1734 CHECK(par->type() == edm::k_InputTag);
1735 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("InputTag"));
1736
1737 edm::ESInputTag k;
1738 par = psetDesc.add<edm::ESInputTag>("esinput", k);
1739 pset.addParameter<edm::ESInputTag>("esinput", k);
1740 CHECK(par->type() == edm::k_ESInputTag);
1741 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("ESInputTag"));
1742
1743 std::vector<int> v1;
1744 par = psetDesc.add<std::vector<int>>("v1", v1);
1745 pset.addParameter<std::vector<int>>("v1", v1);
1746 CHECK(par->type() == edm::k_vint32);
1747 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("vint32"));
1748
1749 std::vector<unsigned> v2;
1750 par = psetDesc.add<std::vector<unsigned>>("v2", v2);
1751 pset.addParameter<std::vector<unsigned>>("v2", v2);
1752 CHECK(par->type() == edm::k_vuint32);
1753 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("vuint32"));
1754
1755 std::vector<long long> v3;
1756 par = psetDesc.add<std::vector<long long>>("v3", v3);
1757 pset.addParameter<std::vector<long long>>("v3", v3);
1758 CHECK(par->type() == edm::k_vint64);
1759 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("vint64"));
1760
1761 std::vector<unsigned long long> v4;
1762 par = psetDesc.add<std::vector<unsigned long long>>("v4", v4);
1763 pset.addParameter<std::vector<unsigned long long>>("v4", v4);
1764 CHECK(par->type() == edm::k_vuint64);
1765 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("vuint64"));
1766
1767 std::vector<double> v5;
1768 par = psetDesc.add<std::vector<double>>("v5", v5);
1769 pset.addParameter<std::vector<double>>("v5", v5);
1770 CHECK(par->type() == edm::k_vdouble);
1771 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("vdouble"));
1772
1773 std::vector<std::string> v6;
1774 par = psetDesc.add<std::vector<std::string>>("v6", v6);
1775 pset.addParameter<std::vector<std::string>>("v6", v6);
1776 CHECK(par->type() == edm::k_vstringRaw);
1777 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("vstring"));
1778
1779 std::vector<edm::EventID> v7;
1780 par = psetDesc.add<std::vector<edm::EventID>>("v7", v7);
1781 pset.addParameter<std::vector<edm::EventID>>("v7", v7);
1782 CHECK(par->type() == edm::k_VEventID);
1783 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("VEventID"));
1784
1785 std::vector<edm::LuminosityBlockID> v8;
1786 par = psetDesc.add<std::vector<edm::LuminosityBlockID>>("v8", v8);
1787 pset.addParameter<std::vector<edm::LuminosityBlockID>>("v8", v8);
1788 CHECK(par->type() == edm::k_VLuminosityBlockID);
1789 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("VLuminosityBlockID"));
1790
1791 std::vector<edm::InputTag> v9;
1792 par = psetDesc.add<std::vector<edm::InputTag>>("v9", v9);
1793 pset.addParameter<std::vector<edm::InputTag>>("v9", v9);
1794 CHECK(par->type() == edm::k_VInputTag);
1795 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("VInputTag"));
1796
1797 std::vector<edm::ESInputTag> v11;
1798 par = psetDesc.add<std::vector<edm::ESInputTag>>("v11", v11);
1799 pset.addParameter<std::vector<edm::ESInputTag>>("v11", v11);
1800 CHECK(par->type() == edm::k_VESInputTag);
1801 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("VESInputTag"));
1802
1803 edm::ParameterSetDescription m;
1804 par = psetDesc.add<edm::ParameterSetDescription>("psetDesc", m);
1805 CHECK(par->exists(pset) == false);
1806 CHECK(par->partiallyExists(pset) == false);
1807 CHECK(par->howManyXORSubNodesExist(pset) == 0);
1808 edm::ParameterSet p1;
1809 pset.addParameter<edm::ParameterSet>("psetDesc", p1);
1810 CHECK(par->type() == edm::k_PSet);
1811 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("PSet"));
1812 CHECK(par->exists(pset) == true);
1813 CHECK(par->partiallyExists(pset) == true);
1814 CHECK(par->howManyXORSubNodesExist(pset) == 1);
1815
1816 edm::ParameterSetDescription v10;
1817 par = psetDesc.addVPSet("psetVectorDesc", v10);
1818 CHECK(par->exists(pset) == false);
1819 CHECK(par->partiallyExists(pset) == false);
1820 CHECK(par->howManyXORSubNodesExist(pset) == 0);
1821 std::vector<edm::ParameterSet> vp1;
1822 pset.addParameter<std::vector<edm::ParameterSet>>("psetVectorDesc", vp1);
1823 CHECK(par->type() == edm::k_VPSet);
1824 CHECK(edm::parameterTypeEnumToString(par->type()) == std::string("VPSet"));
1825 CHECK(par->exists(pset) == true);
1826 CHECK(par->partiallyExists(pset) == true);
1827 CHECK(par->howManyXORSubNodesExist(pset) == 1);
1828
1829 psetDesc.validate(pset);
1830
1831
1832
1833
1834
1835 edm::ParameterSet nest2;
1836 nest2.addParameter<int>("intLevel2a", 1);
1837 nest2.addUntrackedParameter<int>("intLevel2b", 1);
1838 nest2.addParameter<int>("intLevel2e", 1);
1839 nest2.addUntrackedParameter<int>("intLevel2f", 1);
1840
1841 edm::ParameterSet nest1;
1842 nest1.addParameter<int>("intLevel1a", 1);
1843 nest1.addParameter<edm::ParameterSet>("nestLevel1b", nest2);
1844
1845 std::vector<edm::ParameterSet> vPset;
1846 vPset.push_back(edm::ParameterSet());
1847 vPset.push_back(nest1);
1848
1849 pset.addUntrackedParameter<std::vector<edm::ParameterSet>>("nestLevel0", vPset);
1850
1851 std::vector<edm::ParameterSetDescription> testDescriptions;
1852 testDescriptions.push_back(psetDesc);
1853 testDescriptions.push_back(psetDesc);
1854 testDescriptions.push_back(psetDesc);
1855
1856 for (int ii = 0; ii < 3; ++ii) {
1857 edm::ParameterSetDescription nestLevel2;
1858
1859
1860
1861
1862 if (ii > 0)
1863 nestLevel2.add<int>("intLevel2a", 1);
1864
1865
1866
1867
1868
1869 if (ii == 2)
1870 nestLevel2.add<int>("intLevel2extra", 11);
1871
1872 nestLevel2.addUntracked<int>("intLevel2b", 1);
1873 nestLevel2.addOptional<int>("intLevel2c", 1);
1874 nestLevel2.addOptionalUntracked<int>("intLevel2d", 1);
1875 nestLevel2.addOptional<int>("intLevel2e", 1);
1876 nestLevel2.addOptionalUntracked<int>("intLevel2f", 1);
1877
1878 edm::ParameterSetDescription nestLevel1;
1879 nestLevel1.add<int>("intLevel1a", 1);
1880 nestLevel1.add<edm::ParameterSetDescription>("nestLevel1b", nestLevel2);
1881
1882 testDescriptions[ii].addVPSetUntracked("nestLevel0", nestLevel1);
1883 }
1884
1885
1886 REQUIRE_THROWS_AS(testDescriptions[0].validate(pset), edm::Exception);
1887
1888
1889 testDescriptions[1].validate(pset);
1890
1891
1892
1893 testDescriptions[2].validate(pset);
1894
1895 std::vector<edm::ParameterSet> const& vpset = pset.getUntrackedParameterSetVector("nestLevel0");
1896 edm::ParameterSet const& psetInPset = vpset[1].getParameterSet("nestLevel1b");
1897 CHECK(psetInPset.getParameter<int>("intLevel2extra") == 11);
1898
1899
1900
1901 edm::ParameterSetDescription nestLevel2;
1902 par = nestLevel2.add<int>("intLevel2a", 1);
1903 par->setComment("testComment");
1904 CHECK(par->parameterSetDescription() == 0);
1905 edm::ParameterDescriptionBase const& constParRef = *par;
1906 CHECK(constParRef.parameterSetDescription() == 0);
1907
1908 nestLevel2.addUntracked<int>("intLevel2b", 1);
1909 nestLevel2.addOptional<int>("intLevel2c", 1);
1910 nestLevel2.addOptionalUntracked<int>("intLevel2d", 1);
1911 nestLevel2.addOptional<int>("intLevel2e", 1);
1912 nestLevel2.addOptionalUntracked<int>("intLevel2f", 1);
1913 nestLevel2.setAllowAnything();
1914
1915 edm::ParameterSetDescription nestLevel1;
1916 par = nestLevel1.add<int>("intLevel1a", 1);
1917 par->setComment("testComment1");
1918 par = nestLevel1.add<edm::ParameterSetDescription>("nestLevel1b", nestLevel2);
1919 CHECK(par->parameterSetDescription() != 0);
1920 CHECK(par->parameterSetDescription()->begin()->node()->comment() == std::string("testComment"));
1921 edm::ParameterDescriptionBase const& constParRef2 = *par;
1922 CHECK(constParRef2.parameterSetDescription() != 0);
1923 CHECK(constParRef2.parameterSetDescription()->begin()->node()->comment() == std::string("testComment"));
1924
1925 CHECK(par->parameterSetDescription()->anythingAllowed() == true);
1926 CHECK(constParRef2.parameterSetDescription()->anythingAllowed() == true);
1927
1928 par = psetDesc.addVPSetUntracked("nestLevel0", nestLevel1);
1929 CHECK(par->parameterSetDescription() != 0);
1930 CHECK(par->parameterSetDescription()->begin()->node()->comment() == std::string("testComment1"));
1931 edm::ParameterDescriptionBase const& constParRef3 = *par;
1932 CHECK(constParRef3.parameterSetDescription() != 0);
1933 CHECK(constParRef3.parameterSetDescription()->begin()->node()->comment() == std::string("testComment1"));
1934
1935 psetDesc.validate(pset);
1936 }
1937 }
1938
1939 EDM_REGISTER_VALIDATED_PLUGINFACTORY(TestPluginFactory, "TestPluginFWCoreParameterSet");
1940
1941 DEFINE_EDM_VALIDATED_PLUGIN(TestPluginFactory, testParameterSetDescription::ATestPlugin, "ATestPlugin");
1942 DEFINE_EDM_VALIDATED_PLUGIN(TestPluginFactory, testParameterSetDescription::BTestPlugin, "BTestPlugin");