Config.TestModuleCommand Class Reference

Inheritance diagram for Config.TestModuleCommand:

Public Member Functions
def	setUp (self)
def	testCloneSequence (self)
def	testConditionalTask (self)
def	testConditionalTaskPlaceholder (self)
def	testContains (self)
def	testDelete (self)
def	testExamples (self)
def	testFinalPath (self)
def	testFreeze (self)
def	testGlobalReplace (self)
def	testImplicitSchedule (self)
def	testMaxEvents (self)
def	testModifier (self)
def	testOptions (self)
def	testOverride (self)
def	testParameterizable (self)
def	testPath (self)
def	testPrefers (self)
def	testProcessAccelerator (self)
def	testProcessDumpPython (self)
def	testProcessExtend (self)
def	testProcessForProcessAccelerator (self)
def	testProcessFragment (self)
def	testProcessInsertion (self)
def	testPrune (self)
def	testRefToPSet (self)
def	testSchedule (self)
def	testSecSource (self)
def	testSequence (self)
def	testSequence2 (self)
def	testServiceInProcess (self)
def	testSubProcess (self)
def	testSwitchProducer (self)
def	testTask (self)
def	testTaskPlaceholder (self)
def	testTypedParameterizable (self)
def	testUsing (self)

Public Attributes
	maxDiff
	proc_mod_

Static Public Attributes
	a
	b
	c
	d
	e
	f
	g
	p
	p2
	process
	r
	s
	s1
	s2
	s3
	schedule
	task1
	task2
	task3
	task4
	task5
	tasks

Detailed Description

Definition at line 2285 of file Config.py.

Member Function Documentation

setUp()

def Config.TestModuleCommand.setUp

(

self

)

Nothing to do 

Definition at line 2286 of file Config.py.

        def setUp(self):
            """Nothing to do """
            None

testCloneSequence()

def Config.TestModuleCommand.testCloneSequence

(

self

)

Definition at line 3373 of file Config.py.

References EcalPhiSymFlatTableProducers_cfi.id, and str.

        def testCloneSequence(self):
            p = Process("test")
            a = EDAnalyzer("MyAnalyzer")
            p.a = a
            a.setLabel("a")
            b = EDAnalyzer("YOurAnalyzer")
            p.b = b
            b.setLabel("b")
            path = Path(a * b)
            p.path = Path(p.a*p.b)
            lookuptable = {id(a): p.a, id(b): p.b}
            #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
            #lookuptable = p._cloneToObjectDict
            #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
            self.assertEqual(str(path),str(p.path))

testConditionalTask()

def Config.TestModuleCommand.testConditionalTask

(

self

)

Definition at line 3075 of file Config.py.

        def testConditionalTask(self):

            # create some objects to use in tests
            edanalyzer = EDAnalyzer("a")
            edproducer = EDProducer("b")
            edproducer2 = EDProducer("b2")
            edproducer3 = EDProducer("b3")
            edproducer4 = EDProducer("b4")
            edproducer8 = EDProducer("b8")
            edproducer9 = EDProducer("b9")
            edfilter = EDFilter("c")
            service = Service("d")
            service3 = Service("d", v = untracked.uint32(3))
            essource = ESSource("e")
            esproducer = ESProducer("f")
            testTask2 = Task()
            testCTask2 = ConditionalTask()

            # test adding things to Tasks
            testTask1 = ConditionalTask(edproducer, edfilter)
            self.assertRaises(RuntimeError, testTask1.add, edanalyzer)
            testTask1.add(essource, service)
            testTask1.add(essource, esproducer)
            testTask1.add(testTask2)
            testTask1.add(testCTask2)
            coll = testTask1._collection
            self.assertTrue(edproducer in coll)
            self.assertTrue(edfilter in coll)
            self.assertTrue(service in coll)
            self.assertTrue(essource in coll)
            self.assertTrue(esproducer in coll)
            self.assertTrue(testTask2 in coll)
            self.assertTrue(testCTask2 in coll)
            self.assertTrue(len(coll) == 7)
            self.assertTrue(len(testTask2._collection) == 0)

            taskContents = []
            for i in testTask1:
                taskContents.append(i)
            self.assertEqual(taskContents, [edproducer, edfilter, essource, service, esproducer, testTask2, testCTask2])

            # test attaching Task to Process
            process = Process("test")

            process.mproducer = edproducer
            process.mproducer2 = edproducer2
            process.mfilter = edfilter
            process.messource = essource
            process.mesproducer = esproducer
            process.d = service

            testTask3 = ConditionalTask(edproducer, edproducer2)
            testTask1.add(testTask3)
            process.myTask1 = testTask1

            # test the validation that occurs when attaching a ConditionalTask to a Process
            # first a case that passes, then one the fails on an EDProducer
            # then one that fails on a service
            l = set()
            visitor = NodeNameVisitor(l)
            testTask1.visit(visitor)
            self.assertEqual(l, set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
            l2 = testTask1.moduleNames()
            self.assertEqual(l2, set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))

            testTask4 = ConditionalTask(edproducer3)
            l.clear()
            self.assertRaises(RuntimeError, testTask4.visit, visitor)
            try:
                process.myTask4 = testTask4
                self.assertTrue(False)
            except RuntimeError:
                pass

            testTask5 = ConditionalTask(service3)
            l.clear()
            self.assertRaises(RuntimeError, testTask5.visit, visitor)
            try:
                process.myTask5 = testTask5
                self.assertTrue(False)
            except RuntimeError:
                pass

            process.d = service3
            process.myTask5 = testTask5

            # test placement into the Process and the tasks property
            expectedDict = { 'myTask1' : testTask1, 'myTask5' : testTask5 }
            expectedFixedDict = DictTypes.FixedKeysDict(expectedDict);
            self.assertEqual(process.conditionaltasks, expectedFixedDict)
            self.assertEqual(process.conditionaltasks['myTask1'], testTask1)
            self.assertEqual(process.myTask1, testTask1)

            # test replacing an EDProducer in a ConditionalTask when calling __settattr__
            # for the EDProducer on the Process.
            process.mproducer2 = edproducer4
            process.d = service
            l = list()
            visitor1 = ModuleNodeVisitor(l)
            testTask1.visit(visitor1)
            l.sort(key=lambda mod: mod.__str__())
            expectedList = sorted([edproducer,essource,esproducer,service,edfilter,edproducer,edproducer4],key=lambda mod: mod.__str__())
            self.assertEqual(expectedList, l)
            process.myTask6 = ConditionalTask()
            process.myTask7 = ConditionalTask()
            process.mproducer8 = edproducer8
            process.myTask8 = ConditionalTask(process.mproducer8)
            process.myTask6.add(process.myTask7)
            process.myTask7.add(process.myTask8)
            process.myTask1.add(process.myTask6)
            process.myTask8.add(process.myTask5)
            self.assertEqual(process.myTask8.dumpPython(), "cms.ConditionalTask(process.mproducer8, process.myTask5)\n")

            testDict = process._itemsInDependencyOrder(process.conditionaltasks)
            expectedLabels = ["myTask5", "myTask8", "myTask7", "myTask6", "myTask1"]
            expectedTasks = [process.myTask5, process.myTask8, process.myTask7, process.myTask6, process.myTask1]
            index = 0
            for testLabel, testTask in testDict.items():
                self.assertEqual(testLabel, expectedLabels[index])
                self.assertEqual(testTask, expectedTasks[index])
                index += 1

            pythonDump = testTask1.dumpPython(PrintOptions())


            expectedPythonDump = 'cms.ConditionalTask(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer, process.mproducer2, process.myTask6)\n'
            self.assertEqual(pythonDump, expectedPythonDump)

            process.myTask5 = ConditionalTask()
            self.assertEqual(process.myTask8.dumpPython(), "cms.ConditionalTask(process.mproducer8, process.myTask5)\n")
            process.myTask100 = ConditionalTask()
            process.mproducer9 = edproducer9
            sequence1 = Sequence(process.mproducer8, process.myTask1, process.myTask5, testTask2, testTask3)
            sequence2 = Sequence(process.mproducer8 + process.mproducer9)
            process.sequence3 = Sequence((process.mproducer8 + process.mfilter))
            sequence4 = Sequence()
            process.path1 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+sequence4)
            process.path1.associate(process.myTask1, process.myTask5, testTask2, testTask3)
            process.path11 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+ sequence4,process.myTask1, process.myTask5, testTask2, testTask3, process.myTask100)
            process.path2 = Path(process.mproducer)
            process.path3 = Path(process.mproducer9+process.mproducer8,testTask2)

            self.assertEqual(process.path1.dumpPython(PrintOptions()), 'cms.Path(process.mproducer+process.mproducer8+cms.Sequence(process.mproducer8, cms.ConditionalTask(process.None, process.mproducer), cms.Task(), process.myTask1, process.myTask5)+(process.mproducer8+process.mproducer9)+process.sequence3, cms.ConditionalTask(process.None, process.mproducer), cms.Task(), process.myTask1, process.myTask5)\n')

            self.assertEqual(process.path11.dumpPython(PrintOptions()), 'cms.Path(process.mproducer+process.mproducer8+cms.Sequence(process.mproducer8, cms.ConditionalTask(process.None, process.mproducer), cms.Task(), process.myTask1, process.myTask5)+(process.mproducer8+process.mproducer9)+process.sequence3, cms.ConditionalTask(process.None, process.mproducer), cms.Task(), process.myTask1, process.myTask100, process.myTask5)\n')

            # test NodeNameVisitor and moduleNames
            l = set()
            nameVisitor = NodeNameVisitor(l)
            process.path1.visit(nameVisitor)
            self.assertTrue(l == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
            self.assertTrue(process.path1.moduleNames() == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))

            # test copy
            process.mproducer10 = EDProducer("b10")
            process.path21 = process.path11.copy()
            process.path21.replace(process.mproducer, process.mproducer10)

            self.assertEqual(process.path11.dumpPython(PrintOptions()), 'cms.Path(process.mproducer+process.mproducer8+cms.Sequence(process.mproducer8, cms.ConditionalTask(process.None, process.mproducer), cms.Task(), process.myTask1, process.myTask5)+(process.mproducer8+process.mproducer9)+process.sequence3, cms.ConditionalTask(process.None, process.mproducer), cms.Task(), process.myTask1, process.myTask100, process.myTask5)\n')

            # Some peculiarities of the way things work show up here. dumpPython sorts tasks and
            # removes duplication at the level of strings. The Task and Sequence objects themselves
            # remove duplicate tasks in their contents if the instances are the same (exact same python
            # object id which is not the same as the string representation being the same).
            # Also note that the mutating visitor replaces sequences and tasks that have
            # modified contents with their modified contents, it does not modify the sequence
            # or task itself.
            self.assertEqual(process.path21.dumpPython(PrintOptions()), 'cms.Path(process.mproducer10+process.mproducer8+process.mproducer8+(process.mproducer8+process.mproducer9)+process.sequence3, cms.ConditionalTask(process.None, process.mproducer10), cms.ConditionalTask(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer10, process.mproducer2, process.mproducer8, process.myTask5), cms.Task(), process.myTask100, process.myTask5)\n')

            process.path22 = process.path21.copyAndExclude([process.d, process.mesproducer, process.mfilter])
            self.assertEqual(process.path22.dumpPython(PrintOptions()), 'cms.Path(process.mproducer10+process.mproducer8+process.mproducer8+(process.mproducer8+process.mproducer9)+process.mproducer8, cms.ConditionalTask(process.None, process.mproducer10), cms.ConditionalTask(process.messource, process.mproducer10, process.mproducer2, process.mproducer8, process.myTask5), cms.Task(), process.myTask100, process.myTask5)\n')

            process.path23 = process.path22.copyAndExclude([process.messource, process.mproducer10])
            self.assertEqual(process.path23.dumpPython(PrintOptions()), 'cms.Path(process.mproducer8+process.mproducer8+(process.mproducer8+process.mproducer9)+process.mproducer8, cms.ConditionalTask(process.None), cms.ConditionalTask(process.mproducer2, process.mproducer8, process.myTask5), cms.Task(), process.myTask100, process.myTask5)\n')

            process = Process("Test")

            process.b = EDProducer("b")
            process.b2 = EDProducer("b2")
            process.b3 = EDProducer("b3")
            process.p = Path(process.b, ConditionalTask(process.b3, process.b2))
            p = TestMakePSet()
            process.fillProcessDesc(p)
            self.assertEqual(p.values["@all_modules"], (True, ['b', 'b2', 'b3']))
            self.assertEqual(p.values["@paths"], (True, ['p']))
            self.assertEqual(p.values["p"], (True, ['b','#','b2','b3','@']))
            

testConditionalTaskPlaceholder()

def Config.TestModuleCommand.testConditionalTaskPlaceholder

(

self

)

Definition at line 4099 of file Config.py.

References Config._lineDiff(), and ConfigBuilder.dumpPython().

        def testConditionalTaskPlaceholder(self):
            p = Process("test")
            p.a = EDProducer("ma")
            p.b = EDAnalyzer("mb")
            p.t1 = ConditionalTask(ConditionalTaskPlaceholder("c"))
            p.t2 = ConditionalTask(p.a, ConditionalTaskPlaceholder("d"), p.t1)
            p.t3 = ConditionalTask(ConditionalTaskPlaceholder("e"))
            p.path1 = Path(p.b, p.t2, p.t3)
            p.t5 = ConditionalTask(p.a, ConditionalTaskPlaceholder("g"), ConditionalTaskPlaceholder("t4"))
            p.t4 = ConditionalTask(ConditionalTaskPlaceholder("f"))
            p.path2 = Path(p.b, p.t5)
            p.schedule = Schedule(p.path1, p.path2)
            p.c = EDProducer("mc")
            p.d = EDProducer("md")
            p.e = EDProducer("me")
            p.f = EDProducer("mf")
            p.g = EDProducer("mg")
            p.h = EDProducer("mh")
            p.i = EDProducer("mi")
            p.j = EDProducer("mj")
            self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
"""process.a = cms.EDProducer("ma")
process.c = cms.EDProducer("mc")
process.d = cms.EDProducer("md")
process.e = cms.EDProducer("me")
process.f = cms.EDProducer("mf")
process.g = cms.EDProducer("mg")
process.h = cms.EDProducer("mh")
process.i = cms.EDProducer("mi")
process.j = cms.EDProducer("mj")
process.b = cms.EDAnalyzer("mb")
process.t1 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("c"))
process.t2 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("d"), process.a, process.t1)
process.t3 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("e"))
process.t5 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("g"), cms.ConditionalTaskPlaceholder("t4"), process.a)
process.t4 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("f"))
process.path1 = cms.Path(process.b, process.t2, process.t3)
process.path2 = cms.Path(process.b, process.t5)
process.schedule = cms.Schedule(*[ process.path1, process.path2 ])""")
            p.resolve()
            self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
"""process.a = cms.EDProducer("ma")
process.c = cms.EDProducer("mc")
process.d = cms.EDProducer("md")
process.e = cms.EDProducer("me")
process.f = cms.EDProducer("mf")
process.g = cms.EDProducer("mg")
process.h = cms.EDProducer("mh")
process.i = cms.EDProducer("mi")
process.j = cms.EDProducer("mj")
process.b = cms.EDAnalyzer("mb")
process.t1 = cms.ConditionalTask(process.c)
process.t2 = cms.ConditionalTask(process.a, process.d, process.t1)
process.t3 = cms.ConditionalTask(process.e)
process.t4 = cms.ConditionalTask(process.f)
process.t5 = cms.ConditionalTask(process.a, process.g, process.t4)
process.path1 = cms.Path(process.b, process.t2, process.t3)
process.path2 = cms.Path(process.b, process.t5)
process.schedule = cms.Schedule(*[ process.path1, process.path2 ])""")

testContains()

def Config.TestModuleCommand.testContains

(

self

)

Definition at line 3389 of file Config.py.

        def testContains(self):

            a = EDProducer("a")
            b = EDProducer("b")
            c = EDProducer("c")
            d = EDProducer("d")
            e = EDProducer("e")
            f = EDProducer("f")
            g = EDProducer("g")
            h = EDProducer("h")
            i = EDProducer("i")
            j = EDProducer("j")
            k = EDProducer("k")
            l = EDProducer("l")
            m = EDProducer("m")
            n = EDProducer("n")

            seq1 = Sequence(e)
            task1 = Task(g)
            ctask1 = ConditionalTask(h)
            path = Path(a * c * seq1, task1, ctask1)

            self.assertTrue(path.contains(a))
            self.assertFalse(path.contains(b))
            self.assertTrue(path.contains(c))
            self.assertFalse(path.contains(d))
            self.assertTrue(path.contains(e))
            self.assertFalse(path.contains(f))
            self.assertTrue(path.contains(g))
            self.assertTrue(path.contains(h))

            endpath = EndPath(h * i)
            self.assertFalse(endpath.contains(b))
            self.assertTrue(endpath.contains(i))

            seq = Sequence(a * c)
            self.assertFalse(seq.contains(b))
            self.assertTrue(seq.contains(c))

            task2 = Task(l)
            task = Task(j, k, task2)
            self.assertFalse(task.contains(b))
            self.assertTrue(task.contains(j))
            self.assertTrue(task.contains(k))
            self.assertTrue(task.contains(l))

            task3 = Task(m)
            path2 = Path(n)
            sch = Schedule(path, path2, tasks=[task,task3])
            self.assertFalse(sch.contains(b))
            self.assertTrue(sch.contains(a))
            self.assertTrue(sch.contains(c))
            self.assertTrue(sch.contains(e))
            self.assertTrue(sch.contains(g))
            self.assertTrue(sch.contains(n))
            self.assertTrue(sch.contains(j))
            self.assertTrue(sch.contains(k))
            self.assertTrue(sch.contains(l))
            self.assertTrue(sch.contains(m))

            ctask2 = ConditionalTask(l, task1)
            ctask = ConditionalTask(j, k, ctask2)
            self.assertFalse(ctask.contains(b))
            self.assertTrue(ctask.contains(j))
            self.assertTrue(ctask.contains(k))
            self.assertTrue(ctask.contains(l))
            self.assertTrue(ctask.contains(g))

testDelete()

def Config.TestModuleCommand.testDelete

(

self

)

Definition at line 4159 of file Config.py.

References ConfigBuilder.dumpPython().

        def testDelete(self):
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.d = EDAnalyzer("OurAnalyzer")
            p.e = EDAnalyzer("OurAnalyzer")
            p.f = EDAnalyzer("OurAnalyzer")
            p.g = EDProducer("OurProducer")
            p.h = EDProducer("YourProducer")
            p.i = SwitchProducerTest(
                test1 = EDProducer("OneProducer"),
                test2 = EDProducer("TwoProducer")
            )
            p.t1 = Task(p.g, p.h, p.i)
            t2 = Task(p.g, p.h, p.i)
            t3 = Task(p.g, p.h)
            p.t4 = Task(p.h)
            p.ct1 = ConditionalTask(p.g, p.h, p.i)
            ct2 = ConditionalTask(p.g, p.h)
            ct3 = ConditionalTask(p.g, p.h)
            p.ct4 = ConditionalTask(p.h)
            p.s = Sequence(p.d+p.e)
            p.path1 = Path(p.a+p.f+p.s,t2,ct2)
            p.path2 = Path(p.a)
            p.path3 = Path(ct3, p.ct4)
            p.endpath2 = EndPath(p.b)
            p.endpath1 = EndPath(p.b+p.f)
            p.schedule = Schedule(p.path2, p.path3, p.endpath2, tasks=[t3, p.t4])
            self.assertTrue(hasattr(p, 'f'))
            self.assertTrue(hasattr(p, 'g'))
            self.assertTrue(hasattr(p, 'i'))
            del p.e
            del p.f
            del p.g
            del p.i
            self.assertFalse(hasattr(p, 'f'))
            self.assertFalse(hasattr(p, 'g'))
            self.assertEqual(p.t1.dumpPython(), 'cms.Task(process.h)\n')
            self.assertEqual(p.ct1.dumpPython(), 'cms.ConditionalTask(process.h)\n')
            self.assertEqual(p.s.dumpPython(), 'cms.Sequence(process.d)\n')
            self.assertEqual(p.path1.dumpPython(), 'cms.Path(process.a+process.s, cms.ConditionalTask(process.h), cms.Task(process.h))\n')
            self.assertEqual(p.endpath1.dumpPython(), 'cms.EndPath(process.b)\n')
            self.assertEqual(p.path3.dumpPython(), 'cms.Path(cms.ConditionalTask(process.h), process.ct4)\n')
            del p.s
            self.assertEqual(p.path1.dumpPython(), 'cms.Path(process.a+(process.d), cms.ConditionalTask(process.h), cms.Task(process.h))\n')
            self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(*[ process.path2, process.path3, process.endpath2 ], tasks=[cms.Task(process.h), process.t4])\n')
            del p.path2
            self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(*[ process.path3, process.endpath2 ], tasks=[cms.Task(process.h), process.t4])\n')
            del p.path3
            self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(*[ process.endpath2 ], tasks=[cms.Task(process.h), process.t4])\n')
            del p.endpath2
            self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(tasks=[cms.Task(process.h), process.t4])\n')
            del p.t4
            self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(tasks=[cms.Task(process.h)])\n')

testExamples()

def Config.TestModuleCommand.testExamples

(

self

)

Definition at line 3659 of file Config.py.

References Types.untracked.

        def testExamples(self):
            p = Process("Test")
            p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
            p.foos = EDProducer("FooProducer")
            p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
            p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
            p.bars.foos = 'Foosball'
            self.assertEqual(p.bars.foos, InputTag('Foosball'))
            p.p = Path(p.foos*p.bars)
            p.e = EndPath(p.out)
            p.add_(Service("MessageLogger"))

testFinalPath()

def Config.TestModuleCommand.testFinalPath

(

self

)

Definition at line 3314 of file Config.py.

References str.

        def testFinalPath(self):
            p = Process("test")
            p.a = OutputModule("MyOutputModule")
            p.b = OutputModule("YourOutputModule")
            p.c = OutputModule("OurOutputModule")
            path = FinalPath(p.a)
            path *= p.b
            path += p.c
            self.assertEqual(str(path),'a+b+c')
            path = FinalPath(p.a*p.b+p.c)
            self.assertEqual(str(path),'a+b+c')
            path = FinalPath(p.a+ p.b*p.c)
            self.assertEqual(str(path),'a+b+c')
            path = FinalPath(p.a*(p.b+p.c))
            self.assertEqual(str(path),'a+b+c')
            p.es = ESProducer("AnESProducer")
            self.assertRaises(TypeError,FinalPath, p.es)

            t = FinalPath()
            self.assertEqual(t.dumpPython(PrintOptions()), 'cms.FinalPath()\n')

            t = FinalPath(p.a)
            self.assertEqual(t.dumpPython(PrintOptions()), 'cms.FinalPath(process.a)\n')

            self.assertRaises(TypeError, FinalPath, Task())
            self.assertRaises(TypeError, FinalPath, p.a, Task())

            p.prod = EDProducer("prodName")
            p.t1 = Task(p.prod)
            self.assertRaises(TypeError, FinalPath, p.a, p.t1, Task(), p.t1)

            p.prod = EDProducer("prodName")
            p.t1 = ConditionalTask(p.prod)
            self.assertRaises(TypeError, FinalPath, p.a, p.t1, ConditionalTask(), p.t1)

            p.t = FinalPath(p.a)
            p.a = OutputModule("ReplacedOutputModule")
            self.assertEqual(p.t.dumpPython(PrintOptions()), 'cms.FinalPath(process.a)\n')

            p.anal = EDAnalyzer("MyAnalyzer")
            p.t = FinalPath(p.anal)
            pset = TestMakePSet()
            self.assertRaises(RuntimeError, p.fillProcessDesc, pset)

            p.prod = EDProducer("MyProducer")
            p.t = FinalPath(p.prod)
            pset = TestMakePSet()
            self.assertRaises(RuntimeError, p.fillProcessDesc, pset)

            p.filt = EDFilter("MyFilter")
            p.t = FinalPath(p.filt)
            pset = TestMakePSet()
            self.assertRaises(RuntimeError, p.fillProcessDesc, pset)

            p.outp = OutputModule("MyOutputModule")
            p.t = FinalPath(p.outp)
            pset = TestMakePSet()
            p.fillProcessDesc(pset)

testFreeze()

def Config.TestModuleCommand.testFreeze

(

self

)

Definition at line 3691 of file Config.py.

        def testFreeze(self):
            process = Process("Freeze")
            m = EDProducer("M", p=PSet(i = int32(1)))
            m.p.i = 2
            process.m = m
            # should be frozen
            #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
            #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
            #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
            #self.assertRaises(ValueError, setattr, m, 'j', 1)
            # But OK to change through the process
            process.m.p.i = 4
            self.assertEqual(process.m.p.i.value(), 4)
            process.m.p = PSet(j=int32(1))
            # should work to clone it, though
            m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
            m2.p.i = 6
            m2.j = 8

testGlobalReplace()

def Config.TestModuleCommand.testGlobalReplace

(

self

)

Definition at line 2769 of file Config.py.

        def testGlobalReplace(self):
            p = Process('test')
            p.a = EDAnalyzer("MyAnalyzer")
            old = p.a
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.d = EDProducer("MyProducer")
            old2 = p.d
            p.t1 = Task(p.d)
            t2 = Task(p.d)
            t3 = Task(p.d)
            t4 = Task(p.d)
            t5 = Task(p.d)
            t6 = Task(p.d)
            p.ct1 = ConditionalTask(p.d)
            s = Sequence(p.a*p.b)
            p.s4 = Sequence(p.a*p.b, p.ct1)
            s.associate(t2)
            p.s4.associate(t2)
            p.p = Path(p.c+s+p.a)
            p.p2 = Path(p.c+p.s4+p.a, p.ct1)
            p.e3 = EndPath(p.c+s+p.a)
            new = EDAnalyzer("NewAnalyzer")
            new2 = EDProducer("NewProducer")
            visitor1 = NodeVisitor()
            p.p.visit(visitor1)
            self.assertTrue(visitor1.modules == set([old,old2,p.b,p.c]))
            p.schedule = Schedule(tasks=[t6])
            p.globalReplace("a",new)
            p.globalReplace("d",new2)
            visitor2 = NodeVisitor()
            p.p.visit(visitor2)
            self.assertTrue(visitor2.modules == set([new,new2,p.b,p.c]))
            self.assertEqual(p.p.dumpPython()[:-1], "cms.Path(process.c+process.a+process.b+process.a, cms.Task(process.d))")
            visitor_p2 = NodeVisitor()
            p.p2.visit(visitor_p2)
            self.assertTrue(visitor_p2.modules == set([new,new2,p.b,p.c]))
            self.assertEqual(p.p2.dumpPython()[:-1], "cms.Path(process.c+process.s4+process.a, process.ct1)")
            visitor3 = NodeVisitor()
            p.e3.visit(visitor3)
            self.assertTrue(visitor3.modules == set([new,new2,p.b,p.c]))
            visitor4 = NodeVisitor()
            p.s4.visit(visitor4)
            self.assertTrue(visitor4.modules == set([new,new2,p.b]))
            self.assertEqual(p.s4.dumpPython()[:-1],"cms.Sequence(process.a+process.b, cms.Task(process.d), process.ct1)")
            visitor5 = NodeVisitor()
            p.t1.visit(visitor5)
            self.assertTrue(visitor5.modules == set([new2]))
            visitor6 = NodeVisitor()
            listOfTasks = list(p.schedule._tasks)
            listOfTasks[0].visit(visitor6)
            self.assertTrue(visitor6.modules == set([new2]))
            visitor7 = NodeVisitor()
            p.ct1.visit(visitor7)
            self.assertTrue(visitor7.modules == set([new2]))
            visitor8 = NodeVisitor()
            listOfConditionalTasks = list(p.conditionaltasks.values())
            listOfConditionalTasks[0].visit(visitor8)
            self.assertTrue(visitor8.modules == set([new2]))


            p.d2 = EDProducer("YourProducer")
            p.schedule = Schedule(p.p, p.p2, p.e3, tasks=[p.t1])
            self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
            p.p = Path(p.c+s)
            self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
            p.e3 = EndPath(p.c)
            self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
            p.t1 = Task(p.d2)
            self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")

testImplicitSchedule()

def Config.TestModuleCommand.testImplicitSchedule

(

self

)

Definition at line 3562 of file Config.py.

        def testImplicitSchedule(self):
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.path1 = Path(p.a)
            p.path2 = Path(p.b)
            self.assertTrue(p.schedule is None)
            pths = p.paths
            keys = pths.keys()
            self.assertEqual(pths[keys[0]],p.path1)
            self.assertEqual(pths[keys[1]],p.path2)
            p.prune()
            self.assertTrue(hasattr(p, 'a'))
            self.assertTrue(hasattr(p, 'b'))
            self.assertTrue(not hasattr(p, 'c'))
            self.assertTrue(hasattr(p, 'path1'))
            self.assertTrue(hasattr(p, 'path2'))


            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.path2 = Path(p.b)
            p.path1 = Path(p.a)
            self.assertTrue(p.schedule is None)
            pths = p.paths
            keys = pths.keys()
            self.assertEqual(pths[keys[1]],p.path1)
            self.assertEqual(pths[keys[0]],p.path2)

testMaxEvents()

def Config.TestModuleCommand.testMaxEvents

(

self

)

Definition at line 3641 of file Config.py.

        def testMaxEvents(self):
            p = Process("Test")
            p.maxEvents.input = 10
            self.assertEqual(p.maxEvents.input.value(),10)
            p = Process("Test")
            p.maxEvents.output = 10
            self.assertEqual(p.maxEvents.output.value(),10)
            p = Process("Test")
            p.maxEvents.output = PSet(out=untracked.int32(10))
            self.assertEqual(p.maxEvents.output.out.value(), 10)
            p = Process("Test")
            p.maxEvents = untracked.PSet(input = untracked.int32(5))
            self.assertEqual(p.maxEvents.input.value(), 5)
            del p.maxEvents
            self.assertRaises(TypeError, setattr, p, 'maxEvents', untracked.PSet(input = untracked.uint32(1)))
            p.maxEvents = untracked.PSet(input = untracked.int32(1))
            self.assertEqual(p.maxEvents.input.value(), 1)
        

testModifier()

def Config.TestModuleCommand.testModifier

(

self

)

Definition at line 4214 of file Config.py.

References submitPVValidationJobs.__init__(), and default_text_conditions_cfi.object.

        def testModifier(self):
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test")
            self.assertRaises(RuntimeError, lambda: Process("test2", m1))
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
            def _mod_fred(obj):
                obj.fred = 2
            m1.toModify(p.a,_mod_fred)
            self.assertEqual(p.a.fred.value(),2)
            p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
            m1.toModify(p.b, wilma = 2)
            self.assertEqual(p.b.wilma.value(),2)
            self.assertTrue(p.isUsingModifier(m1))
            #check that Modifier not attached to a process doesn't run
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
            m1.toModify(p.a,_mod_fred)
            p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
            m1.toModify(p.b, wilma = 2)
            self.assertEqual(p.a.fred.value(),1)
            self.assertEqual(p.b.wilma.value(),1)
            self.assertEqual(p.isUsingModifier(m1),False)
            #make sure clones get the changes
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
            m1.toModify(p.a, fred = int32(2))
            p.b = p.a.clone(wilma = int32(3))
            self.assertEqual(p.a.fred.value(),2)
            self.assertEqual(p.a.wilma.value(),1)
            self.assertEqual(p.b.fred.value(),2)
            self.assertEqual(p.b.wilma.value(),3)
            #test removal of parameter
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1), fintstones = PSet(fred = int32(1)))
            m1.toModify(p.a, fred = None, fintstones = dict(fred = None))
            self.assertEqual(hasattr(p.a, "fred"), False)
            self.assertEqual(hasattr(p.a.fintstones, "fred"), False)
            self.assertEqual(p.a.wilma.value(),1)
            #test adding a parameter
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
            m1.toModify(p.a, wilma = int32(2))
            self.assertEqual(p.a.fred.value(), 1)
            self.assertEqual(p.a.wilma.value(),2)
            #test setting of value in PSet
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = int32(1), wilma = int32(1)))
            m1.toModify(p.a, flintstones = dict(fred = int32(2)))
            self.assertEqual(p.a.flintstones.fred.value(),2)
            self.assertEqual(p.a.flintstones.wilma.value(),1)
            #test proper exception from nonexisting parameter name
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = PSet(wilma = int32(1))))
            self.assertRaises(KeyError, lambda: m1.toModify(p.a, flintstones = dict(imnothere = dict(wilma=2))))
            self.assertRaises(KeyError, lambda: m1.toModify(p.a, foo = 1))
            #test setting a value in a VPSet
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
            m1.toModify(p.a, flintstones = {1:dict(wilma = int32(2))})
            self.assertEqual(p.a.flintstones[0].fred.value(),1)
            self.assertEqual(p.a.flintstones[1].wilma.value(),2)
            #test setting a value in a list of values
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
            m1.toModify(p.a, fred = {1:7})
            self.assertEqual(p.a.fred[0],1)
            self.assertEqual(p.a.fred[1],7)
            self.assertEqual(p.a.fred[2],3)
            #test IndexError setting a value in a list to an item key not in the list
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
            raised = False
            try: m1.toModify(p.a, fred = {5:7})
            except IndexError as e: raised = True
            self.assertEqual(raised, True)
            #test TypeError setting a value in a list using a key that is not an int
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
            raised = False
            try: m1.toModify(p.a, flintstones = dict(bogus = int32(37)))
            except TypeError as e: raised = True
            self.assertEqual(raised, True)
            #test that load causes process wide methods to run
            def _rem_a(proc):
                del proc.a
            class ProcModifierMod(object):
                def __init__(self,modifier,func):
                    self.proc_mod_ = modifier.makeProcessModifier(func)
            class DummyMod(object):
                def __init__(self):
                    self.a = EDAnalyzer("Dummy")
            testMod = DummyMod()
            p.extend(testMod)
            self.assertTrue(hasattr(p,"a"))
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            testProcMod = ProcModifierMod(m1,_rem_a)
            p.extend(testMod)
            p.extend(testProcMod)
            self.assertTrue(not hasattr(p,"a"))
            #test ModifierChain
            m1 = Modifier()
            mc = ModifierChain(m1)
            Process._firstProcess = True
            p = Process("test",mc)
            self.assertTrue(p.isUsingModifier(m1))
            self.assertTrue(p.isUsingModifier(mc))
            testMod = DummyMod()
            p.b = EDAnalyzer("Dummy2", fred = int32(1))
            m1.toModify(p.b, fred = int32(3))
            p.extend(testMod)
            testProcMod = ProcModifierMod(m1,_rem_a)
            p.extend(testProcMod)
            self.assertTrue(not hasattr(p,"a"))
            self.assertEqual(p.b.fred.value(),3)
            #check cloneAndExclude
            m1 = Modifier()
            m2 = Modifier()
            mc = ModifierChain(m1,m2)
            mclone = mc.copyAndExclude([m2])
            self.assertTrue(not mclone._isOrContains(m2))
            self.assertTrue(mclone._isOrContains(m1))
            m3 = Modifier()
            mc2 = ModifierChain(mc,m3)
            mclone = mc2.copyAndExclude([m2])
            self.assertTrue(not mclone._isOrContains(m2))
            self.assertTrue(mclone._isOrContains(m1))
            self.assertTrue(mclone._isOrContains(m3))
            #check combining
            m1 = Modifier()
            m2 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
            (m1 & m2).toModify(p.a, fred = int32(2))
            self.assertRaises(TypeError, lambda: (m1 & m2).toModify(p.a, 1, wilma=2))
            self.assertEqual(p.a.fred, 1)
            m1 = Modifier()
            m2 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1,m2)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
            (m1 & m2).toModify(p.a, fred = int32(2))
            self.assertEqual(p.a.fred, 2)
            m1 = Modifier()
            m2 = Modifier()
            m3 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1,m2,m3)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
            (m1 & m2 & m3).toModify(p.a, fred = int32(2))
            self.assertEqual(p.a.fred, 2)
            (m1 & (m2 & m3)).toModify(p.a, fred = int32(3))
            self.assertEqual(p.a.fred, 3)
            ((m1 & m2) & m3).toModify(p.a, fred = int32(4))
            self.assertEqual(p.a.fred, 4)
            #check inverse
            m1 = Modifier()
            m2 = Modifier()
            Process._firstProcess = True
            p = Process("test", m1)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
            (~m1).toModify(p.a, fred=2)
            self.assertEqual(p.a.fred, 1)
            (~m2).toModify(p.a, wilma=2)
            self.assertEqual(p.a.wilma, 2)
            self.assertRaises(TypeError, lambda: (~m1).toModify(p.a, 1, wilma=2))
            self.assertRaises(TypeError, lambda: (~m2).toModify(p.a, 1, wilma=2))
            # check or
            m1 = Modifier()
            m2 = Modifier()
            m3 = Modifier()
            Process._firstProcess = True
            p = Process("test", m1)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
            (m1 | m2).toModify(p.a, fred=2)
            self.assertEqual(p.a.fred, 2)
            (m1 | m2 | m3).toModify(p.a, fred=3)
            self.assertEqual(p.a.fred, 3)
            (m3 | m2 | m1).toModify(p.a, fred=4)
            self.assertEqual(p.a.fred, 4)
            ((m1 | m2) | m3).toModify(p.a, fred=5)
            self.assertEqual(p.a.fred, 5)
            (m1 | (m2 | m3)).toModify(p.a, fred=6)
            self.assertEqual(p.a.fred, 6)
            (m2 | m3).toModify(p.a, fred=7)
            self.assertEqual(p.a.fred, 6)
            self.assertRaises(TypeError, lambda: (m1 | m2).toModify(p.a, 1, wilma=2))
            self.assertRaises(TypeError, lambda: (m2 | m3).toModify(p.a, 1, wilma=2))
            # check combinations
            m1 = Modifier()
            m2 = Modifier()
            m3 = Modifier()
            m4 = Modifier()
            Process._firstProcess = True
            p = Process("test", m1, m2)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
            (m1 & ~m2).toModify(p.a, fred=2)
            self.assertEqual(p.a.fred, 1)
            (m1 & ~m3).toModify(p.a, fred=2)
            self.assertEqual(p.a.fred, 2)
            (m1 | ~m2).toModify(p.a, fred=3)
            self.assertEqual(p.a.fred, 3)
            (~m1 | ~m2).toModify(p.a, fred=4)
            self.assertEqual(p.a.fred, 3)
            (~m3 & ~m4).toModify(p.a, fred=4)
            self.assertEqual(p.a.fred, 4)
            ((m1 & m3) | ~m4).toModify(p.a, fred=5)
            self.assertEqual(p.a.fred, 5)
            #check toReplaceWith
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test",m1)
            p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
            m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
            self.assertRaises(TypeError, lambda: m1.toReplaceWith(p.a, EDProducer("YourProducer")))
            #Task
            p.b =EDAnalyzer("BAn")
            p.c =EDProducer("c")
            p.d =EDProducer("d")
            p.tc = Task(p.c)
            p.td = Task(p.d)
            p.s = Sequence(p.a, p.tc)
            m1.toReplaceWith(p.s, Sequence(p.a+p.b, p.td))
            self.assertEqual(p.a.wilma.value(),3)
            self.assertEqual(p.a.type_(),"YourAnalyzer")
            self.assertEqual(hasattr(p,"fred"),False)
            self.assertTrue(p.s.dumpPython() == "cms.Sequence(process.a+process.b, process.td)\n")
            p.e =EDProducer("e")
            m1.toReplaceWith(p.td, Task(p.e))
            self.assertTrue(p.td._collection == OrderedSet([p.e]))
            #ConditionalTask
            p.b =EDAnalyzer("BAn")
            p.c =EDProducer("c")
            p.d =EDProducer("d")
            del p.tc
            del p.td
            p.tc = ConditionalTask(p.c)
            p.td = ConditionalTask(p.d)
            p.s = Sequence(p.a, p.tc)
            m1.toReplaceWith(p.s, Sequence(p.a+p.b, p.td))
            self.assertEqual(p.a.wilma.value(),3)
            self.assertEqual(p.a.type_(),"YourAnalyzer")
            self.assertEqual(hasattr(p,"fred"),False)
            self.assertTrue(p.s.dumpPython() == "cms.Sequence(process.a+process.b, process.td)\n")
            p.e =EDProducer("e")
            m1.toReplaceWith(p.td, ConditionalTask(p.e))
            self.assertTrue(p.td._collection == OrderedSet([p.e]))
            #check toReplaceWith doesn't activate not chosen
            m1 = Modifier()
            Process._firstProcess = True
            p = Process("test")
            p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
            m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
            self.assertEqual(p.a.type_(),"MyAnalyzer")
            #check toReplaceWith and and/not/or combinations
            m1 = Modifier()
            m2 = Modifier()
            m3 = Modifier()
            m4 = Modifier()
            Process._firstProcess = True
            p = Process("test", m1, m2)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
            self.assertRaises(TypeError, lambda: (m1 & m2).toReplaceWith(p.a, EDProducer("YourProducer")))
            self.assertRaises(TypeError, lambda: (m3 & m4).toReplaceWith(p.a, EDProducer("YourProducer")))
            self.assertRaises(TypeError, lambda: (~m3).toReplaceWith(p.a, EDProducer("YourProducer")))
            self.assertRaises(TypeError, lambda: (~m1).toReplaceWith(p.a, EDProducer("YourProducer")))
            self.assertRaises(TypeError, lambda: (m1 | m3).toReplaceWith(p.a, EDProducer("YourProducer")))
            self.assertRaises(TypeError, lambda: (m3 | m4).toReplaceWith(p.a, EDProducer("YourProducer")))
            (m1 & m2).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer1"))
            self.assertEqual(p.a.type_(), "YourAnalyzer1")
            (m1 & m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
            self.assertEqual(p.a.type_(), "YourAnalyzer1")
            (~m1).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
            self.assertEqual(p.a.type_(), "YourAnalyzer1")
            (~m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
            self.assertEqual(p.a.type_(), "YourAnalyzer2")
            (m1 | m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer3"))
            self.assertEqual(p.a.type_(), "YourAnalyzer3")
            (m3 | m4).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer4"))
            self.assertEqual(p.a.type_(), "YourAnalyzer3")
            #check chaining of toModify and toReplaceWith
            m1 = Modifier()
            m2 = Modifier()
            m3 = Modifier()
            Process._firstProcess = True
            p = Process("test", m1, m2)
            p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
            p.b = EDProducer("MyProducer", barney = int32(1), betty = int32(1))
            (m1 & m2).toModify(p.a, fred = 2).toModify(p.b, betty = 3)
            self.assertEqual(p.a.fred, 2)
            self.assertEqual(p.a.wilma, 1)
            self.assertEqual(p.b.barney, 1)
            self.assertEqual(p.b.betty, 3)
            (m1 | m3).toModify(p.a, wilma = 4).toModify(p.b, barney = 5)
            self.assertEqual(p.a.fred, 2)
            self.assertEqual(p.a.wilma, 4)
            self.assertEqual(p.b.barney, 5)
            self.assertEqual(p.b.betty, 3)
            (m2 & ~m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer")).toModify(p.b, barney = 6)
            self.assertEqual(p.a.type_(), "YourAnalyzer")
            self.assertEqual(p.b.barney, 6)
            self.assertEqual(p.b.betty, 3)
            (m1 & ~m3).toModify(p.a, param=int32(42)).toReplaceWith(p.b, EDProducer("YourProducer"))
            self.assertEqual(p.a.type_(), "YourAnalyzer")
            self.assertEqual(p.a.param, 42)
            self.assertEqual(p.b.type_(), "YourProducer")

            # EDAlias
            a = EDAlias(foo2 = VPSet(PSet(type = string("Foo2"))))
            m = Modifier()
            m._setChosen()
            # Modify parameters
            m.toModify(a, foo2 = {0: dict(type = "Foo3")})
            self.assertEqual(a.foo2[0].type, "Foo3")
            # Add an alias
            m.toModify(a, foo4 = VPSet(PSet(type = string("Foo4"))))
            self.assertEqual(a.foo2[0].type, "Foo3")
            self.assertEqual(a.foo4[0].type, "Foo4")
            # Remove an alias
            m.toModify(a, foo2 = None)
            self.assertFalse(hasattr(a, "foo2"))
            self.assertEqual(a.foo4[0].type, "Foo4")
            # Replace (doesn't work out of the box because EDAlias is not _Parameterizable
            m.toReplaceWith(a, EDAlias(bar = VPSet(PSet(type = string("Bar")))))
            self.assertFalse(hasattr(a, "foo2"))
            self.assertFalse(hasattr(a, "foo4"))
            self.assertTrue(hasattr(a, "bar"))
            self.assertEqual(a.bar[0].type, "Bar")

            # SwitchProducer
            sp = SwitchProducerTest(test1 = EDProducer("Foo",
                                                       a = int32(1),
                                                       b = PSet(c = int32(2))),
                                    test2 = EDProducer("Bar",
                                                       aa = int32(11),
                                                       bb = PSet(cc = int32(12))))
            m = Modifier()
            m._setChosen()
            # Modify parameters
            m.toModify(sp,
                       test1 = dict(a = 4, b = dict(c = None)),
                       test2 = dict(aa = 15, bb = dict(cc = 45, dd = string("foo"))))
            self.assertEqual(sp.test1.a.value(), 4)
            self.assertEqual(sp.test1.b.hasParameter("c"), False)
            self.assertEqual(sp.test2.aa.value(), 15)
            self.assertEqual(sp.test2.bb.cc.value(), 45)
            self.assertEqual(sp.test2.bb.dd.value(), "foo")
            # Replace a producer
            m.toReplaceWith(sp.test1, EDProducer("Fred", x = int32(42)))
            self.assertEqual(sp.test1.type_(), "Fred")
            self.assertEqual(sp.test1.x.value(), 42)
            self.assertRaises(TypeError, lambda: m.toReplaceWith(sp.test1, EDAnalyzer("Foo")))
            # Alternative way (only to be allow same syntax to be used as for adding)
            m.toModify(sp, test2 = EDProducer("Xyzzy", x = int32(24)))
            self.assertEqual(sp.test2.type_(), "Xyzzy")
            self.assertEqual(sp.test2.x.value(), 24)
            self.assertRaises(TypeError, lambda: m.toModify(sp, test2 = EDAnalyzer("Foo")))
            # Add a producer
            m.toModify(sp, test3 = EDProducer("Wilma", y = int32(24)))
            self.assertEqual(sp.test3.type_(), "Wilma")
            self.assertEqual(sp.test3.y.value(), 24)
            self.assertRaises(TypeError, lambda: m.toModify(sp, test4 = EDAnalyzer("Foo")))
            # Remove a producer
            m.toModify(sp, test2 = None)
            self.assertEqual(hasattr(sp, "test2"), False)
            # Add an alias
            m.toModify(sp, test2 = EDAlias(foo = VPSet(PSet(type = string("int")))))
            self.assertTrue(hasattr(sp.test2, "foo"))
            # Replace an alias
            m.toReplaceWith(sp.test2, EDAlias(bar = VPSet(PSet(type = string("int")))))
            self.assertTrue(hasattr(sp.test2, "bar"))
            # Alternative way
            m.toModify(sp, test2 = EDAlias(xyzzy = VPSet(PSet(type = string("int")))))
            self.assertTrue(hasattr(sp.test2, "xyzzy"))
            # Replace an alias with EDProducer
            self.assertRaises(TypeError, lambda: m.toReplaceWith(sp.test2, EDProducer("Foo")))
            m.toModify(sp, test2 = EDProducer("Foo"))

testOptions()

def Config.TestModuleCommand.testOptions

(

self

)

Definition at line 3625 of file Config.py.

        def testOptions(self):
            p = Process('test')
            self.assertEqual(p.options.numberOfThreads.value(),1)
            p.options.numberOfThreads = 8
            self.assertEqual(p.options.numberOfThreads.value(),8)
            p.options = PSet()
            self.assertEqual(p.options.numberOfThreads.value(),1)
            p.options = dict(numberOfStreams =2,
                             numberOfThreads =2)
            self.assertEqual(p.options.numberOfThreads.value(),2)
            self.assertEqual(p.options.numberOfStreams.value(),2)
            del p.options
            self.assertRaises(TypeError, setattr, p, 'options', untracked.PSet(numberOfThreads = int32(-1)))
            p.options = untracked.PSet(numberOfThreads = untracked.uint32(4))
            self.assertEqual(p.options.numberOfThreads.value(), 4)

testOverride()

def Config.TestModuleCommand.testOverride

(

self

)

Definition at line 3602 of file Config.py.

        def testOverride(self):
            p = Process('test')
            a = EDProducer("A", a1=int32(0))
            self.assertTrue(not a.isModified())
            a.a1 = 1
            self.assertTrue(a.isModified())
            p.a = a
            self.assertEqual(p.a.a1.value(), 1)
            # try adding an unmodified module.
            # should accept it
            p.a = EDProducer("A", a1=int32(2))
            self.assertEqual(p.a.a1.value(), 2)
            # try adding a modified module.  Should throw
            # no longer, since the same (modified) say, geometry
            # could come from more than one cff
            b = EDProducer("A", a1=int32(3))
            b.a1 = 4
            #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
            ps1 = PSet(a = int32(1))
            ps2 = PSet(a = int32(2))
            self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
            self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
        

testParameterizable()

def Config.TestModuleCommand.testParameterizable

(

self

)

Definition at line 2289 of file Config.py.

        def testParameterizable(self):
            p = _Parameterizable()
            self.assertEqual(len(p.parameterNames_()),0)
            p.a = int32(1)
            self.assertTrue('a' in p.parameterNames_())
            self.assertEqual(p.a.value(), 1)
            p.a = 10
            self.assertEqual(p.a.value(), 10)
            p.a = untracked(int32(1))
            self.assertEqual(p.a.value(), 1)
            self.assertFalse(p.a.isTracked())
            p.a = untracked.int32(1)
            self.assertEqual(p.a.value(), 1)
            self.assertFalse(p.a.isTracked())
            p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
            self.assertEqual(p.foo.value(), 10)
            self.assertEqual(p.bar.value(),1.0)
            self.assertFalse(p.bar.isTracked())
            self.assertRaises(TypeError,setattr,(p,'c',1))
            p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
            self.assertEqual(p.a.foo.value(),10)
            self.assertEqual(p.a.bar.value(),1.0)
            p.b = untracked(PSet(fii = int32(1)))
            self.assertEqual(p.b.fii.value(),1)
            self.assertFalse(p.b.isTracked())
            #test the fact that values can be shared
            v = int32(10)
            p=_Parameterizable(a=v)
            v.setValue(11)
            self.assertEqual(p.a.value(),11)
            p.a = 12
            self.assertEqual(p.a.value(),12)
            self.assertEqual(v.value(),12)

testPath()

def Config.TestModuleCommand.testPath

(

self

)

Definition at line 3263 of file Config.py.

References SequenceTypes.ignore(), and str.

        def testPath(self):
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            path = Path(p.a)
            path *= p.b
            path += p.c
            self.assertEqual(str(path),'a+b+c')
            path = Path(p.a*p.b+p.c)
            self.assertEqual(str(path),'a+b+c')
#            path = Path(p.a)*p.b+p.c #This leads to problems with sequences
#            self.assertEqual(str(path),'((a*b)+c)')
            path = Path(p.a+ p.b*p.c)
            self.assertEqual(str(path),'a+b+c')
            path = Path(p.a*(p.b+p.c))
            self.assertEqual(str(path),'a+b+c')
            path = Path(p.a*(p.b+~p.c))
            pathx = Path(p.a*(p.b+ignore(p.c)))
            self.assertEqual(str(path),'a+b+~c')
            p.es = ESProducer("AnESProducer")
            self.assertRaises(TypeError,Path,p.es)

            t = Path()
            self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path()\n')

            t = Path(p.a)
            self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a)\n')

            t = Path(Task())
            self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(cms.Task())\n')

            t = Path(p.a, Task())
            self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.Task())\n')

            p.prod = EDProducer("prodName")
            p.t1 = Task(p.prod)
            t = Path(p.a, p.t1, Task(), p.t1)
            self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.Task(), process.t1)\n')

            t = Path(ConditionalTask())
            self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(cms.ConditionalTask())\n')

            t = Path(p.a, ConditionalTask())
            self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.ConditionalTask())\n')

            p.prod = EDProducer("prodName")
            p.t1 = ConditionalTask(p.prod)
            t = Path(p.a, p.t1, Task(), p.t1)
            self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.Task(), process.t1)\n')

testPrefers()

def Config.TestModuleCommand.testPrefers

(

self

)

Definition at line 3671 of file Config.py.

References Config._lineDiff(), and ConfigBuilder.dumpPython().

        def testPrefers(self):
            p = Process("Test")
            p.add_(ESSource("ForceSource"))
            p.juicer = ESProducer("JuicerProducer")
            p.prefer("ForceSource")
            p.prefer("juicer")
            self.assertEqual(_lineDiff(p.dumpPython(), Process('Test').dumpPython()),
"""process.juicer = cms.ESProducer("JuicerProducer")
process.ForceSource = cms.ESSource("ForceSource")
process.prefer("ForceSource")
process.prefer("juicer")""")
            p.prefer("juicer",fooRcd=vstring("Foo"))
            self.assertEqual(_lineDiff(p.dumpPython(), Process('Test').dumpPython()),
"""process.juicer = cms.ESProducer("JuicerProducer")
process.ForceSource = cms.ESSource("ForceSource")
process.prefer("ForceSource")
process.prefer("juicer",
    fooRcd = cms.vstring('Foo')
)""")

testProcessAccelerator()

def Config.TestModuleCommand.testProcessAccelerator

(

self

)

Definition at line 4648 of file Config.py.

References ALCARECOTkAlBeamHalo_cff.filter, and Config.TestModuleCommand.maxDiff.

        def testProcessAccelerator(self):
            proc = Process("TEST")
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertTrue(["cpu"], p.values["@available_accelerators"][1])
            self.assertFalse(p.values["@selected_accelerators"][0])
            self.assertTrue(["cpu"], p.values["@selected_accelerators"][1])
            self.assertFalse(p.values["@module_type_resolver"][0])
            self.assertEqual("", p.values["@module_type_resolver"][1])

            proc = Process("TEST")
            self.assertRaises(TypeError, setattr, proc, "processAcceleratorTest", ProcessAcceleratorTest())
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            del proc.MessageLogger # remove boilerplate unnecessary for this test case
            self.maxDiff = None
            self.assertEqual(proc.dumpPython(),
"""import FWCore.ParameterSet.Config as cms
from test import ProcessAcceleratorTest

process = cms.Process("TEST")

process.maxEvents = cms.untracked.PSet(
    input = cms.optional.untracked.int32,
    output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
)

process.maxLuminosityBlocks = cms.untracked.PSet(
    input = cms.untracked.int32(-1)
)

process.options = cms.untracked.PSet(
    IgnoreCompletely = cms.untracked.vstring(),
    Rethrow = cms.untracked.vstring(),
    TryToContinue = cms.untracked.vstring(),
    accelerators = cms.untracked.vstring('*'),
    allowUnscheduled = cms.obsolete.untracked.bool,
    canDeleteEarly = cms.untracked.vstring(),
    deleteNonConsumedUnscheduledModules = cms.untracked.bool(True),
    dumpOptions = cms.untracked.bool(False),
    emptyRunLumiMode = cms.obsolete.untracked.string,
    eventSetup = cms.untracked.PSet(
        forceNumberOfConcurrentIOVs = cms.untracked.PSet(
            allowAnyLabel_=cms.required.untracked.uint32
        ),
        numberOfConcurrentIOVs = cms.untracked.uint32(0)
    ),
    fileMode = cms.untracked.string('FULLMERGE'),
    forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False),
    holdsReferencesToDeleteEarly = cms.untracked.VPSet(),
    makeTriggerResults = cms.obsolete.untracked.bool,
    modulesToCallForTryToContinue = cms.untracked.vstring(),
    modulesToIgnoreForDeleteEarly = cms.untracked.vstring(),
    numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0),
    numberOfConcurrentRuns = cms.untracked.uint32(1),
    numberOfStreams = cms.untracked.uint32(0),
    numberOfThreads = cms.untracked.uint32(1),
    printDependencies = cms.untracked.bool(False),
    sizeOfStackForThreadsInKB = cms.optional.untracked.uint32,
    throwIfIllegalParameter = cms.untracked.bool(True),
    wantSummary = cms.untracked.bool(False)
)

process.ProcessAcceleratorTest = ProcessAcceleratorTest(
    enabled = ['test1', 'test2', 'anothertest3']
)


""")
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual(["*"], p.values["options"][1].values["accelerators"][1])
            self.assertFalse(p.values["options"][1].values["accelerators"][0])
            self.assertTrue(["anothertest3", "cpu", "test1", "test2"], p.values["@selected_accelerators"][1])
            self.assertEqual("AcceleratorTestService", p.values["services"][1][0].values["@service_type"][1])
            self.assertFalse(p.values["@available_accelerators"][0])
            self.assertTrue(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
            self.assertFalse(p.values["@module_type_resolver"][0])
            self.assertEqual("", p.values["@module_type_resolver"][1])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.add_(Service("AcceleratorTestServiceRemove"))
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            services = [x.values["@service_type"][1] for x in p.values["services"][1]]
            self.assertTrue("AcceleratorTestService" in services)
            self.assertFalse("AcceleratorTestServiceRemove" in services)

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest(enabled=["test1"])
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual(["cpu", "test1"], p.values["@selected_accelerators"][1])
            self.assertEqual(["cpu", "test1"], p.values["@available_accelerators"][1])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.options.accelerators = ["test2"]
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual(["test2"], p.values["@selected_accelerators"][1])
            self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.options.accelerators = ["test*"]
            proc.fillProcessDesc(p)
            self.assertEqual(["test1", "test2"], p.values["@selected_accelerators"][1])
            self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest(enabled=["test1"])
            proc.options.accelerators = ["test2"]
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual([], p.values["@selected_accelerators"][1])
            self.assertEqual(["cpu", "test1"], p.values["@available_accelerators"][1])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.options.accelerators = ["cpu*"]
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual(["cpu"], p.values["@selected_accelerators"][1])
            self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.options.accelerators = ["test3"]
            p = TestMakePSet()
            self.assertRaises(ValueError, proc.fillProcessDesc, p)

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.options.accelerators = ["*", "test1"]
            p = TestMakePSet()
            self.assertRaises(ValueError, proc.fillProcessDesc, p)

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.ProcessAcceleratorTest2 = ProcessAcceleratorTest2()
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual(["anothertest3", "anothertest4", "cpu", "test1", "test2"], p.values["@selected_accelerators"][1])
            self.assertEqual(["anothertest3", "anothertest4", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.ProcessAcceleratorTest2 = ProcessAcceleratorTest2()
            proc.options.accelerators = ["*test3", "c*"]
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual(["anothertest3", "cpu"], p.values["@selected_accelerators"][1])
            self.assertEqual(["anothertest3", "anothertest4", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
                                                             a = int32(1),
                                                             b = PSet(c = int32(2))),
                                          test1 = EDProducer("Bar",
                                                             aa = int32(11),
                                                             bb = PSet(cc = int32(12))))
            proc.p = Path(proc.sp)
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest(enabled=["test1"])
            proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
                                                             a = int32(1),
                                                             b = PSet(c = int32(2))),
                                          test1 = EDProducer("Bar",
                                                             aa = int32(11),
                                                             bb = PSet(cc = int32(12))))
            proc.p = Path(proc.sp)
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual((False, "sp@test1"), p.values["sp"][1].values["@chosen_case"])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.options.accelerators = ["test1"]
            proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
                                                             a = int32(1),
                                                             b = PSet(c = int32(2))),
                                          test1 = EDProducer("Bar",
                                                             aa = int32(11),
                                                             bb = PSet(cc = int32(12))))
            proc.p = Path(proc.sp)
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual((False, "sp@test1"), p.values["sp"][1].values["@chosen_case"])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.options.accelerators = ["test*"]
            proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
                                                             a = int32(1),
                                                             b = PSet(c = int32(2))),
                                          test1 = EDProducer("Bar",
                                                             aa = int32(11),
                                                             bb = PSet(cc = int32(12))))
            proc.p = Path(proc.sp)
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.options.accelerators = ["anothertest3"]
            proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
                                                             a = int32(1),
                                                             b = PSet(c = int32(2))),
                                          test1 = EDProducer("Bar",
                                                             aa = int32(11),
                                                             bb = PSet(cc = int32(12))))
            proc.p = Path(proc.sp)
            p = TestMakePSet()
            self.assertRaises(RuntimeError, proc.fillProcessDesc, p)

            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest(
                moduleTypeResolverMaker=lambda accelerators: TestModuleTypeResolver(accelerators))
            proc.ProcessAcceleratorTest2 = ProcessAcceleratorTest2()
            proc.normalProducer = EDProducer("FooProducer")
            proc.testProducer = EDProducer("BarProducer@test")
            proc.test2Producer = EDProducer("BarProducer@test", test=untracked.PSet(backend=untracked.string("test2_backend")))
            proc.testAnalyzer = EDAnalyzer("Analyzer@test")
            proc.testFilter = EDAnalyzer("Filter@test")
            proc.testESProducer = ESProducer("ESProducer@test")
            proc.testESSource = ESSource("ESSource@test")
            proc.p = Path(proc.normalProducer+proc.testProducer+proc.test2Producer+proc.testAnalyzer+proc.testFilter)
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual("TestModuleTypeResolver", p.values["@module_type_resolver"][1])
            self.assertEqual("FooProducer", p.values["normalProducer"][1].values["@module_type"][1])
            self.assertEqual(len(list(filter(lambda x: not "@" in x, p.values["normalProducer"][1].values.keys()))), 0)
            self.assertEqual("BarProducer@test", p.values["testProducer"][1].values["@module_type"][1])
            self.assertEqual(False, p.values["testProducer"][1].values["test"][0])
            self.assertEqual(False, p.values["testProducer"][1].values["test"][1].values["backend"][0])
            self.assertEqual("test1_backend", p.values["testProducer"][1].values["test"][1].values["backend"][1])
            self.assertEqual("BarProducer@test", p.values["test2Producer"][1].values["@module_type"][1])
            self.assertEqual("test2_backend", p.values["test2Producer"][1].values["test"][1].values["backend"][1])
            self.assertEqual("Analyzer@test", p.values["testAnalyzer"][1].values["@module_type"][1])
            self.assertEqual("test1_backend", p.values["testAnalyzer"][1].values["test"][1].values["backend"][1])
            self.assertEqual("Filter@test", p.values["testFilter"][1].values["@module_type"][1])
            self.assertEqual("test1_backend", p.values["testFilter"][1].values["test"][1].values["backend"][1])
            self.assertEqual("ESProducer@test", p.values["ESProducer@test@testESProducer"][1].values["@module_type"][1])
            self.assertEqual("test1_backend", p.values["ESProducer@test@testESProducer"][1].values["test"][1].values["backend"][1])
            self.assertEqual("ESSource@test", p.values["ESSource@test@testESSource"][1].values["@module_type"][1])
            self.assertEqual("test1_backend", p.values["ESSource@test@testESSource"][1].values["test"][1].values["backend"][1])

            # No required accelerators available
            proc = Process("Test")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest(
                moduleTypeResolverMaker=lambda accelerators: TestModuleTypeResolver(accelerators))
            proc.options.accelerators = []
            self.assertRaises(EDMException, proc.fillProcessDesc, p)

            proc = Process("Test")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest(
                moduleTypeResolverMaker=lambda accelerators: TestModuleTypeResolver(accelerators))
            proc.options.accelerators = ["test1"]
            proc.test2Producer = EDProducer("BarProducer@test", test=untracked.PSet(backend=untracked.string("test2_backend")))
            proc.p = Path(proc.test2Producer)
            self.assertRaises(EDMException, proc.fillProcessDesc, p)

            # Two ProcessAccelerators return type resolver
            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest(
                moduleTypeResolverMaker=lambda accelerators: TestModuleTypeResolver(accelerators))
            proc.ProcessAcceleratorTest2 = ProcessAcceleratorTest2(
                moduleTypeResolverMaker=lambda accelerators: TestModuleTypeResolver(accelerators))
            p = TestMakePSet()
            self.assertRaises(RuntimeError, proc.fillProcessDesc, p)

            import pickle
            proc = Process("TEST")
            proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
            proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
                                                             a = int32(1),
                                                             b = PSet(c = int32(2))),
                                          test1 = EDProducer("Bar",
                                                             aa = int32(11),
                                                             bb = PSet(cc = int32(12))))
            proc.p = Path(proc.sp)
            pkl = pickle.dumps(proc)
            unpkl = pickle.loads(pkl)
            p = TestMakePSet()
            unpkl.fillProcessDesc(p)
            self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
            self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
            unpkl = pickle.loads(pkl)
            unpkl.ProcessAcceleratorTest.setEnabled(["test1"])
            p = TestMakePSet()
            unpkl.fillProcessDesc(p)
            self.assertEqual((False, "sp@test1"), p.values["sp"][1].values["@chosen_case"])
            self.assertEqual(["cpu", "test1"], p.values["@available_accelerators"][1])

    unittest.main()

testProcessDumpPython()

def Config.TestModuleCommand.testProcessDumpPython

(

self

)

Definition at line 2449 of file Config.py.

        def testProcessDumpPython(self):
            self.maxDiff = None
            self.assertEqual(Process("test").dumpPython(),
"""import FWCore.ParameterSet.Config as cms

process = cms.Process("test")

process.maxEvents = cms.untracked.PSet(
    input = cms.optional.untracked.int32,
    output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
)

process.maxLuminosityBlocks = cms.untracked.PSet(
    input = cms.untracked.int32(-1)
)

process.options = cms.untracked.PSet(
    IgnoreCompletely = cms.untracked.vstring(),
    Rethrow = cms.untracked.vstring(),
    TryToContinue = cms.untracked.vstring(),
    accelerators = cms.untracked.vstring('*'),
    allowUnscheduled = cms.obsolete.untracked.bool,
    canDeleteEarly = cms.untracked.vstring(),
    deleteNonConsumedUnscheduledModules = cms.untracked.bool(True),
    dumpOptions = cms.untracked.bool(False),
    emptyRunLumiMode = cms.obsolete.untracked.string,
    eventSetup = cms.untracked.PSet(
        forceNumberOfConcurrentIOVs = cms.untracked.PSet(
            allowAnyLabel_=cms.required.untracked.uint32
        ),
        numberOfConcurrentIOVs = cms.untracked.uint32(0)
    ),
    fileMode = cms.untracked.string('FULLMERGE'),
    forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False),
    holdsReferencesToDeleteEarly = cms.untracked.VPSet(),
    makeTriggerResults = cms.obsolete.untracked.bool,
    modulesToCallForTryToContinue = cms.untracked.vstring(),
    modulesToIgnoreForDeleteEarly = cms.untracked.vstring(),
    numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0),
    numberOfConcurrentRuns = cms.untracked.uint32(1),
    numberOfStreams = cms.untracked.uint32(0),
    numberOfThreads = cms.untracked.uint32(1),
    printDependencies = cms.untracked.bool(False),
    sizeOfStackForThreadsInKB = cms.optional.untracked.uint32,
    throwIfIllegalParameter = cms.untracked.bool(True),
    wantSummary = cms.untracked.bool(False)
)

process.MessageLogger = cms.Service("MessageLogger",
    cerr = cms.untracked.PSet(
        FwkReport = cms.untracked.PSet(
            limit = cms.untracked.int32(10000000),
            reportEvery = cms.untracked.int32(1)
        ),
        FwkSummary = cms.untracked.PSet(
            limit = cms.untracked.int32(10000000),
            reportEvery = cms.untracked.int32(1)
        ),
        INFO = cms.untracked.PSet(
            limit = cms.untracked.int32(0)
        ),
        Root_NoDictionary = cms.untracked.PSet(
            limit = cms.untracked.int32(0)
        ),
        default = cms.untracked.PSet(
            limit = cms.untracked.int32(10000000)
        ),
        enable = cms.untracked.bool(True),
        enableStatistics = cms.untracked.bool(False),
        lineLength = cms.optional.untracked.int32,
        noLineBreaks = cms.optional.untracked.bool,
        noTimeStamps = cms.untracked.bool(False),
        resetStatistics = cms.untracked.bool(False),
        statisticsThreshold = cms.untracked.string('WARNING'),
        threshold = cms.untracked.string('INFO'),
        allowAnyLabel_=cms.optional.untracked.PSetTemplate(
            limit = cms.optional.untracked.int32,
            reportEvery = cms.untracked.int32(1),
            timespan = cms.optional.untracked.int32
        )
    ),
    cout = cms.untracked.PSet(
        enable = cms.untracked.bool(False),
        enableStatistics = cms.untracked.bool(False),
        lineLength = cms.optional.untracked.int32,
        noLineBreaks = cms.optional.untracked.bool,
        noTimeStamps = cms.optional.untracked.bool,
        resetStatistics = cms.untracked.bool(False),
        statisticsThreshold = cms.optional.untracked.string,
        threshold = cms.optional.untracked.string,
        allowAnyLabel_=cms.optional.untracked.PSetTemplate(
            limit = cms.optional.untracked.int32,
            reportEvery = cms.untracked.int32(1),
            timespan = cms.optional.untracked.int32
        )
    ),
    debugModules = cms.untracked.vstring(),
    default = cms.untracked.PSet(
        limit = cms.optional.untracked.int32,
        lineLength = cms.untracked.int32(80),
        noLineBreaks = cms.untracked.bool(False),
        noTimeStamps = cms.untracked.bool(False),
        reportEvery = cms.untracked.int32(1),
        statisticsThreshold = cms.untracked.string('INFO'),
        threshold = cms.untracked.string('INFO'),
        timespan = cms.optional.untracked.int32,
        allowAnyLabel_=cms.optional.untracked.PSetTemplate(
            limit = cms.optional.untracked.int32,
            reportEvery = cms.untracked.int32(1),
            timespan = cms.optional.untracked.int32
        )
    ),
    files = cms.untracked.PSet(
        allowAnyLabel_=cms.optional.untracked.PSetTemplate(
            enableStatistics = cms.untracked.bool(False),
            extension = cms.optional.untracked.string,
            filename = cms.optional.untracked.string,
            lineLength = cms.optional.untracked.int32,
            noLineBreaks = cms.optional.untracked.bool,
            noTimeStamps = cms.optional.untracked.bool,
            output = cms.optional.untracked.string,
            resetStatistics = cms.untracked.bool(False),
            statisticsThreshold = cms.optional.untracked.string,
            threshold = cms.optional.untracked.string,
            allowAnyLabel_=cms.optional.untracked.PSetTemplate(
                limit = cms.optional.untracked.int32,
                reportEvery = cms.untracked.int32(1),
                timespan = cms.optional.untracked.int32
            )
        )
    ),
    suppressDebug = cms.untracked.vstring(),
    suppressFwkInfo = cms.untracked.vstring(),
    suppressInfo = cms.untracked.vstring(),
    suppressWarning = cms.untracked.vstring(),
    allowAnyLabel_=cms.optional.untracked.PSetTemplate(
        limit = cms.optional.untracked.int32,
        reportEvery = cms.untracked.int32(1),
        timespan = cms.optional.untracked.int32
    )
)


""")
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.p = Path(p.a)
            p.s = Sequence(p.a)
            p.r = Sequence(p.s)
            p.p2 = Path(p.s)
            p.schedule = Schedule(p.p2,p.p)
            d=p.dumpPython()
            self.assertEqual(_lineDiff(d,Process("test").dumpPython()),
"""process.a = cms.EDAnalyzer("MyAnalyzer")
process.s = cms.Sequence(process.a)
process.r = cms.Sequence(process.s)
process.p = cms.Path(process.a)
process.p2 = cms.Path(process.s)
process.schedule = cms.Schedule(*[ process.p2, process.p ])""")
            #Reverse order of 'r' and 's'
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.p = Path(p.a)
            p.r = Sequence(p.a)
            p.s = Sequence(p.r)
            p.p2 = Path(p.r)
            p.schedule = Schedule(p.p2,p.p)
            p.b = EDAnalyzer("YourAnalyzer")
            d=p.dumpPython()
            self.assertEqual(_lineDiff(d,Process("test").dumpPython()),
"""process.a = cms.EDAnalyzer("MyAnalyzer")
process.b = cms.EDAnalyzer("YourAnalyzer")
process.r = cms.Sequence(process.a)
process.s = cms.Sequence(process.r)
process.p = cms.Path(process.a)
process.p2 = cms.Path(process.r)
process.schedule = cms.Schedule(*[ process.p2, process.p ])""")

testProcessExtend()

def Config.TestModuleCommand.testProcessExtend

(

self

)

Definition at line 2354 of file Config.py.

References submitPVValidationJobs.__init__(), default_text_conditions_cfi.object, and str.

        def testProcessExtend(self):
            class FromArg(object):
                def __init__(self,*arg,**args):
                    for name in args.keys():
                        self.__dict__[name]=args[name]

            a=EDAnalyzer("MyAnalyzer")
            t=EDAnalyzer("MyAnalyzer")
            t.setLabel("foo")
            s1 = Sequence(a)
            s2 = Sequence(s1)
            s3 = Sequence(s2)
            d = FromArg(
                    a=a,
                    b=Service("Full"),
                    c=Path(a),
                    d=s2,
                    e=s1,
                    f=s3,
                    g=Sequence(s1+s2+s3)
                )
            p = Process("Test")
            p.extend(d)
            self.assertEqual(p.a.type_(),"MyAnalyzer")
            self.assertEqual(p.a.label_(),"a")
            self.assertRaises(AttributeError,getattr,p,'b')
            self.assertEqual(p.Full.type_(),"Full")
            self.assertEqual(str(p.c),'a')
            self.assertEqual(str(p.d),'a')

            z1 = FromArg(
                    a=a,
                    b=Service("Full"),
                    c=Path(a),
                    d=s2,
                    e=s1,
                    f=s3,
                    s4=s3,
                    g=Sequence(s1+s2+s3)
                 )

            p1 = Process("Test")
            #p1.extend(z1)
            self.assertRaises(ValueError, p1.extend, z1)

            z2 = FromArg(
                    a=a,
                    b=Service("Full"),
                    c=Path(a),
                    d=s2,
                    e=s1,
                    f=s3,
                    aaa=copy.deepcopy(a),
                    s4=copy.deepcopy(s3),
                    g=Sequence(s1+s2+s3),
                    t=t
                )
            p2 = Process("Test")
            p2.extend(z2)
            #self.assertRaises(ValueError, p2.extend, z2)
            self.assertEqual(p2.s4.label_(),"s4")
            #p2.s4.setLabel("foo")
            self.assertRaises(ValueError, p2.s4.setLabel, "foo")
            p2.s4.setLabel("s4")
            p2.s4.setLabel(None)
            p2.s4.setLabel("foo")
            p2._Process__setObjectLabel(p2.s4, "foo")
            p2._Process__setObjectLabel(p2.s4, None)
            p2._Process__setObjectLabel(p2.s4, "bar")


            p = Process('test')
            p.a = EDProducer("MyProducer")
            p.t = Task(p.a)
            p.p = Path(p.t)
            self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
            self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
            self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())

            p = Process('test')
            p.a = EDProducer("MyProducer")
            p.t = ConditionalTask(p.a)
            p.p = Path(p.t)
            self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
            self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
            self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())

            p = Process('test')
            p.a = EDProducer("MyProducer")
            p.s = Sequence(p.a)
            p.p = Path(p.s)
            self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
            self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
            self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())

testProcessForProcessAccelerator()

def Config.TestModuleCommand.testProcessForProcessAccelerator

(

self

)

Definition at line 4634 of file Config.py.

        def testProcessForProcessAccelerator(self):
            proc = Process("TEST")
            p = ProcessForProcessAccelerator(proc)
            p.TestService = Service("TestService")
            self.assertTrue(hasattr(proc, "TestService"))
            self.assertEqual(proc.TestService.type_(), "TestService")
            self.assertRaises(TypeError, setattr, p, "a", EDProducer("Foo"))
            p.add_(Service("TestServiceTwo"))
            self.assertTrue(hasattr(proc, "TestServiceTwo"))
            self.assertEqual(proc.TestServiceTwo.type_(), "TestServiceTwo")
            p.TestService.foo = untracked.uint32(42)
            self.assertEqual(proc.TestService.foo.value(), 42)
            proc.mod = EDProducer("Producer")
            self.assertRaises(TypeError, getattr, p, "mod")

testProcessFragment()

def Config.TestModuleCommand.testProcessFragment

(

self

)

Definition at line 4617 of file Config.py.

        def testProcessFragment(self):
            #check defaults are not overwritten
            f = ProcessFragment('Fragment')
            p = Process('PROCESS')
            p.maxEvents.input = 10
            p.options.numberOfThreads = 4
            p.maxLuminosityBlocks.input = 2
            p.extend(f)
            self.assertEqual(p.maxEvents.input.value(),10)
            self.assertEqual(p.options.numberOfThreads.value(), 4)
            self.assertEqual(p.maxLuminosityBlocks.input.value(),2)
            #general checks
            f = ProcessFragment("Fragment")
            f.fltr = EDFilter("Foo")
            p = Process('PROCESS')
            p.extend(f)
            self.assertTrue(hasattr(p,'fltr'))

testProcessInsertion()

def Config.TestModuleCommand.testProcessInsertion

(

self

)

Definition at line 2329 of file Config.py.

        def testProcessInsertion(self):
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            self.assertTrue( 'a' in p.analyzers_() )
            self.assertTrue( 'a' in p.analyzers)
            p.add_(Service("SomeService"))
            self.assertTrue('SomeService' in p.services_())
            self.assertEqual(p.SomeService.type_(), "SomeService")
            p.Tracer = Service("Tracer")
            self.assertTrue('Tracer' in p.services_())
            self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
            self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
            self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
            p.out = OutputModule("Outer")
            self.assertEqual(p.out.type_(), 'Outer')
            self.assertTrue( 'out' in p.outputModules_() )

            p.geom = ESSource("GeomProd")
            self.assertTrue('geom' in p.es_sources_())
            p.add_(ESSource("ConfigDB"))
            self.assertTrue('ConfigDB' in p.es_sources_())

            p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
            self.assertTrue('aliasfoo1' in p.aliases_())

testPrune()

def Config.TestModuleCommand.testPrune

(

self

)

Definition at line 3868 of file Config.py.

        def testPrune(self):
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.d = EDAnalyzer("OurAnalyzer")
            p.e = EDProducer("MyProducer")
            p.f = EDProducer("YourProducer")
            p.g = EDProducer("TheirProducer")
            p.h = EDProducer("OnesProducer")
            p.s = Sequence(p.d)
            p.t1 = Task(p.e)
            p.t2 = Task(p.f)
            p.t3 = Task(p.g, p.t1)
            p.ct1 = ConditionalTask(p.h)
            p.ct2 = ConditionalTask(p.f)
            p.ct3 = ConditionalTask(p.ct1)
            p.path1 = Path(p.a, p.t3, p.ct3)
            p.path2 = Path(p.b)
            self.assertTrue(p.schedule is None)
            pths = p.paths
            keys = pths.keys()
            self.assertEqual(pths[keys[0]],p.path1)
            self.assertEqual(pths[keys[1]],p.path2)
            p.pset1 = PSet(parA = string("pset1"))
            p.pset2 = untracked.PSet(parA = string("pset2"))
            p.vpset1 = VPSet()
            p.vpset2 = untracked.VPSet()
            p.prune()
            self.assertTrue(hasattr(p, 'a'))
            self.assertTrue(hasattr(p, 'b'))
            self.assertTrue(not hasattr(p, 'c'))
            self.assertTrue(not hasattr(p, 'd'))
            self.assertTrue(hasattr(p, 'e'))
            self.assertTrue(not hasattr(p, 'f'))
            self.assertTrue(hasattr(p, 'g'))
            self.assertTrue(hasattr(p, 'h'))
            self.assertTrue(not hasattr(p, 's'))
            self.assertTrue(hasattr(p, 't1'))
            self.assertTrue(not hasattr(p, 't2'))
            self.assertTrue(hasattr(p, 't3'))
            self.assertTrue(hasattr(p, 'path1'))
            self.assertTrue(hasattr(p, 'path2'))
#            self.assertTrue(not hasattr(p, 'pset1'))
#            self.assertTrue(hasattr(p, 'pset2'))
#            self.assertTrue(not hasattr(p, 'vpset1'))
#            self.assertTrue(not hasattr(p, 'vpset2'))

            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.d = EDAnalyzer("OurAnalyzer")
            p.e = EDAnalyzer("OurAnalyzer")
            p.f = EDProducer("MyProducer")
            p.g = EDProducer("YourProducer")
            p.h = EDProducer("TheirProducer")
            p.i = EDProducer("OurProducer")
            p.j = EDProducer("OurProducer")
            p.k = EDProducer("OurProducer")
            p.l = EDProducer("OurProducer")
            p.t1 = Task(p.f)
            p.t2 = Task(p.g)
            p.t3 = Task(p.h)
            p.t4 = Task(p.i)
            p.ct1 = Task(p.f)
            p.ct2 = Task(p.j)
            p.ct3 = Task(p.k)
            p.ct4 = Task(p.l)
            p.s = Sequence(p.d, p.t1, p.ct1)
            p.s2 = Sequence(p.b, p.t2, p.ct2)
            p.s3 = Sequence(p.e)
            p.path1 = Path(p.a, p.t3, p.ct3)
            p.path2 = Path(p.b)
            p.path3 = Path(p.b+p.s2)
            p.path4 = Path(p.b+p.s3)
            p.schedule = Schedule(p.path1,p.path2,p.path3)
            p.schedule.associate(p.t4)
            pths = p.paths
            keys = pths.keys()
            self.assertEqual(pths[keys[0]],p.path1)
            self.assertEqual(pths[keys[1]],p.path2)
            p.prune()
            self.assertTrue(hasattr(p, 'a'))
            self.assertTrue(hasattr(p, 'b'))
            self.assertTrue(not hasattr(p, 'c'))
            self.assertTrue(not hasattr(p, 'd'))
            self.assertTrue(not hasattr(p, 'e'))
            self.assertTrue(not hasattr(p, 'f'))
            self.assertTrue(hasattr(p, 'g'))
            self.assertTrue(hasattr(p, 'h'))
            self.assertTrue(hasattr(p, 'i'))
            self.assertTrue(hasattr(p, 'j'))
            self.assertTrue(hasattr(p, 'k'))
            self.assertTrue(not hasattr(p, 'l'))
            self.assertTrue(not hasattr(p, 't1'))
            self.assertTrue(hasattr(p, 't2'))
            self.assertTrue(hasattr(p, 't3'))
            self.assertTrue(hasattr(p, 't4'))
            self.assertTrue(not hasattr(p, 'ct1'))
            self.assertTrue(hasattr(p, 'ct2'))
            self.assertTrue(hasattr(p, 'ct3'))
            self.assertTrue(not hasattr(p, 'ct4'))
            self.assertTrue(not hasattr(p, 's'))
            self.assertTrue(hasattr(p, 's2'))
            self.assertTrue(not hasattr(p, 's3'))
            self.assertTrue(hasattr(p, 'path1'))
            self.assertTrue(hasattr(p, 'path2'))
            self.assertTrue(hasattr(p, 'path3'))
            self.assertTrue(not hasattr(p, 'path4'))
            #test SequencePlaceholder
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.s = Sequence(SequencePlaceholder("a")+p.b)
            p.pth = Path(p.s)
            p.prune()
            self.assertTrue(hasattr(p, 'a'))
            self.assertTrue(hasattr(p, 'b'))
            self.assertTrue(hasattr(p, 's'))
            self.assertTrue(hasattr(p, 'pth'))
            #test unresolved SequencePlaceholder
            p = Process("test")
            p.b = EDAnalyzer("YourAnalyzer")
            p.s = Sequence(SequencePlaceholder("a")+p.b)
            p.pth = Path(p.s)
            p.prune(keepUnresolvedSequencePlaceholders=True)
            self.assertTrue(hasattr(p, 'b'))
            self.assertTrue(hasattr(p, 's'))
            self.assertTrue(hasattr(p, 'pth'))
            self.assertEqual(p.s.dumpPython(),'cms.Sequence(cms.SequencePlaceholder("a")+process.b)\n')
            #test TaskPlaceholder
            p = Process("test")
            p.a = EDProducer("MyProducer")
            p.b = EDProducer("YourProducer")
            p.s = Task(TaskPlaceholder("a"),p.b)
            p.pth = Path(p.s)
            p.prune()
            self.assertTrue(hasattr(p, 'a'))
            self.assertTrue(hasattr(p, 'b'))
            self.assertTrue(hasattr(p, 's'))
            self.assertTrue(hasattr(p, 'pth'))
            #test ConditionalTaskPlaceholder
            p = Process("test")
            p.a = EDProducer("MyProducer")
            p.b = EDProducer("YourProducer")
            p.s = ConditionalTask(ConditionalTaskPlaceholder("a"),p.b)
            p.pth = Path(p.s)
            p.prune()
            self.assertTrue(hasattr(p, 'a'))
            self.assertTrue(hasattr(p, 'b'))
            self.assertTrue(hasattr(p, 's'))
            self.assertTrue(hasattr(p, 'pth'))
            #test unresolved SequencePlaceholder
            p = Process("test")
            p.b = EDProducer("YourAnalyzer")
            p.s = Task(TaskPlaceholder("a"),p.b)
            p.pth = Path(p.s)
            p.prune(keepUnresolvedSequencePlaceholders=True)
            self.assertTrue(hasattr(p, 'b'))
            self.assertTrue(hasattr(p, 's'))
            self.assertTrue(hasattr(p, 'pth'))
            self.assertEqual(p.s.dumpPython(),'cms.Task(cms.TaskPlaceholder("a"), process.b)\n')

testRefToPSet()

def Config.TestModuleCommand.testRefToPSet

(

self

)

Definition at line 3744 of file Config.py.

        def testRefToPSet(self):
            proc = Process("test")
            proc.top = PSet(a = int32(1))
            proc.ref = PSet(refToPSet_ = string("top"))
            proc.ref2 = PSet( a = int32(1), b = PSet( refToPSet_ = string("top")))
            proc.ref3 = PSet(refToPSet_ = string("ref"))
            proc.ref4 = VPSet(PSet(refToPSet_ = string("top")),
                              PSet(refToPSet_ = string("ref2")))
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual((True,1),p.values["ref"][1].values["a"])
            self.assertEqual((True,1),p.values["ref3"][1].values["a"])
            self.assertEqual((True,1),p.values["ref2"][1].values["a"])
            self.assertEqual((True,1),p.values["ref2"][1].values["b"][1].values["a"])
            self.assertEqual((True,1),p.values["ref4"][1][0].values["a"])
            self.assertEqual((True,1),p.values["ref4"][1][1].values["a"])

testSchedule()

def Config.TestModuleCommand.testSchedule

(

self

)

Definition at line 3457 of file Config.py.

        def testSchedule(self):
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.d = EDAnalyzer("OurAnalyzer")
            p.path1 = Path(p.a)
            p.path2 = Path(p.b)
            p.path3 = Path(p.d)

            s = Schedule(p.path1,p.path2)
            self.assertEqual(s[0],p.path1)
            self.assertEqual(s[1],p.path2)
            p.schedule = s
            self.assertTrue('b' in p.schedule.moduleNames())
            self.assertTrue(hasattr(p, 'b'))
            self.assertTrue(hasattr(p, 'c'))
            self.assertTrue(hasattr(p, 'd'))
            self.assertTrue(hasattr(p, 'path1'))
            self.assertTrue(hasattr(p, 'path2'))
            self.assertTrue(hasattr(p, 'path3'))
            p.prune()
            self.assertTrue('b' in p.schedule.moduleNames())
            self.assertTrue(hasattr(p, 'b'))
            self.assertTrue(not hasattr(p, 'c'))
            self.assertTrue(not hasattr(p, 'd'))
            self.assertTrue(hasattr(p, 'path1'))
            self.assertTrue(hasattr(p, 'path2'))
            self.assertTrue(not hasattr(p, 'path3'))

            self.assertTrue(len(p.schedule._tasks) == 0)

            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.d = EDAnalyzer("dAnalyzer")
            p.e = EDProducer("eProducer")
            p.f = EDProducer("fProducer")
            p.Tracer = Service("Tracer")
            p.path1 = Path(p.a)
            p.path2 = Path(p.b)
            p.path3 = Path(p.d)
            p.task1 = Task(p.e)
            p.task2 = Task(p.f, p.Tracer)
            s = Schedule(p.path1,p.path2,tasks=[p.task1,p.task2,p.task1])
            self.assertEqual(s[0],p.path1)
            self.assertEqual(s[1],p.path2)
            self.assertTrue(len(s._tasks) == 2)
            self.assertTrue(p.task1 in s._tasks)
            self.assertTrue(p.task2 in s._tasks)
            listOfTasks = list(s._tasks)
            self.assertTrue(len(listOfTasks) == 2)
            self.assertTrue(p.task1 == listOfTasks[0])
            self.assertTrue(p.task2 == listOfTasks[1])
            p.schedule = s
            self.assertTrue('b' in p.schedule.moduleNames())

            process2 = Process("test")
            process2.a = EDAnalyzer("MyAnalyzer")
            process2.e = EDProducer("eProducer")
            process2.path1 = Path(process2.a)
            process2.task1 = Task(process2.e)
            process2.schedule = Schedule(process2.path1,tasks=process2.task1)
            listOfTasks = list(process2.schedule._tasks)
            self.assertTrue(listOfTasks[0] == process2.task1)

            # test Schedule copy
            s2 = s.copy()
            self.assertEqual(s2[0],p.path1)
            self.assertEqual(s2[1],p.path2)
            self.assertTrue(len(s2._tasks) == 2)
            self.assertTrue(p.task1 in s2._tasks)
            self.assertTrue(p.task2 in s2._tasks)
            listOfTasks = list(s2._tasks)
            self.assertTrue(len(listOfTasks) == 2)
            self.assertTrue(p.task1 == listOfTasks[0])
            self.assertTrue(p.task2 == listOfTasks[1])

            names = s.moduleNames()
            self.assertTrue(names == set(['a', 'b', 'e', 'Tracer', 'f']))
            #adding a path not attached to the Process should cause an exception
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            path1 = Path(p.a)
            s = Schedule(path1)
            self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )

            #make sure anonymous sequences work
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("MyOtherAnalyzer")
            p.c = EDProducer("MyProd")
            path1 = Path(p.c*Sequence(p.a+p.b))
            s = Schedule(path1)
            self.assertTrue('a' in s.moduleNames())
            self.assertTrue('b' in s.moduleNames())
            self.assertTrue('c' in s.moduleNames())
            p.path1 = path1
            p.schedule = s
            p.prune()
            self.assertTrue('a' in s.moduleNames())
            self.assertTrue('b' in s.moduleNames())
            self.assertTrue('c' in s.moduleNames())

testSecSource()

def Config.TestModuleCommand.testSecSource

(

self

)

Definition at line 2764 of file Config.py.

References Config._lineDiff(), and ConfigBuilder.dumpPython().

        def testSecSource(self):
            p = Process('test')
            p.a = SecSource("MySecSource")
            self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),'process.a = cms.SecSource("MySecSource")')

testSequence()

def Config.TestModuleCommand.testSequence

(

self

)

Definition at line 2840 of file Config.py.

References str.

        def testSequence(self):
            p = Process('test')
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.s = Sequence(p.a*p.b)
            self.assertEqual(str(p.s),'a+b')
            self.assertEqual(p.s.label_(),'s')
            path = Path(p.c+p.s)
            self.assertEqual(str(path),'c+a+b')
            p._validateSequence(path, 'p1')
            notInProcess = EDAnalyzer('NotInProcess')
            p2 = Path(p.c+p.s*notInProcess)
            self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')

testSequence2()

def Config.TestModuleCommand.testSequence2

(

self

)

Definition at line 2855 of file Config.py.

        def testSequence2(self):
            p = Process('test')
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            testseq = Sequence(p.a*p.b)
            p.s = testseq
            #p.y = testseq
            self.assertRaises(ValueError, p.__setattr__, "y", testseq) 

testServiceInProcess()

def Config.TestModuleCommand.testServiceInProcess

(

self

)

Definition at line 2865 of file Config.py.

        def testServiceInProcess(self):
            service = Service("d")
            self.assertFalse(service._inProcess)
            process = Process("test")
            process.d = service
            self.assertTrue(service._inProcess)
            service2 = Service("d")
            process.d = service2
            self.assertFalse(service._inProcess)
            self.assertTrue(service2._inProcess)
            del process.d
            self.assertFalse(service2._inProcess)

testSubProcess()

def Config.TestModuleCommand.testSubProcess

(

self

)

Definition at line 3709 of file Config.py.

References Config._lineDiff(), ConfigBuilder.dumpPython(), cond.hash, submitPVValidationJobs.split(), and str.

        def testSubProcess(self):
            process = Process("Parent")
            subProcess = Process("Child")
            subProcess.a = EDProducer("A")
            subProcess.p = Path(subProcess.a)
            subProcess.add_(Service("Foo"))
            process.addSubProcess(SubProcess(subProcess))
            d = process.dumpPython()
            equalD ="""parentProcess = process
process.a = cms.EDProducer("A")
process.Foo = cms.Service("Foo")
process.p = cms.Path(process.a)
childProcess = process
process = parentProcess
process.addSubProcess(cms.SubProcess(process = childProcess, SelectEvents = cms.untracked.PSet(
), outputCommands = cms.untracked.vstring()))"""
            equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcesses_()[0])))
            # SubProcesses are dumped before Services, so in order to
            # craft the dump of the Parent and Child manually the dump
            # of the Parent needs to be split at the MessageLogger
            # boundary (now when it is part of Process by default),
            # and insert the dump of the Child between the top part of
            # the Parent (before MessageLogger) and the bottom part of
            # the Parent (after and including MessageLogger)
            messageLoggerSplit = 'process.MessageLogger = cms.Service'
            parentDumpSplit = Process('Parent').dumpPython().split(messageLoggerSplit)
            childProcess = Process('Child')
            del childProcess.MessageLogger
            combinedDump = parentDumpSplit[0] + childProcess.dumpPython() + messageLoggerSplit + parentDumpSplit[1]
            self.assertEqual(_lineDiff(d, combinedDump), equalD)
            p = TestMakePSet()
            process.fillProcessDesc(p)
            self.assertEqual((True,['a']),p.values["subProcesses"][1][0].values["process"][1].values['@all_modules'])
            self.assertEqual((True,['p']),p.values["subProcesses"][1][0].values["process"][1].values['@paths'])
            self.assertEqual({'@service_type':(True,'Foo')}, p.values["subProcesses"][1][0].values["process"][1].values["services"][1][0].values)

testSwitchProducer()

def Config.TestModuleCommand.testSwitchProducer

(

self

)

Definition at line 3760 of file Config.py.

References jetUpdater_cfi.sort.

        def testSwitchProducer(self):
            proc = Process("test")
            proc.sp = SwitchProducerTest(test2 = EDProducer("Foo",
                                                            a = int32(1),
                                                            b = PSet(c = int32(2))),
                                         test1 = EDProducer("Bar",
                                                            aa = int32(11),
                                                            bb = PSet(cc = int32(12))))
            self.assertEqual(proc.sp.label_(), "sp")
            self.assertEqual(proc.sp.test1.label_(), "sp@test1")
            self.assertEqual(proc.sp.test2.label_(), "sp@test2")

            proc.a = EDProducer("A")
            proc.s = Sequence(proc.a + proc.sp)
            proc.t = Task(proc.a, proc.sp)
            proc.p = Path()
            proc.p.associate(proc.t)
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
            self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
            self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
            all_cases = copy.deepcopy(p.values["sp"][1].values["@all_cases"])
            all_cases[1].sort() # names of all cases come via dict, i.e. their order is undefined
            self.assertEqual((True, ["sp@test1", "sp@test2"]), all_cases)
            self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
            self.assertEqual(["a", "sp", "sp@test1", "sp@test2"], p.values["@all_modules"][1])
            self.assertEqual((True,"EDProducer"), p.values["sp@test1"][1].values["@module_edm_type"])
            self.assertEqual((True,"Bar"), p.values["sp@test1"][1].values["@module_type"])
            self.assertEqual((True,"EDProducer"), p.values["sp@test2"][1].values["@module_edm_type"])
            self.assertEqual((True,"Foo"), p.values["sp@test2"][1].values["@module_type"])
            dump = proc.dumpPython()
            self.assertEqual(dump.find('@'), -1)
            self.assertEqual(specialImportRegistry.getSpecialImports(), ["from test import SwitchProducerTest"])
            self.assertTrue(dump.find("\nfrom test import SwitchProducerTest\n") != -1)

            # EDAlias as non-chosen case
            proc = Process("test")
            proc.sp = SwitchProducerTest(test2 = EDProducer("Foo",
                                                            a = int32(1),
                                                            b = PSet(c = int32(2))),
                                         test1 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
            proc.a = EDProducer("A")
            proc.s = Sequence(proc.a + proc.sp)
            proc.t = Task(proc.a, proc.sp)
            proc.p = Path()
            proc.p.associate(proc.t)
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
            self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
            self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
            all_cases = copy.deepcopy(p.values["sp"][1].values["@all_cases"])
            all_cases[1].sort()
            self.assertEqual((True, ["sp@test1", "sp@test2"]), all_cases)
            self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
            self.assertEqual(["a", "sp", "sp@test2"], p.values["@all_modules"][1])
            self.assertEqual(["sp@test1"], p.values["@all_aliases"][1])
            self.assertEqual((True,"EDProducer"), p.values["sp@test2"][1].values["@module_edm_type"])
            self.assertEqual((True,"Foo"), p.values["sp@test2"][1].values["@module_type"])
            self.assertEqual((True,"EDAlias"), p.values["sp@test1"][1].values["@module_edm_type"])
            self.assertEqual((True,"Bar"), p.values["sp@test1"][1].values["a"][1][0].values["type"])

            # EDAlias as chosen case
            proc = Process("test")
            proc.sp = SwitchProducerTest(test1 = EDProducer("Foo",
                                                            a = int32(1),
                                                            b = PSet(c = int32(2))),
                                         test2 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
            proc.a = EDProducer("A")
            proc.s = Sequence(proc.a + proc.sp)
            proc.t = Task(proc.a, proc.sp)
            proc.p = Path()
            proc.p.associate(proc.t)
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
            self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
            self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
            self.assertEqual((True, ["sp@test1", "sp@test2"]), p.values["sp"][1].values["@all_cases"])
            self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
            self.assertEqual(["a", "sp", "sp@test1"], p.values["@all_modules"][1])
            self.assertEqual(["sp@test2"], p.values["@all_aliases"][1])
            self.assertEqual((True,"EDProducer"), p.values["sp@test1"][1].values["@module_edm_type"])
            self.assertEqual((True,"Foo"), p.values["sp@test1"][1].values["@module_type"])
            self.assertEqual((True,"EDAlias"), p.values["sp@test2"][1].values["@module_edm_type"])
            self.assertEqual((True,"Bar"), p.values["sp@test2"][1].values["a"][1][0].values["type"])

            # ConditionalTask
            proc = Process("test")
            proc.spct = SwitchProducerTest(test2 = EDProducer("Foo",
                                                              a = int32(1),
                                                              b = PSet(c = int32(2))),
                                           test1 = EDProducer("Bar",
                                                              aa = int32(11),
                                                              bb = PSet(cc = int32(12))),
                                           test3 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
            proc.spp = proc.spct.clone()
            proc.a = EDProducer("A")
            proc.ct = ConditionalTask(proc.spct)
            proc.p = Path(proc.a, proc.ct)
            proc.pp = Path(proc.a + proc.spp)
            p = TestMakePSet()
            proc.fillProcessDesc(p)
            self.assertEqual(["a", "spct", "spct@test1", "spct@test2", "spp", "spp@test1", "spp@test2"], p.values["@all_modules"][1])
            self.assertEqual(["a", "#", "spct", "spct@test1", "spct@test2", "@"], p.values["p"][1])
            self.assertEqual(["a", "spp", "#", "spp@test1", "spp@test2", "@"], p.values["pp"][1])

testTask()

def Config.TestModuleCommand.testTask

(

self

)

Definition at line 2878 of file Config.py.

        def testTask(self):

            # create some objects to use in tests
            edanalyzer = EDAnalyzer("a")
            edproducer = EDProducer("b")
            edproducer2 = EDProducer("b2")
            edproducer3 = EDProducer("b3")
            edproducer4 = EDProducer("b4")
            edproducer8 = EDProducer("b8")
            edproducer9 = EDProducer("b9")
            edfilter = EDFilter("c")
            service = Service("d")
            service3 = Service("d", v = untracked.uint32(3))
            essource = ESSource("e")
            esproducer = ESProducer("f")
            testTask2 = Task()

            # test adding things to Tasks
            testTask1 = Task(edproducer, edfilter)
            self.assertRaises(RuntimeError, testTask1.add, edanalyzer)
            testTask1.add(essource, service)
            testTask1.add(essource, esproducer)
            testTask1.add(testTask2)
            coll = testTask1._collection
            self.assertTrue(edproducer in coll)
            self.assertTrue(edfilter in coll)
            self.assertTrue(service in coll)
            self.assertTrue(essource in coll)
            self.assertTrue(esproducer in coll)
            self.assertTrue(testTask2 in coll)
            self.assertTrue(len(coll) == 6)
            self.assertTrue(len(testTask2._collection) == 0)

            taskContents = []
            for i in testTask1:
                taskContents.append(i)
            self.assertTrue(taskContents == [edproducer, edfilter, essource, service, esproducer, testTask2])

            # test attaching Task to Process
            process = Process("test")

            process.mproducer = edproducer
            process.mproducer2 = edproducer2
            process.mfilter = edfilter
            process.messource = essource
            process.mesproducer = esproducer
            process.d = service

            testTask3 = Task(edproducer, edproducer2)
            testTask1.add(testTask3)
            process.myTask1 = testTask1

            # test the validation that occurs when attaching a Task to a Process
            # first a case that passes, then one the fails on an EDProducer
            # then one that fails on a service
            l = set()
            visitor = NodeNameVisitor(l)
            testTask1.visit(visitor)
            self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
            l2 = testTask1.moduleNames
            self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))

            testTask4 = Task(edproducer3)
            l.clear()
            self.assertRaises(RuntimeError, testTask4.visit, visitor)
            try:
                process.myTask4 = testTask4
                self.assertTrue(False)
            except RuntimeError:
                pass

            testTask5 = Task(service3)
            l.clear()
            self.assertRaises(RuntimeError, testTask5.visit, visitor)
            try:
                process.myTask5 = testTask5
                self.assertTrue(False)
            except RuntimeError:
                pass

            process.d = service3
            process.myTask5 = testTask5

            # test placement into the Process and the tasks property
            expectedDict = { 'myTask1' : testTask1, 'myTask5' : testTask5 }
            expectedFixedDict = DictTypes.FixedKeysDict(expectedDict);
            self.assertTrue(process.tasks == expectedFixedDict)
            self.assertTrue(process.tasks['myTask1'] == testTask1)
            self.assertTrue(process.myTask1 == testTask1)

            # test replacing an EDProducer in a Task when calling __settattr__
            # for the EDProducer on the Process.
            process.mproducer2 = edproducer4
            process.d = service
            l = list()
            visitor1 = ModuleNodeVisitor(l)
            testTask1.visit(visitor1)
            l.sort(key=lambda mod: mod.__str__())
            expectedList = sorted([edproducer,essource,esproducer,service,edfilter,edproducer,edproducer4],key=lambda mod: mod.__str__())
            self.assertTrue(expectedList == l)
            process.myTask6 = Task()
            process.myTask7 = Task()
            process.mproducer8 = edproducer8
            process.myTask8 = Task(process.mproducer8)
            process.myTask6.add(process.myTask7)
            process.myTask7.add(process.myTask8)
            process.myTask1.add(process.myTask6)
            process.myTask8.add(process.myTask5)

            testDict = process._itemsInDependencyOrder(process.tasks)
            expectedLabels = ["myTask5", "myTask8", "myTask7", "myTask6", "myTask1"]
            expectedTasks = [process.myTask5, process.myTask8, process.myTask7, process.myTask6, process.myTask1]
            index = 0
            for testLabel, testTask in testDict.items():
                self.assertTrue(testLabel == expectedLabels[index])
                self.assertTrue(testTask == expectedTasks[index])
                index += 1

            pythonDump = testTask1.dumpPython(PrintOptions())


            expectedPythonDump = 'cms.Task(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer, process.mproducer2, process.myTask6)\n'
            self.assertTrue(pythonDump == expectedPythonDump)

            process.myTask5 = Task()
            process.myTask100 = Task()
            process.mproducer9 = edproducer9
            sequence1 = Sequence(process.mproducer8, process.myTask1, process.myTask5, testTask2, testTask3)
            sequence2 = Sequence(process.mproducer8 + process.mproducer9)
            process.sequence3 = Sequence((process.mproducer8 + process.mfilter))
            sequence4 = Sequence()
            process.path1 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+sequence4)
            process.path1.associate(process.myTask1, process.myTask5, testTask2, testTask3)
            process.path11 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+ sequence4,process.myTask1, process.myTask5, testTask2, testTask3, process.myTask100)
            process.path2 = Path(process.mproducer)
            process.path3 = Path(process.mproducer9+process.mproducer8,testTask2)

            self.assertTrue(process.path1.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer+process.mproducer8+cms.Sequence(process.mproducer8, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask5)+(process.mproducer8+process.mproducer9)+process.sequence3, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask5)\n')

            self.assertTrue(process.path11.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer+process.mproducer8+cms.Sequence(process.mproducer8, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask5)+(process.mproducer8+process.mproducer9)+process.sequence3, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask100, process.myTask5)\n')

            # test NodeNameVisitor and moduleNames
            l = set()
            nameVisitor = NodeNameVisitor(l)
            process.path1.visit(nameVisitor)
            self.assertTrue(l == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
            self.assertTrue(process.path1.moduleNames() == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))

            # test copy
            process.mproducer10 = EDProducer("b10")
            process.path21 = process.path11.copy()
            process.path21.replace(process.mproducer, process.mproducer10)

            self.assertTrue(process.path11.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer+process.mproducer8+cms.Sequence(process.mproducer8, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask5)+(process.mproducer8+process.mproducer9)+process.sequence3, cms.Task(), cms.Task(process.None, process.mproducer), process.myTask1, process.myTask100, process.myTask5)\n')

            # Some peculiarities of the way things work show up here. dumpPython sorts tasks and
            # removes duplication at the level of strings. The Task and Sequence objects themselves
            # remove duplicate tasks in their contents if the instances are the same (exact same python
            # object id which is not the same as the string representation being the same).
            # Also note that the mutating visitor replaces sequences and tasks that have
            # modified contents with their modified contents, it does not modify the sequence
            # or task itself.
            self.assertTrue(process.path21.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer10+process.mproducer8+process.mproducer8+(process.mproducer8+process.mproducer9)+process.sequence3, cms.Task(), cms.Task(process.None, process.mproducer10), cms.Task(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer10, process.mproducer2, process.mproducer8, process.myTask5), process.myTask100, process.myTask5)\n')

            process.path22 = process.path21.copyAndExclude([process.d, process.mesproducer, process.mfilter])
            self.assertTrue(process.path22.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer10+process.mproducer8+process.mproducer8+(process.mproducer8+process.mproducer9)+process.mproducer8, cms.Task(), cms.Task(process.None, process.mproducer10), cms.Task(process.messource, process.mproducer10, process.mproducer2, process.mproducer8, process.myTask5), process.myTask100, process.myTask5)\n')

            process.path23 = process.path22.copyAndExclude([process.messource, process.mproducer10])
            self.assertTrue(process.path23.dumpPython(PrintOptions()) == 'cms.Path(process.mproducer8+process.mproducer8+(process.mproducer8+process.mproducer9)+process.mproducer8, cms.Task(), cms.Task(process.None), cms.Task(process.mproducer2, process.mproducer8, process.myTask5), process.myTask100, process.myTask5)\n')

            process.a = EDAnalyzer("MyAnalyzer")
            process.b = OutputModule("MyOutputModule")
            process.c = EDFilter("MyFilter")
            process.d = EDProducer("MyProducer")
            process.e = ESProducer("MyESProducer")
            process.f = ESSource("MyESSource")
            process.g = ESProducer("g")
            process.path24 = Path(process.a+process.b+process.c+process.d)
            process.path25 = process.path24.copyAndExclude([process.a,process.b,process.c])
            self.assertTrue(process.path25.dumpPython() == 'cms.Path(process.d)\n')
            #print process.path3
            #print process.dumpPython()

            process.path200 = EndPath(Sequence(process.c,Task(process.e)))
            process.path200.replace(process.c,process.b)
            process.path200.replace(process.e,process.f)
            self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.b, cms.Task(process.f))\n")
            process.path200.replace(process.b,process.c)
            process.path200.replace(process.f,process.e)
            self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.c, cms.Task(process.e))\n")
            process.path200.replace(process.c,process.a)
            process.path200.replace(process.e,process.g)
            self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.a, cms.Task(process.g))\n")
            process.path200.replace(process.a,process.c)
            process.path200.replace(process.g,process.e)
            self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.c, cms.Task(process.e))\n")

testTaskPlaceholder()

def Config.TestModuleCommand.testTaskPlaceholder

(

self

)

Definition at line 4031 of file Config.py.

References Config._lineDiff(), and ConfigBuilder.dumpPython().

        def testTaskPlaceholder(self):
            p = Process("test")
            p.a = EDProducer("ma")
            p.b = EDAnalyzer("mb")
            p.t1 = Task(TaskPlaceholder("c"))
            p.t2 = Task(p.a, TaskPlaceholder("d"), p.t1)
            p.t3 = Task(TaskPlaceholder("e"))
            p.path1 = Path(p.b, p.t2, p.t3)
            p.t5 = Task(p.a, TaskPlaceholder("g"), TaskPlaceholder("t4"))
            p.t4 = Task(TaskPlaceholder("f"))
            p.endpath1 = EndPath(p.b, p.t5)
            p.t6 = Task(TaskPlaceholder("h"))
            p.t7 = Task(p.a, TaskPlaceholder("i"), p.t6)
            p.t8 = Task(TaskPlaceholder("j"))
            p.schedule = Schedule(p.path1, p.endpath1,tasks=[p.t7,p.t8])
            p.c = EDProducer("mc")
            p.d = EDProducer("md")
            p.e = EDProducer("me")
            p.f = EDProducer("mf")
            p.g = EDProducer("mg")
            p.h = EDProducer("mh")
            p.i = EDProducer("mi")
            p.j = EDProducer("mj")
            self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
"""process.a = cms.EDProducer("ma")
process.c = cms.EDProducer("mc")
process.d = cms.EDProducer("md")
process.e = cms.EDProducer("me")
process.f = cms.EDProducer("mf")
process.g = cms.EDProducer("mg")
process.h = cms.EDProducer("mh")
process.i = cms.EDProducer("mi")
process.j = cms.EDProducer("mj")
process.b = cms.EDAnalyzer("mb")
process.t1 = cms.Task(cms.TaskPlaceholder("c"))
process.t2 = cms.Task(cms.TaskPlaceholder("d"), process.a, process.t1)
process.t3 = cms.Task(cms.TaskPlaceholder("e"))
process.t5 = cms.Task(cms.TaskPlaceholder("g"), cms.TaskPlaceholder("t4"), process.a)
process.t4 = cms.Task(cms.TaskPlaceholder("f"))
process.t6 = cms.Task(cms.TaskPlaceholder("h"))
process.t7 = cms.Task(cms.TaskPlaceholder("i"), process.a, process.t6)
process.t8 = cms.Task(cms.TaskPlaceholder("j"))
process.path1 = cms.Path(process.b, process.t2, process.t3)
process.endpath1 = cms.EndPath(process.b, process.t5)
process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])""")
            p.resolve()
            self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
"""process.a = cms.EDProducer("ma")
process.c = cms.EDProducer("mc")
process.d = cms.EDProducer("md")
process.e = cms.EDProducer("me")
process.f = cms.EDProducer("mf")
process.g = cms.EDProducer("mg")
process.h = cms.EDProducer("mh")
process.i = cms.EDProducer("mi")
process.j = cms.EDProducer("mj")
process.b = cms.EDAnalyzer("mb")
process.t1 = cms.Task(process.c)
process.t2 = cms.Task(process.a, process.d, process.t1)
process.t3 = cms.Task(process.e)
process.t4 = cms.Task(process.f)
process.t6 = cms.Task(process.h)
process.t7 = cms.Task(process.a, process.i, process.t6)
process.t8 = cms.Task(process.j)
process.t5 = cms.Task(process.a, process.g, process.t4)
process.path1 = cms.Path(process.b, process.t2, process.t3)
process.endpath1 = cms.EndPath(process.b, process.t5)
process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])""")

testTypedParameterizable()

def Config.TestModuleCommand.testTypedParameterizable

(

self

)

Definition at line 2322 of file Config.py.

        def testTypedParameterizable(self):
            p = _TypedParameterizable("blah", b=int32(1))
            #see if copy works deeply
            other = p.copy()
            other.b = 2
            self.assertNotEqual(p.b,other.b)

testUsing()

def Config.TestModuleCommand.testUsing

(

self

)

Definition at line 3595 of file Config.py.

        def testUsing(self):
            p = Process('test')
            p.block = PSet(a = int32(1))
            p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
            self.assertEqual(p.modu.a.value(),1)
            self.assertEqual(p.modu.b.value(),2)

Member Data Documentation

a

Config.TestModuleCommand.a

static

Definition at line 2628 of file Config.py.

b

Config.TestModuleCommand.b

static

Definition at line 2645 of file Config.py.

c

Config.TestModuleCommand.c

static

Definition at line 2646 of file Config.py.

d

Config.TestModuleCommand.d

static

Definition at line 2634 of file Config.py.

e

Config.TestModuleCommand.e

static

Definition at line 2648 of file Config.py.

f

Config.TestModuleCommand.f

static

Definition at line 2649 of file Config.py.

g

Config.TestModuleCommand.g

static

Definition at line 2650 of file Config.py.

maxDiff

Config.TestModuleCommand.maxDiff

Definition at line 2450 of file Config.py.

Referenced by Config.TestModuleCommand.testProcessAccelerator().

p

Config.TestModuleCommand.p

static

Definition at line 2627 of file Config.py.

Referenced by Electron.Electron.ptErr().

p2

Config.TestModuleCommand.p2

static

Definition at line 2632 of file Config.py.

proc_mod_

Config.TestModuleCommand.proc_mod_

Definition at line 4325 of file Config.py.

process

Config.TestModuleCommand.process

static

Definition at line 2743 of file Config.py.

Referenced by adaptToRunAtMiniAOD.adaptToRunAtMiniAOD.__init__(), adaptToRunAtMiniAOD.adaptToRunAtMiniAOD.convertModuleToMiniAODInput(), runTauIdMVA.TauIDEmbedder.load_againstElectronMVA6(), runTauIdMVA.TauIDEmbedder.loadMVA_WPs_run2_2017(), runTauIdMVA.TauIDEmbedder.processDeepProducer(), runTauIdMVA.TauIDEmbedder.runTauID(), and runTauIdMVA.TauIDEmbedder.tauIDMVAinputs().

r

Config.TestModuleCommand.r

static

Definition at line 2631 of file Config.py.

s

Config.TestModuleCommand.s

static

Definition at line 2630 of file Config.py.

s1

Config.TestModuleCommand.s1

static

Definition at line 2751 of file Config.py.

s2

Config.TestModuleCommand.s2

static

Definition at line 2741 of file Config.py.

s3

Config.TestModuleCommand.s3

static

Definition at line 2753 of file Config.py.

schedule

Config.TestModuleCommand.schedule

static

Definition at line 2633 of file Config.py.

task1

Config.TestModuleCommand.task1

static

Definition at line 2655 of file Config.py.

task2

Config.TestModuleCommand.task2

static

Definition at line 2653 of file Config.py.

task3

Config.TestModuleCommand.task3

static

Definition at line 2652 of file Config.py.

task4

Config.TestModuleCommand.task4

static

Definition at line 2654 of file Config.py.

task5

Config.TestModuleCommand.task5

static

Definition at line 2651 of file Config.py.

tasks

Config.TestModuleCommand.tasks

static

Definition at line 2661 of file Config.py.