File indexing completed on 2024-04-06 12:12:22
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010 #include <unordered_map>
0011 #include <unordered_set>
0012 #include <algorithm>
0013 #include <cassert>
0014
0015 #include "FWCore/Framework/interface/PathsAndConsumesOfModules.h"
0016 #include "FWCore/Utilities/interface/Exception.h"
0017 #include "DataFormats/Provenance/interface/ParameterSetID.h"
0018 #include "DataFormats/Provenance/interface/ModuleDescription.h"
0019 #include "DataFormats/Provenance/interface/ProcessConfiguration.h"
0020 #include "cppunit/extensions/HelperMacros.h"
0021
0022 using ModuleDependsOnMap = std::map<std::string, std::vector<std::string>>;
0023 using PathToModules = std::unordered_map<std::string, std::vector<std::string>>;
0024
0025 namespace {
0026 class PathsAndConsumesOfModulesForTest : public edm::PathsAndConsumesOfModulesBase {
0027 public:
0028 PathsAndConsumesOfModulesForTest(ModuleDependsOnMap const&, PathToModules const&);
0029
0030 private:
0031 std::vector<std::string> const& doPaths() const final { return m_paths; }
0032 std::vector<std::string> const& doEndPaths() const final { return m_endPaths; }
0033 std::vector<edm::ModuleDescription const*> const& doAllModules() const final { return m_modules; }
0034 edm::ModuleDescription const* doModuleDescription(unsigned int moduleID) const final { return m_modules[moduleID]; }
0035 std::vector<edm::ModuleDescription const*> const& doModulesOnPath(unsigned int pathIndex) const final {
0036 return m_modulesOnPath[pathIndex];
0037 }
0038 std::vector<edm::ModuleDescription const*> const& doModulesOnEndPath(unsigned int endPathIndex) const final {
0039 return m_modulesOnEndPath[endPathIndex];
0040 }
0041 std::vector<edm::ModuleDescription const*> const& doModulesWhoseProductsAreConsumedBy(
0042 unsigned int moduleID, edm::BranchType branchType) const final {
0043 return m_modulesWhoseProductsAreConsumedBy[moduleID];
0044 }
0045 std::vector<edm::ConsumesInfo> doConsumesInfo(unsigned int moduleID) const final {
0046 return m_moduleConsumesInfo[moduleID];
0047 }
0048 unsigned int doLargestModuleID() const final {
0049 if (m_modules.empty()) {
0050 return 0;
0051 }
0052 return m_modules.size() - 1;
0053 }
0054
0055 std::vector<std::string> m_paths;
0056 std::vector<std::string> m_endPaths;
0057 std::vector<edm::ModuleDescription const*> m_modules;
0058 std::vector<std::vector<edm::ConsumesInfo>> m_moduleConsumesInfo;
0059 std::vector<std::vector<edm::ModuleDescription const*>> m_modulesOnPath;
0060 std::vector<std::vector<edm::ModuleDescription const*>> m_modulesOnEndPath;
0061 std::vector<std::vector<edm::ModuleDescription const*>> m_modulesWhoseProductsAreConsumedBy;
0062 std::vector<edm::ModuleDescription> m_cache;
0063
0064 static unsigned int indexForModule(std::string const& iName,
0065 std::unordered_map<std::string, unsigned int>& modsToIndex,
0066 std::unordered_map<unsigned int, std::string>& indexToMods) {
0067 auto found = modsToIndex.find(iName);
0068 unsigned int fromIndex;
0069 if (found == modsToIndex.end()) {
0070 fromIndex = modsToIndex.size();
0071 modsToIndex.emplace(iName, fromIndex);
0072 indexToMods.emplace(fromIndex, iName);
0073 } else {
0074 fromIndex = found->second;
0075 }
0076 return fromIndex;
0077 }
0078 };
0079 PathsAndConsumesOfModulesForTest::PathsAndConsumesOfModulesForTest(ModuleDependsOnMap const& iModDeps,
0080 PathToModules const& iPaths) {
0081
0082 std::unordered_map<std::string, unsigned int> modsToIndex;
0083 std::unordered_map<unsigned int, std::string> indexToMods;
0084
0085 const edm::ProcessConfiguration pc("TEST", edm::ParameterSetID{}, "CMSSW_x_y_z", "??");
0086
0087
0088 m_cache.emplace_back(
0089 edm::ParameterSetID{}, "source", "source", &pc, indexForModule("source", modsToIndex, indexToMods));
0090
0091 for (auto const& md : iModDeps) {
0092 auto const lastSize = modsToIndex.size();
0093 auto index = indexForModule(md.first, modsToIndex, indexToMods);
0094 if (index == lastSize) {
0095 m_cache.emplace_back(edm::ParameterSetID{}, md.first, md.first, &pc, index);
0096 }
0097 }
0098 m_paths.reserve(iPaths.size());
0099 for (auto const& pToM : iPaths) {
0100 m_paths.push_back(pToM.first);
0101
0102 for (auto const& mod : pToM.second) {
0103 auto const lastSize = modsToIndex.size();
0104 unsigned int index = indexForModule(mod, modsToIndex, indexToMods);
0105 if (index == lastSize) {
0106 m_cache.emplace_back(edm::ParameterSetID{}, mod, mod, &pc, index);
0107 }
0108 }
0109 }
0110 for (auto const& md : iModDeps) {
0111 for (auto const& dep : md.second) {
0112 auto const lastSize = modsToIndex.size();
0113 auto index = indexForModule(dep, modsToIndex, indexToMods);
0114 if (index == lastSize) {
0115 m_cache.emplace_back(edm::ParameterSetID{}, dep, dep, &pc, index);
0116 }
0117 }
0118 }
0119
0120 if (not iPaths.empty()) {
0121 auto indexForTriggerResults = indexForModule("TriggerResults", modsToIndex, indexToMods);
0122 for (auto const& pToM : iPaths) {
0123 auto index = indexForModule(pToM.first, modsToIndex, indexToMods);
0124 m_cache.emplace_back(edm::ParameterSetID{}, "PathStatusInserter", pToM.first, &pc, index);
0125 }
0126 m_cache.emplace_back(
0127 edm::ParameterSetID{}, "TriggerResultInserter", "TriggerResults", &pc, indexForTriggerResults);
0128 }
0129
0130 m_modules.reserve(m_cache.size());
0131 for (auto const& desc : m_cache) {
0132 m_modules.push_back(&desc);
0133 }
0134
0135
0136 edm::TypeID dummy;
0137 m_moduleConsumesInfo.resize(m_modules.size());
0138 m_modulesWhoseProductsAreConsumedBy.resize(m_modules.size());
0139 for (auto const& md : iModDeps) {
0140 auto moduleID = modsToIndex[md.first];
0141 auto& consumes = m_moduleConsumesInfo[moduleID];
0142 consumes.reserve(md.second.size());
0143 for (auto const& dep : md.second) {
0144 consumes.emplace_back(dummy, dep.c_str(), "", "TEST", edm::InEvent, edm::PRODUCT_TYPE, true, false);
0145 m_modulesWhoseProductsAreConsumedBy[moduleID].push_back(m_modules[modsToIndex[dep]]);
0146
0147 }
0148 }
0149
0150 m_modulesOnPath.reserve(m_paths.size());
0151 for (auto const& pToM : iPaths) {
0152 m_modulesOnPath.emplace_back();
0153 auto& newPath = m_modulesOnPath.back();
0154 newPath.reserve(pToM.second.size());
0155 for (auto const& mod : pToM.second) {
0156 newPath.push_back(m_modules[modsToIndex[mod]]);
0157 }
0158 }
0159 }
0160 }
0161
0162 class test_checkForModuleDependencyCorrectness : public CppUnit::TestFixture {
0163 CPPUNIT_TEST_SUITE(test_checkForModuleDependencyCorrectness);
0164
0165 CPPUNIT_TEST(onePathNoCycleTest);
0166 CPPUNIT_TEST(onePathHasCycleTest);
0167 CPPUNIT_TEST(twoPathsNoCycleTest);
0168 CPPUNIT_TEST(twoPathsWithCycleTest);
0169 CPPUNIT_TEST(duplicateModuleOnPathTest);
0170 CPPUNIT_TEST(selfCycleTest);
0171
0172 CPPUNIT_TEST_SUITE_END();
0173
0174 public:
0175 void setUp() {}
0176 void tearDown() {}
0177
0178 void onePathNoCycleTest();
0179 void onePathHasCycleTest();
0180
0181 void twoPathsNoCycleTest();
0182 void twoPathsWithCycleTest();
0183
0184 void selfCycleTest();
0185
0186 void duplicateModuleOnPathTest();
0187
0188 private:
0189 bool testCase(ModuleDependsOnMap const& iModDeps, PathToModules const& iPaths) const {
0190 PathsAndConsumesOfModulesForTest pAndC(iModDeps, iPaths);
0191
0192 checkForModuleDependencyCorrectness(pAndC, false);
0193 return true;
0194 }
0195 };
0196
0197
0198 CPPUNIT_TEST_SUITE_REGISTRATION(test_checkForModuleDependencyCorrectness);
0199
0200 void test_checkForModuleDependencyCorrectness::onePathNoCycleTest() {
0201 {
0202 ModuleDependsOnMap md = {{"C", {"B"}}, {"B", {"A"}}};
0203 PathToModules paths = {{"p", {"A", "B", "C"}}};
0204
0205 CPPUNIT_ASSERT(testCase(md, paths));
0206 }
0207
0208 {
0209 ModuleDependsOnMap md = {};
0210 PathToModules paths = {{"p", {"A", "B", "C"}}};
0211
0212 CPPUNIT_ASSERT(testCase(md, paths));
0213 }
0214
0215 {
0216
0217
0218
0219
0220 ModuleDependsOnMap md = {{"E", {"F"}}, {"F", {"G"}}, {"G", {"E"}}, {"A", {}}};
0221 PathToModules paths = {{"p", {"A", "B", "C"}}};
0222
0223 CPPUNIT_ASSERT(testCase(md, paths));
0224 }
0225 }
0226
0227 void test_checkForModuleDependencyCorrectness::onePathHasCycleTest() {
0228 {
0229 ModuleDependsOnMap md = {{"C", {"B"}}, {"B", {"A"}}};
0230 {
0231 PathToModules paths = {{"p", {"B", "A", "C"}}};
0232
0233 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0234 }
0235 {
0236 PathToModules paths = {{"p", {"B", "A"}}};
0237
0238 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0239 }
0240 {
0241 PathToModules paths = {{"p", {"C", "A"}}};
0242
0243 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0244 }
0245 {
0246 PathToModules paths = {{"p", {"C", "B"}}};
0247
0248 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0249 }
0250 }
0251
0252 {
0253 ModuleDependsOnMap md = {{"C", {"B"}}};
0254 {
0255 PathToModules paths = {{"p", {"C", "A", "B"}}};
0256
0257 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0258 }
0259 {
0260 PathToModules paths = {{"p", {"A", "C", "B"}}};
0261
0262 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0263 }
0264 {
0265 PathToModules paths = {{"p", {"C", "B", "A"}}};
0266
0267 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0268 }
0269 }
0270 {
0271 ModuleDependsOnMap md = {{"A", {"p"}}};
0272 {
0273 PathToModules paths = {{"p", {"A"}}};
0274
0275 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0276 }
0277 }
0278 }
0279
0280 void test_checkForModuleDependencyCorrectness::twoPathsNoCycleTest() {
0281 {
0282 ModuleDependsOnMap md = {{"C", {"B"}}};
0283
0284 {
0285 PathToModules paths = {{"p1", {"A", "B", "C"}}, {"p2", {"A", "B", "C"}}};
0286
0287 CPPUNIT_ASSERT(testCase(md, paths));
0288 }
0289
0290 {
0291
0292 PathToModules paths = {{"p1", {"A", "B", "C"}}, {"p2", {"B", "A", "C"}}};
0293
0294 CPPUNIT_ASSERT(testCase(md, paths));
0295 }
0296 {
0297 PathToModules paths = {{"p1", {"A", "B", "C"}}, {"p2", {"B", "C", "A"}}};
0298
0299 CPPUNIT_ASSERT(testCase(md, paths));
0300 }
0301 {
0302 PathToModules paths = {{"p1", {"B", "A", "C"}}, {"p2", {"A", "B", "C"}}};
0303
0304 CPPUNIT_ASSERT(testCase(md, paths));
0305 }
0306 {
0307 PathToModules paths = {{"p1", {"B", "A", "C"}}, {"p2", {"B", "A", "C"}}};
0308
0309 CPPUNIT_ASSERT(testCase(md, paths));
0310 }
0311 {
0312 PathToModules paths = {{"p1", {"B", "A", "C"}}, {"p2", {"B", "C", "A"}}};
0313
0314 CPPUNIT_ASSERT(testCase(md, paths));
0315 }
0316 {
0317 PathToModules paths = {{"p1", {"B", "C", "A"}}, {"p2", {"A", "B", "C"}}};
0318
0319 CPPUNIT_ASSERT(testCase(md, paths));
0320 }
0321 {
0322 PathToModules paths = {{"p1", {"B", "C", "A"}}, {"p2", {"B", "A", "C"}}};
0323
0324 CPPUNIT_ASSERT(testCase(md, paths));
0325 }
0326 {
0327 PathToModules paths = {{"p1", {"B", "C", "A"}}, {"p2", {"B", "C", "A"}}};
0328
0329 CPPUNIT_ASSERT(testCase(md, paths));
0330 }
0331 }
0332
0333 {
0334
0335 ModuleDependsOnMap md = {};
0336 std::vector<std::string> moduleName = {"A", "B", "C"};
0337 std::vector<std::string> pathModules;
0338 for (unsigned int i = 0; i < 3; ++i) {
0339 pathModules.push_back(moduleName[i]);
0340 for (unsigned int j = 0; j < 3; ++j) {
0341 if (j == i) {
0342 continue;
0343 }
0344 pathModules.push_back(moduleName[j]);
0345 for (unsigned int k = 0; k < 3; ++k) {
0346 if (j == k or i == k) {
0347 continue;
0348 }
0349 pathModules.push_back(moduleName[k]);
0350
0351 std::vector<std::string> path2Modules;
0352 for (unsigned int ii = 0; ii < 3; ++ii) {
0353 path2Modules.push_back(moduleName[ii]);
0354 for (unsigned int jj = 0; jj < 3; ++jj) {
0355 if (jj == ii) {
0356 continue;
0357 }
0358 path2Modules.push_back(moduleName[jj]);
0359 for (unsigned int kk = 0; kk < 3; ++kk) {
0360 if (jj == kk or ii == kk) {
0361 continue;
0362 }
0363 path2Modules.push_back(moduleName[kk]);
0364 PathToModules paths;
0365 paths["p1"] = pathModules;
0366 paths["p2"] = path2Modules;
0367 CPPUNIT_ASSERT(testCase(md, paths));
0368 path2Modules.pop_back();
0369 }
0370 path2Modules.pop_back();
0371 }
0372 path2Modules.pop_back();
0373 }
0374
0375 pathModules.pop_back();
0376 }
0377 pathModules.pop_back();
0378 }
0379 pathModules.pop_back();
0380 }
0381 }
0382
0383 {
0384 ModuleDependsOnMap md = {{"C", {"B"}}, {"B", {"A"}}, {"D", {"C"}}};
0385
0386 {
0387 PathToModules paths = {{"p1", {"A", "C"}}, {"p2", {"B", "D"}}};
0388
0389 CPPUNIT_ASSERT(testCase(md, paths));
0390 }
0391
0392 {
0393 PathToModules paths = {{"p1", {"A", "D"}}, {"p2", {"B", "C"}}};
0394
0395 CPPUNIT_ASSERT(testCase(md, paths));
0396 }
0397 {
0398 PathToModules paths = {{"p1", {"A", "B"}}, {"p2", {"C", "D"}}};
0399
0400 CPPUNIT_ASSERT(testCase(md, paths));
0401 }
0402
0403 {
0404 PathToModules paths = {{"p1", {"A"}}, {"p2", {"C", "D"}}};
0405
0406 CPPUNIT_ASSERT(testCase(md, paths));
0407 }
0408 {
0409 PathToModules paths = {{"p1", {"A"}}, {"p2", {"D"}}};
0410
0411 CPPUNIT_ASSERT(testCase(md, paths));
0412 }
0413 {
0414 PathToModules paths = {{"p1", {"A"}}, {"p2", {"C"}}};
0415
0416 CPPUNIT_ASSERT(testCase(md, paths));
0417 }
0418
0419 {
0420 PathToModules paths = {{"p1", {"B"}}, {"p2", {"D"}}};
0421
0422 CPPUNIT_ASSERT(testCase(md, paths));
0423 }
0424
0425 {
0426 PathToModules paths = {{"p1", {"B"}}, {"p2", {"C"}}};
0427
0428 CPPUNIT_ASSERT(testCase(md, paths));
0429 }
0430 {
0431 PathToModules paths = {{"p1", {"C"}}, {"p2", {"D"}}};
0432
0433 CPPUNIT_ASSERT(testCase(md, paths));
0434 }
0435
0436 {
0437 PathToModules paths = {{"p1", {"A", "C"}}, {"p2", {"A", "D"}}};
0438
0439 CPPUNIT_ASSERT(testCase(md, paths));
0440 }
0441 {
0442 PathToModules paths = {{"p1", {"A", "C"}}, {"p2", {"A", "D"}}};
0443
0444 CPPUNIT_ASSERT(testCase(md, paths));
0445 }
0446 }
0447
0448 {
0449 ModuleDependsOnMap md = {{"B", {"C"}}, {"D", {"A"}}};
0450 PathToModules paths = {{"p1", {"A", "B"}}, {"p2", {"C", "D"}}};
0451
0452 CPPUNIT_ASSERT(testCase(md, paths));
0453 }
0454
0455 {
0456 ModuleDependsOnMap md = {{"B", {"E"}}, {"E", {"C"}}, {"D", {"F"}}, {"F", {"A"}}};
0457 PathToModules paths = {{"p1", {"A", "B"}}, {"p2", {"C", "D"}}};
0458
0459 CPPUNIT_ASSERT(testCase(md, paths));
0460 }
0461
0462 {
0463 ModuleDependsOnMap md = {{"B", {"E"}}, {"E", {"C"}}, {"D", {"E"}}, {"E", {"A"}}};
0464 PathToModules paths = {{"p1", {"A", "B"}}, {"p2", {"C", "D"}}};
0465
0466 CPPUNIT_ASSERT(testCase(md, paths));
0467 }
0468
0469 {
0470 ModuleDependsOnMap md = {{"B", {"E"}}, {"C", {"E"}}, {"D", {"E"}}, {"A", {"E"}}};
0471 PathToModules paths = {{"p1", {"A", "B"}}, {"p2", {"C", "D"}}};
0472
0473 CPPUNIT_ASSERT(testCase(md, paths));
0474 }
0475
0476 {
0477
0478 ModuleDependsOnMap md = {{"H", {"A"}}};
0479 PathToModules paths = {{"reco", {"I", "A", "H", "G", "F", "E"}}, {"val", {"E", "D", "C", "B", "A"}}};
0480
0481 CPPUNIT_ASSERT(testCase(md, paths));
0482 }
0483
0484 {
0485
0486 ModuleDependsOnMap md = {{"B", {"X"}}, {"Y", {"Z"}}, {"Z", {"A"}}};
0487 PathToModules paths = {{"p1", {"X", "B", "A"}}, {"p2", {"A", "Z", "?", "Y", "X"}}};
0488
0489 CPPUNIT_ASSERT(testCase(md, paths));
0490 }
0491 {
0492
0493 ModuleDependsOnMap md = {{"B", {"X"}}, {"Y", {"Z"}}, {"Z", {"A"}}, {"?", {}}, {"A", {}}, {"X", {}}};
0494 PathToModules paths = {{"p1", {"X", "B", "A"}}, {"p2", {"A", "Z", "?", "Y", "X"}}};
0495 CPPUNIT_ASSERT(testCase(md, paths));
0496 }
0497
0498 {
0499
0500
0501
0502 ModuleDependsOnMap md = {{"A_TR", {"zEP1", "zEP2"}}, {"D", {"B"}}, {"E", {"D"}}, {"zSEP3", {"A_TR"}}};
0503 PathToModules paths = {{"p1", {"E", "F", "zEP1"}}, {"p2", {"B", "C", "D", "zEP2"}}, {"p3", {"zSEP3", "B", "zEP3"}}};
0504
0505 CPPUNIT_ASSERT(testCase(md, paths));
0506 }
0507
0508 {
0509
0510
0511
0512
0513
0514 ModuleDependsOnMap md = {{"A_TR", {"zEP1"}},
0515 {"A", {"B"}},
0516 {"B", {"H"}},
0517 {"C", {}},
0518 {"D", {}},
0519 {"E", {}},
0520 {"G", {"D"}},
0521 {"H", {"D"}},
0522 {"zEP1", {}},
0523 {"zSEP2", {"A_TR"}}};
0524 PathToModules paths = {{"p2", {"D", "G", "H", "B", "C", "zEP1"}},
0525 {"p3", {"A"}},
0526 {"p1", {"zSEP2", "E", "D", "G", "H", "B", "C"}}};
0527
0528 CPPUNIT_ASSERT(testCase(md, paths));
0529 }
0530
0531 {
0532
0533 ModuleDependsOnMap md = {{"out", {"A", "B"}}, {"A", {"D"}}, {"B", {"D"}}};
0534 PathToModules paths = {{"p1", {"filter", "D"}}, {"p2", {"out"}}};
0535 CPPUNIT_ASSERT(testCase(md, paths));
0536 }
0537 {
0538
0539 ModuleDependsOnMap md = {{"out", {"A", "B"}}, {"A", {"D"}}, {"B", {"D"}}};
0540 PathToModules paths = {{"p1", {"out"}}, {"p2", {"filter", "D"}}};
0541 CPPUNIT_ASSERT(testCase(md, paths));
0542 }
0543
0544 {
0545
0546 ModuleDependsOnMap md = {{"out", {"A", "B"}}, {"A", {"D"}}, {"B", {"D"}}, {"D", {"E"}}};
0547 PathToModules paths = {{"p1", {"filter", "E"}}, {"p2", {"out"}}};
0548 CPPUNIT_ASSERT(testCase(md, paths));
0549 }
0550 {
0551
0552 ModuleDependsOnMap md = {{"out", {"A", "B"}}, {"A", {"D"}}, {"B", {"D"}}, {"D", {"E"}}};
0553 PathToModules paths = {{"p1", {"out"}}, {"p2", {"filter", "E"}}};
0554 CPPUNIT_ASSERT(testCase(md, paths));
0555 }
0556 }
0557
0558 void test_checkForModuleDependencyCorrectness::twoPathsWithCycleTest() {
0559 {
0560 ModuleDependsOnMap md = {{"C", {"B"}}, {"A", {"D"}}};
0561 PathToModules paths = {{"p1", {"A", "B"}}, {"p2", {"C", "D"}}};
0562
0563 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0564 }
0565
0566 {
0567
0568 ModuleDependsOnMap md = {{"C", {"E", "F", "G", "B"}}, {"A", {"D"}}};
0569 PathToModules paths = {{"p1", {"A", "B"}}, {"p2", {"C", "D"}}};
0570
0571 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0572 }
0573
0574 {
0575 ModuleDependsOnMap md = {{"C", {"B"}}, {"A", {"D"}}};
0576 PathToModules paths = {{"p1", {"A", "B"}}, {"p2", {"C", "D", "A"}}};
0577
0578 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0579 }
0580
0581 {
0582 ModuleDependsOnMap md = {{"C", {"B"}}, {"A", {"D"}}, {"B", {"A"}}, {"D", {"C"}}};
0583 PathToModules paths = {{"p1", {"A", "B"}}, {"p2", {"C", "D"}}};
0584
0585 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0586 }
0587
0588 {
0589 ModuleDependsOnMap md = {{"E", {"B"}}, {"C", {"E"}}, {"A", {"D"}}};
0590 PathToModules paths = {{"p1", {"A", "B"}}, {"p2", {"C", "D"}}};
0591
0592 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0593 }
0594
0595 {
0596 ModuleDependsOnMap md = {{"A", {"B"}}, {"B", {"C"}}, {"C", {"D"}}, {"D", {"B"}}};
0597 PathToModules paths = {{"p1", {"A", "EP"}}};
0598
0599 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0600 }
0601
0602 {
0603
0604 ModuleDependsOnMap md = {{"B", {"X"}}, {"Y", {"Z"}}, {"Z", {"A"}}, {"?", {}}, {"A", {}}, {"X", {}}};
0605
0606 PathToModules paths = {{"p1", {"B", "A", "X"}}, {"p2", {"A", "Z", "?", "Y", "X"}}};
0607 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0608 }
0609
0610 {
0611 ModuleDependsOnMap md = {{"A_TR", {"EP1", "EP2"}},
0612 {"C", {"A"}},
0613 {"D", {"A"}},
0614 {"E", {"D"}},
0615 {"BP", {"A_TR"}}};
0616
0617 PathToModules paths = {{"p1", {"A", "B", "C", "EP1"}}, {"p2", {"E", "EP2"}}, {"ep", {"BP", "A", "D"}}};
0618 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0619 }
0620
0621 {
0622
0623
0624
0625 ModuleDependsOnMap md = {{"A_TR", {"zEP1", "zEP2", "zEP3"}}, {"D", {"B"}}, {"E", {"D"}}, {"zSEP4", {"A_TR"}}};
0626 PathToModules paths = {{"p1", {"E", "F", "zEP1"}},
0627 {"p2", {"Filter", "B", "C", "D", "zEP2"}},
0628 {"p3", {"C", "D", "zEP3"}},
0629 {"p4", {"zSEP4", "B", "zEP4"}}};
0630
0631 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0632 }
0633
0634 {
0635
0636
0637
0638 ModuleDependsOnMap md = {{"A_TR", {"zEP1", "zEP2", "zEP3"}}, {"D", {"B"}}, {"E", {"D"}}, {"zSEP4", {"A_TR"}}};
0639 PathToModules paths = {{"p1", {"E", "F", "zEP1"}},
0640 {"p2", {"Filter", "B", "D", "zEP2"}},
0641 {"p3", {"C", "D", "zEP3"}},
0642 {"p4", {"zSEP4", "B", "zEP4"}}};
0643
0644 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0645 }
0646
0647 {
0648
0649
0650
0651 ModuleDependsOnMap md = {{"A_TR", {"zEP1", "zEP2"}}, {"B", {}}, {"zFilter", {"A_TR"}}};
0652 PathToModules paths = {{"p1", {"zFilter", "B", "zEP1"}}, {"p2", {"zFilter", "B", "zEP2"}}};
0653
0654 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0655 }
0656
0657 {
0658 ModuleDependsOnMap md = {{"B", {"A"}}, {"C", {"B"}}, {"cFilter", {"C"}}};
0659 PathToModules paths = {{"p1", {"C", "cFilter", "D", "E", "F", "A", "B"}}, {"p2", {"oFilter", "D", "F", "B"}}};
0660
0661 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0662 }
0663 }
0664
0665 void test_checkForModuleDependencyCorrectness::selfCycleTest() {
0666 {
0667 ModuleDependsOnMap md = {{"A", {"A"}}};
0668 PathToModules paths = {{"p", {"A"}}};
0669
0670 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0671 }
0672 {
0673 ModuleDependsOnMap md = {{"A", {"A"}}, {"B", {"A"}}};
0674 PathToModules paths = {{"p", {"B"}}};
0675
0676 CPPUNIT_ASSERT_THROW(testCase(md, paths), cms::Exception);
0677 }
0678 }
0679
0680 void test_checkForModuleDependencyCorrectness::duplicateModuleOnPathTest() {
0681 {
0682 ModuleDependsOnMap md = {{"C", {"B"}}, {"B", {"A"}}};
0683 PathToModules paths = {{"p", {"A", "B", "C", "A"}}};
0684
0685 CPPUNIT_ASSERT(testCase(md, paths));
0686 }
0687 }