CMS 3D CMS Logo
List of all members | Public Member Functions | Public Attributes | Static Public Attributes
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 2173 of file Config.py.

Member Function Documentation

◆ setUp()

def Config.TestModuleCommand.setUp (   self) 
Nothing to do

Definition at line 2174 of file Config.py.

2174  def setUp(self):
2175  """Nothing to do """
2176  None

◆ testCloneSequence()

def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 3240 of file Config.py.

References l1ctLayer2EG_cff.id, and str.

3240  def testCloneSequence(self):
3241  p = Process("test")
3242  a = EDAnalyzer("MyAnalyzer")
3243  p.a = a
3244  a.setLabel("a")
3245  b = EDAnalyzer("YOurAnalyzer")
3246  p.b = b
3247  b.setLabel("b")
3248  path = Path(a * b)
3249  p.path = Path(p.a*p.b)
3250  lookuptable = {id(a): p.a, id(b): p.b}
3251  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
3252  #lookuptable = p._cloneToObjectDict
3253  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
3254  self.assertEqual(str(path),str(p.path))
3255 
l1ctLayer2EG_cff.id
id
Definition: l1ctLayer2EG_cff.py:65
mps_fire.Path
Path
Definition: mps_fire.py:298
str
#define str(s)
Definition: TestProcessor.cc:55

◆ testConditionalTask()

def Config.TestModuleCommand.testConditionalTask (   self)

Definition at line 2962 of file Config.py.

2962  def testConditionalTask(self):
2963 
2964  # create some objects to use in tests
2965  edanalyzer = EDAnalyzer("a")
2966  edproducer = EDProducer("b")
2967  edproducer2 = EDProducer("b2")
2968  edproducer3 = EDProducer("b3")
2969  edproducer4 = EDProducer("b4")
2970  edproducer8 = EDProducer("b8")
2971  edproducer9 = EDProducer("b9")
2972  edfilter = EDFilter("c")
2973  service = Service("d")
2974  service3 = Service("d", v = untracked.uint32(3))
2975  essource = ESSource("e")
2976  esproducer = ESProducer("f")
2977  testTask2 = Task()
2978  testCTask2 = ConditionalTask()
2979 
2980  # test adding things to Tasks
2981  testTask1 = ConditionalTask(edproducer, edfilter)
2982  self.assertRaises(RuntimeError, testTask1.add, edanalyzer)
2983  testTask1.add(essource, service)
2984  testTask1.add(essource, esproducer)
2985  testTask1.add(testTask2)
2986  testTask1.add(testCTask2)
2987  coll = testTask1._collection
2988  self.assertTrue(edproducer in coll)
2989  self.assertTrue(edfilter in coll)
2990  self.assertTrue(service in coll)
2991  self.assertTrue(essource in coll)
2992  self.assertTrue(esproducer in coll)
2993  self.assertTrue(testTask2 in coll)
2994  self.assertTrue(testCTask2 in coll)
2995  self.assertTrue(len(coll) == 7)
2996  self.assertTrue(len(testTask2._collection) == 0)
2997 
2998  taskContents = []
2999  for i in testTask1:
3000  taskContents.append(i)
3001  self.assertEqual(taskContents, [edproducer, edfilter, essource, service, esproducer, testTask2, testCTask2])
3002 
3003  # test attaching Task to Process
3004  process = Process("test")
3005 
3006  process.mproducer = edproducer
3007  process.mproducer2 = edproducer2
3008  process.mfilter = edfilter
3009  process.messource = essource
3010  process.mesproducer = esproducer
3011  process.d = service
3012 
3013  testTask3 = ConditionalTask(edproducer, edproducer2)
3014  testTask1.add(testTask3)
3015  process.myTask1 = testTask1
3016 
3017  # test the validation that occurs when attaching a ConditionalTask to a Process
3018  # first a case that passes, then one the fails on an EDProducer
3019  # then one that fails on a service
3020  l = set()
3021  visitor = NodeNameVisitor(l)
3022  testTask1.visit(visitor)
3023  self.assertEqual(l, set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
3024  l2 = testTask1.moduleNames()
3025  self.assertEqual(l2, set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
3026 
3027  testTask4 = ConditionalTask(edproducer3)
3028  l.clear()
3029  self.assertRaises(RuntimeError, testTask4.visit, visitor)
3030  try:
3031  process.myTask4 = testTask4
3032  self.assertTrue(False)
3033  except RuntimeError:
3034  pass
3035 
3036  testTask5 = ConditionalTask(service3)
3037  l.clear()
3038  self.assertRaises(RuntimeError, testTask5.visit, visitor)
3039  try:
3040  process.myTask5 = testTask5
3041  self.assertTrue(False)
3042  except RuntimeError:
3043  pass
3044 
3045  process.d = service3
3046  process.myTask5 = testTask5
3047 
3048  # test placement into the Process and the tasks property
3049  expectedDict = { 'myTask1' : testTask1, 'myTask5' : testTask5 }
3050  expectedFixedDict = DictTypes.FixedKeysDict(expectedDict);
3051  self.assertEqual(process.conditionaltasks, expectedFixedDict)
3052  self.assertEqual(process.conditionaltasks['myTask1'], testTask1)
3053  self.assertEqual(process.myTask1, testTask1)
3054 
3055  # test replacing an EDProducer in a ConditionalTask when calling __settattr__
3056  # for the EDProducer on the Process.
3057  process.mproducer2 = edproducer4
3058  process.d = service
3059  l = list()
3060  visitor1 = ModuleNodeVisitor(l)
3061  testTask1.visit(visitor1)
3062  l.sort(key=lambda mod: mod.__str__())
3063  expectedList = sorted([edproducer,essource,esproducer,service,edfilter,edproducer,edproducer4],key=lambda mod: mod.__str__())
3064  self.assertEqual(expectedList, l)
3065  process.myTask6 = ConditionalTask()
3066  process.myTask7 = ConditionalTask()
3067  process.mproducer8 = edproducer8
3068  process.myTask8 = ConditionalTask(process.mproducer8)
3069  process.myTask6.add(process.myTask7)
3070  process.myTask7.add(process.myTask8)
3071  process.myTask1.add(process.myTask6)
3072  process.myTask8.add(process.myTask5)
3073  self.assertEqual(process.myTask8.dumpPython(), "cms.ConditionalTask(process.mproducer8, process.myTask5)\n")
3074 
3075  testDict = process._itemsInDependencyOrder(process.conditionaltasks)
3076  expectedLabels = ["myTask5", "myTask8", "myTask7", "myTask6", "myTask1"]
3077  expectedTasks = [process.myTask5, process.myTask8, process.myTask7, process.myTask6, process.myTask1]
3078  index = 0
3079  for testLabel, testTask in testDict.items():
3080  self.assertEqual(testLabel, expectedLabels[index])
3081  self.assertEqual(testTask, expectedTasks[index])
3082  index += 1
3083 
3084  pythonDump = testTask1.dumpPython(PrintOptions())
3085 
3086 
3087  expectedPythonDump = 'cms.ConditionalTask(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer, process.mproducer2, process.myTask6)\n'
3088  self.assertEqual(pythonDump, expectedPythonDump)
3089 
3090  process.myTask5 = ConditionalTask()
3091  self.assertEqual(process.myTask8.dumpPython(), "cms.ConditionalTask(process.mproducer8, process.myTask5)\n")
3092  process.myTask100 = ConditionalTask()
3093  process.mproducer9 = edproducer9
3094  sequence1 = Sequence(process.mproducer8, process.myTask1, process.myTask5, testTask2, testTask3)
3095  sequence2 = Sequence(process.mproducer8 + process.mproducer9)
3096  process.sequence3 = Sequence((process.mproducer8 + process.mfilter))
3097  sequence4 = Sequence()
3098  process.path1 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+sequence4)
3099  process.path1.associate(process.myTask1, process.myTask5, testTask2, testTask3)
3100  process.path11 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+ sequence4,process.myTask1, process.myTask5, testTask2, testTask3, process.myTask100)
3101  process.path2 = Path(process.mproducer)
3102  process.path3 = Path(process.mproducer9+process.mproducer8,testTask2)
3103 
3104  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')
3105 
3106  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')
3107 
3108  # test NodeNameVisitor and moduleNames
3109  l = set()
3110  nameVisitor = NodeNameVisitor(l)
3111  process.path1.visit(nameVisitor)
3112  self.assertTrue(l == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
3113  self.assertTrue(process.path1.moduleNames() == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
3114 
3115  # test copy
3116  process.mproducer10 = EDProducer("b10")
3117  process.path21 = process.path11.copy()
3118  process.path21.replace(process.mproducer, process.mproducer10)
3119 
3120  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')
3121 
3122  # Some peculiarities of the way things work show up here. dumpPython sorts tasks and
3123  # removes duplication at the level of strings. The Task and Sequence objects themselves
3124  # remove duplicate tasks in their contents if the instances are the same (exact same python
3125  # object id which is not the same as the string representation being the same).
3126  # Also note that the mutating visitor replaces sequences and tasks that have
3127  # modified contents with their modified contents, it does not modify the sequence
3128  # or task itself.
3129  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')
3130 
3131  process.path22 = process.path21.copyAndExclude([process.d, process.mesproducer, process.mfilter])
3132  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')
3133 
3134  process.path23 = process.path22.copyAndExclude([process.messource, process.mproducer10])
3135  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')
3136 
3137  process = Process("Test")
3138 
3139  process.b = EDProducer("b")
3140  process.b2 = EDProducer("b2")
3141  process.b3 = EDProducer("b3")
3142  process.p = Path(process.b, ConditionalTask(process.b3, process.b2))
3143  p = TestMakePSet()
3144  process.fillProcessDesc(p)
3145  self.assertEqual(p.values["@all_modules"], (True, ['b', 'b2', 'b3']))
3146  self.assertEqual(p.values["@paths"], (True, ['p']))
3147  self.assertEqual(p.values["p"], (True, ['b','#','b2','b3','@']))
3148 
3149 
mixOne_cfi.ESProducer
ESProducer
Definition: mixOne_cfi.py:33
mps_fire.Path
Path
Definition: mps_fire.py:298

◆ testConditionalTaskPlaceholder()

def Config.TestModuleCommand.testConditionalTaskPlaceholder (   self)

Definition at line 3959 of file Config.py.

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

3959  def testConditionalTaskPlaceholder(self):
3960  p = Process("test")
3961  p.a = EDProducer("ma")
3962  p.b = EDAnalyzer("mb")
3963  p.t1 = ConditionalTask(ConditionalTaskPlaceholder("c"))
3964  p.t2 = ConditionalTask(p.a, ConditionalTaskPlaceholder("d"), p.t1)
3965  p.t3 = ConditionalTask(ConditionalTaskPlaceholder("e"))
3966  p.path1 = Path(p.b, p.t2, p.t3)
3967  p.t5 = ConditionalTask(p.a, ConditionalTaskPlaceholder("g"), ConditionalTaskPlaceholder("t4"))
3968  p.t4 = ConditionalTask(ConditionalTaskPlaceholder("f"))
3969  p.path2 = Path(p.b, p.t5)
3970  p.schedule = Schedule(p.path1, p.path2)
3971  p.c = EDProducer("mc")
3972  p.d = EDProducer("md")
3973  p.e = EDProducer("me")
3974  p.f = EDProducer("mf")
3975  p.g = EDProducer("mg")
3976  p.h = EDProducer("mh")
3977  p.i = EDProducer("mi")
3978  p.j = EDProducer("mj")
3979  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
3980 """process.a = cms.EDProducer("ma")
3981 process.c = cms.EDProducer("mc")
3982 process.d = cms.EDProducer("md")
3983 process.e = cms.EDProducer("me")
3984 process.f = cms.EDProducer("mf")
3985 process.g = cms.EDProducer("mg")
3986 process.h = cms.EDProducer("mh")
3987 process.i = cms.EDProducer("mi")
3988 process.j = cms.EDProducer("mj")
3989 process.b = cms.EDAnalyzer("mb")
3990 process.t1 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("c"))
3991 process.t2 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("d"), process.a, process.t1)
3992 process.t3 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("e"))
3993 process.t5 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("g"), cms.ConditionalTaskPlaceholder("t4"), process.a)
3994 process.t4 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("f"))
3995 process.path1 = cms.Path(process.b, process.t2, process.t3)
3996 process.path2 = cms.Path(process.b, process.t5)
3997 process.schedule = cms.Schedule(*[ process.path1, process.path2 ])""")
3998  p.resolve()
3999  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
4000 """process.a = cms.EDProducer("ma")
4001 process.c = cms.EDProducer("mc")
4002 process.d = cms.EDProducer("md")
4003 process.e = cms.EDProducer("me")
4004 process.f = cms.EDProducer("mf")
4005 process.g = cms.EDProducer("mg")
4006 process.h = cms.EDProducer("mh")
4007 process.i = cms.EDProducer("mi")
4008 process.j = cms.EDProducer("mj")
4009 process.b = cms.EDAnalyzer("mb")
4010 process.t1 = cms.ConditionalTask(process.c)
4011 process.t2 = cms.ConditionalTask(process.a, process.d, process.t1)
4012 process.t3 = cms.ConditionalTask(process.e)
4013 process.t4 = cms.ConditionalTask(process.f)
4014 process.t5 = cms.ConditionalTask(process.a, process.g, process.t4)
4015 process.path1 = cms.Path(process.b, process.t2, process.t3)
4016 process.path2 = cms.Path(process.b, process.t5)
4017 process.schedule = cms.Schedule(*[ process.path1, process.path2 ])""")
4018 
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2023
mps_fire.Path
Path
Definition: mps_fire.py:298
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:95

◆ testContains()

def Config.TestModuleCommand.testContains (   self)

Definition at line 3256 of file Config.py.

3256  def testContains(self):
3257 
3258  a = EDProducer("a")
3259  b = EDProducer("b")
3260  c = EDProducer("c")
3261  d = EDProducer("d")
3262  e = EDProducer("e")
3263  f = EDProducer("f")
3264  g = EDProducer("g")
3265  h = EDProducer("h")
3266  i = EDProducer("i")
3267  j = EDProducer("j")
3268  k = EDProducer("k")
3269  l = EDProducer("l")
3270  m = EDProducer("m")
3271  n = EDProducer("n")
3272 
3273  seq1 = Sequence(e)
3274  task1 = Task(g)
3275  ctask1 = ConditionalTask(h)
3276  path = Path(a * c * seq1, task1, ctask1)
3277 
3278  self.assertTrue(path.contains(a))
3279  self.assertFalse(path.contains(b))
3280  self.assertTrue(path.contains(c))
3281  self.assertFalse(path.contains(d))
3282  self.assertTrue(path.contains(e))
3283  self.assertFalse(path.contains(f))
3284  self.assertTrue(path.contains(g))
3285  self.assertTrue(path.contains(h))
3286 
3287  endpath = EndPath(h * i)
3288  self.assertFalse(endpath.contains(b))
3289  self.assertTrue(endpath.contains(i))
3290 
3291  seq = Sequence(a * c)
3292  self.assertFalse(seq.contains(b))
3293  self.assertTrue(seq.contains(c))
3294 
3295  task2 = Task(l)
3296  task = Task(j, k, task2)
3297  self.assertFalse(task.contains(b))
3298  self.assertTrue(task.contains(j))
3299  self.assertTrue(task.contains(k))
3300  self.assertTrue(task.contains(l))
3301 
3302  task3 = Task(m)
3303  path2 = Path(n)
3304  sch = Schedule(path, path2, tasks=[task,task3])
3305  self.assertFalse(sch.contains(b))
3306  self.assertTrue(sch.contains(a))
3307  self.assertTrue(sch.contains(c))
3308  self.assertTrue(sch.contains(e))
3309  self.assertTrue(sch.contains(g))
3310  self.assertTrue(sch.contains(n))
3311  self.assertTrue(sch.contains(j))
3312  self.assertTrue(sch.contains(k))
3313  self.assertTrue(sch.contains(l))
3314  self.assertTrue(sch.contains(m))
3315 
3316  ctask2 = ConditionalTask(l, task1)
3317  ctask = ConditionalTask(j, k, ctask2)
3318  self.assertFalse(ctask.contains(b))
3319  self.assertTrue(ctask.contains(j))
3320  self.assertTrue(ctask.contains(k))
3321  self.assertTrue(ctask.contains(l))
3322  self.assertTrue(ctask.contains(g))
3323 
mps_fire.Path
Path
Definition: mps_fire.py:298
helpers.testContains
def testContains(self)
Definition: helpers.py:421

◆ testDelete()

def Config.TestModuleCommand.testDelete (   self)

Definition at line 4019 of file Config.py.

References ConfigBuilder.dumpPython().

4019  def testDelete(self):
4020  p = Process("test")
4021  p.a = EDAnalyzer("MyAnalyzer")
4022  p.b = EDAnalyzer("YourAnalyzer")
4023  p.c = EDAnalyzer("OurAnalyzer")
4024  p.d = EDAnalyzer("OurAnalyzer")
4025  p.e = EDAnalyzer("OurAnalyzer")
4026  p.f = EDAnalyzer("OurAnalyzer")
4027  p.g = EDProducer("OurProducer")
4028  p.h = EDProducer("YourProducer")
4029  p.i = SwitchProducerTest(
4030  test1 = EDProducer("OneProducer"),
4031  test2 = EDProducer("TwoProducer")
4032  )
4033  p.t1 = Task(p.g, p.h, p.i)
4034  t2 = Task(p.g, p.h, p.i)
4035  t3 = Task(p.g, p.h)
4036  p.t4 = Task(p.h)
4037  p.ct1 = ConditionalTask(p.g, p.h, p.i)
4038  ct2 = ConditionalTask(p.g, p.h)
4039  ct3 = ConditionalTask(p.g, p.h)
4040  p.ct4 = ConditionalTask(p.h)
4041  p.s = Sequence(p.d+p.e)
4042  p.path1 = Path(p.a+p.f+p.s,t2,ct2)
4043  p.path2 = Path(p.a)
4044  p.path3 = Path(ct3, p.ct4)
4045  p.endpath2 = EndPath(p.b)
4046  p.endpath1 = EndPath(p.b+p.f)
4047  p.schedule = Schedule(p.path2, p.path3, p.endpath2, tasks=[t3, p.t4])
4048  self.assertTrue(hasattr(p, 'f'))
4049  self.assertTrue(hasattr(p, 'g'))
4050  self.assertTrue(hasattr(p, 'i'))
4051  del p.e
4052  del p.f
4053  del p.g
4054  del p.i
4055  self.assertFalse(hasattr(p, 'f'))
4056  self.assertFalse(hasattr(p, 'g'))
4057  self.assertEqual(p.t1.dumpPython(), 'cms.Task(process.h)\n')
4058  self.assertEqual(p.ct1.dumpPython(), 'cms.ConditionalTask(process.h)\n')
4059  self.assertEqual(p.s.dumpPython(), 'cms.Sequence(process.d)\n')
4060  self.assertEqual(p.path1.dumpPython(), 'cms.Path(process.a+process.s, cms.ConditionalTask(process.h), cms.Task(process.h))\n')
4061  self.assertEqual(p.endpath1.dumpPython(), 'cms.EndPath(process.b)\n')
4062  self.assertEqual(p.path3.dumpPython(), 'cms.Path(cms.ConditionalTask(process.h), process.ct4)\n')
4063  del p.s
4064  self.assertEqual(p.path1.dumpPython(), 'cms.Path(process.a+(process.d), cms.ConditionalTask(process.h), cms.Task(process.h))\n')
4065  self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(*[ process.path2, process.path3, process.endpath2 ], tasks=[cms.Task(process.h), process.t4])\n')
4066  del p.path2
4067  self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(*[ process.path3, process.endpath2 ], tasks=[cms.Task(process.h), process.t4])\n')
4068  del p.path3
4069  self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(*[ process.endpath2 ], tasks=[cms.Task(process.h), process.t4])\n')
4070  del p.endpath2
4071  self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(tasks=[cms.Task(process.h), process.t4])\n')
4072  del p.t4
4073  self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(tasks=[cms.Task(process.h)])\n')
mps_fire.Path
Path
Definition: mps_fire.py:298
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:95

◆ testExamples()

def Config.TestModuleCommand.testExamples (   self)

Definition at line 3519 of file Config.py.

References Types.untracked.

3519  def testExamples(self):
3520  p = Process("Test")
3521  p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
3522  p.foos = EDProducer("FooProducer")
3523  p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
3524  p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
3525  p.bars.foos = 'Foosball'
3526  self.assertEqual(p.bars.foos, InputTag('Foosball'))
3527  p.p = Path(p.foos*p.bars)
3528  p.e = EndPath(p.out)
3529  p.add_(Service("MessageLogger"))
3530 
CollectionTags_cfi.Source
Source
Definition: CollectionTags_cfi.py:11
Types.untracked
untracked
Definition: Types.py:34
HLT_2022v15_cff.InputTag
InputTag
Definition: HLT_2022v15_cff.py:60417
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
mps_fire.Path
Path
Definition: mps_fire.py:298

◆ testFinalPath()

def Config.TestModuleCommand.testFinalPath (   self)

Definition at line 3201 of file Config.py.

References str.

3201  def testFinalPath(self):
3202  p = Process("test")
3203  p.a = OutputModule("MyOutputModule")
3204  p.b = OutputModule("YourOutputModule")
3205  p.c = OutputModule("OurOutputModule")
3206  path = FinalPath(p.a)
3207  path *= p.b
3208  path += p.c
3209  self.assertEqual(str(path),'a+b+c')
3210  path = FinalPath(p.a*p.b+p.c)
3211  self.assertEqual(str(path),'a+b+c')
3212  path = FinalPath(p.a+ p.b*p.c)
3213  self.assertEqual(str(path),'a+b+c')
3214  path = FinalPath(p.a*(p.b+p.c))
3215  self.assertEqual(str(path),'a+b+c')
3216  p.es = ESProducer("AnESProducer")
3217  self.assertRaises(TypeError,FinalPath,p.es)
3218 
3219  t = FinalPath()
3220  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.FinalPath()\n')
3221 
3222  t = FinalPath(p.a)
3223  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.FinalPath(process.a)\n')
3224 
3225  self.assertRaises(TypeError, FinalPath, Task())
3226  self.assertRaises(TypeError, FinalPath, p.a, Task())
3227 
3228  p.prod = EDProducer("prodName")
3229  p.t1 = Task(p.prod)
3230  self.assertRaises(TypeError, FinalPath, p.a, p.t1, Task(), p.t1)
3231 
3232  p.prod = EDProducer("prodName")
3233  p.t1 = ConditionalTask(p.prod)
3234  self.assertRaises(TypeError, FinalPath, p.a, p.t1, ConditionalTask(), p.t1)
3235 
3236  p.t = FinalPath(p.a)
3237  p.a = OutputModule("ReplacedOutputModule")
3238  self.assertEqual(p.t.dumpPython(PrintOptions()), 'cms.FinalPath(process.a)\n')
3239 
mixOne_cfi.ESProducer
ESProducer
Definition: mixOne_cfi.py:33
str
#define str(s)
Definition: TestProcessor.cc:55

◆ testFreeze()

def Config.TestModuleCommand.testFreeze (   self)

Definition at line 3551 of file Config.py.

3551  def testFreeze(self):
3552  process = Process("Freeze")
3553  m = EDProducer("M", p=PSet(i = int32(1)))
3554  m.p.i = 2
3555  process.m = m
3556  # should be frozen
3557  #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
3558  #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
3559  #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
3560  #self.assertRaises(ValueError, setattr, m, 'j', 1)
3561  # But OK to change through the process
3562  process.m.p.i = 4
3563  self.assertEqual(process.m.p.i.value(), 4)
3564  process.m.p = PSet(j=int32(1))
3565  # should work to clone it, though
3566  m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
3567  m2.p.i = 6
3568  m2.j = 8

◆ testGlobalReplace()

def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 2656 of file Config.py.

2656  def testGlobalReplace(self):
2657  p = Process('test')
2658  p.a = EDAnalyzer("MyAnalyzer")
2659  old = p.a
2660  p.b = EDAnalyzer("YourAnalyzer")
2661  p.c = EDAnalyzer("OurAnalyzer")
2662  p.d = EDProducer("MyProducer")
2663  old2 = p.d
2664  p.t1 = Task(p.d)
2665  t2 = Task(p.d)
2666  t3 = Task(p.d)
2667  t4 = Task(p.d)
2668  t5 = Task(p.d)
2669  t6 = Task(p.d)
2670  p.ct1 = ConditionalTask(p.d)
2671  s = Sequence(p.a*p.b)
2672  p.s4 = Sequence(p.a*p.b, p.ct1)
2673  s.associate(t2)
2674  p.s4.associate(t2)
2675  p.p = Path(p.c+s+p.a)
2676  p.p2 = Path(p.c+p.s4+p.a, p.ct1)
2677  p.e3 = EndPath(p.c+s+p.a)
2678  new = EDAnalyzer("NewAnalyzer")
2679  new2 = EDProducer("NewProducer")
2680  visitor1 = NodeVisitor()
2681  p.p.visit(visitor1)
2682  self.assertTrue(visitor1.modules == set([old,old2,p.b,p.c]))
2683  p.schedule = Schedule(tasks=[t6])
2684  p.globalReplace("a",new)
2685  p.globalReplace("d",new2)
2686  visitor2 = NodeVisitor()
2687  p.p.visit(visitor2)
2688  self.assertTrue(visitor2.modules == set([new,new2,p.b,p.c]))
2689  self.assertEqual(p.p.dumpPython()[:-1], "cms.Path(process.c+process.a+process.b+process.a, cms.Task(process.d))")
2690  visitor_p2 = NodeVisitor()
2691  p.p2.visit(visitor_p2)
2692  self.assertTrue(visitor_p2.modules == set([new,new2,p.b,p.c]))
2693  self.assertEqual(p.p2.dumpPython()[:-1], "cms.Path(process.c+process.s4+process.a, process.ct1)")
2694  visitor3 = NodeVisitor()
2695  p.e3.visit(visitor3)
2696  self.assertTrue(visitor3.modules == set([new,new2,p.b,p.c]))
2697  visitor4 = NodeVisitor()
2698  p.s4.visit(visitor4)
2699  self.assertTrue(visitor4.modules == set([new,new2,p.b]))
2700  self.assertEqual(p.s4.dumpPython()[:-1],"cms.Sequence(process.a+process.b, cms.Task(process.d), process.ct1)")
2701  visitor5 = NodeVisitor()
2702  p.t1.visit(visitor5)
2703  self.assertTrue(visitor5.modules == set([new2]))
2704  visitor6 = NodeVisitor()
2705  listOfTasks = list(p.schedule._tasks)
2706  listOfTasks[0].visit(visitor6)
2707  self.assertTrue(visitor6.modules == set([new2]))
2708  visitor7 = NodeVisitor()
2709  p.ct1.visit(visitor7)
2710  self.assertTrue(visitor7.modules == set([new2]))
2711  visitor8 = NodeVisitor()
2712  listOfConditionalTasks = list(p.conditionaltasks.values())
2713  listOfConditionalTasks[0].visit(visitor8)
2714  self.assertTrue(visitor8.modules == set([new2]))
2715 
2716 
2717  p.d2 = EDProducer("YourProducer")
2718  p.schedule = Schedule(p.p, p.p2, p.e3, tasks=[p.t1])
2719  self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
2720  p.p = Path(p.c+s)
2721  self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
2722  p.e3 = EndPath(p.c)
2723  self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
2724  p.t1 = Task(p.d2)
2725  self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
2726 
mps_fire.Path
Path
Definition: mps_fire.py:298

◆ testImplicitSchedule()

def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 3429 of file Config.py.

3429  def testImplicitSchedule(self):
3430  p = Process("test")
3431  p.a = EDAnalyzer("MyAnalyzer")
3432  p.b = EDAnalyzer("YourAnalyzer")
3433  p.c = EDAnalyzer("OurAnalyzer")
3434  p.path1 = Path(p.a)
3435  p.path2 = Path(p.b)
3436  self.assertTrue(p.schedule is None)
3437  pths = p.paths
3438  keys = pths.keys()
3439  self.assertEqual(pths[keys[0]],p.path1)
3440  self.assertEqual(pths[keys[1]],p.path2)
3441  p.prune()
3442  self.assertTrue(hasattr(p, 'a'))
3443  self.assertTrue(hasattr(p, 'b'))
3444  self.assertTrue(not hasattr(p, 'c'))
3445  self.assertTrue(hasattr(p, 'path1'))
3446  self.assertTrue(hasattr(p, 'path2'))
3447 
3448 
3449  p = Process("test")
3450  p.a = EDAnalyzer("MyAnalyzer")
3451  p.b = EDAnalyzer("YourAnalyzer")
3452  p.c = EDAnalyzer("OurAnalyzer")
3453  p.path2 = Path(p.b)
3454  p.path1 = Path(p.a)
3455  self.assertTrue(p.schedule is None)
3456  pths = p.paths
3457  keys = pths.keys()
3458  self.assertEqual(pths[keys[1]],p.path1)
3459  self.assertEqual(pths[keys[0]],p.path2)
3460 
3461 
mps_fire.Path
Path
Definition: mps_fire.py:298

◆ testMaxEvents()

def Config.TestModuleCommand.testMaxEvents (   self)

Definition at line 3504 of file Config.py.

3504  def testMaxEvents(self):
3505  p = Process("Test")
3506  p.maxEvents.input = 10
3507  self.assertEqual(p.maxEvents.input.value(),10)
3508  p = Process("Test")
3509  p.maxEvents.output = 10
3510  self.assertEqual(p.maxEvents.output.value(),10)
3511  p = Process("Test")
3512  p.maxEvents.output = PSet(out=untracked.int32(10))
3513  self.assertEqual(p.maxEvents.output.out.value(), 10)
3514  p = Process("Test")
3515  p.maxEvents = untracked.PSet(input = untracked.int32(5))
3516  self.assertEqual(p.maxEvents.input.value(), 5)
3517 
3518 

◆ testModifier()

def Config.TestModuleCommand.testModifier (   self)

Definition at line 4074 of file Config.py.

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

4074  def testModifier(self):
4075  m1 = Modifier()
4076  Process._firstProcess = True
4077  p = Process("test")
4078  self.assertRaises(RuntimeError, lambda: Process("test2", m1))
4079  m1 = Modifier()
4080  Process._firstProcess = True
4081  p = Process("test",m1)
4082  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
4083  def _mod_fred(obj):
4084  obj.fred = 2
4085  m1.toModify(p.a,_mod_fred)
4086  self.assertEqual(p.a.fred.value(),2)
4087  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
4088  m1.toModify(p.b, wilma = 2)
4089  self.assertEqual(p.b.wilma.value(),2)
4090  self.assertTrue(p.isUsingModifier(m1))
4091  #check that Modifier not attached to a process doesn't run
4092  m1 = Modifier()
4093  Process._firstProcess = True
4094  p = Process("test")
4095  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
4096  m1.toModify(p.a,_mod_fred)
4097  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
4098  m1.toModify(p.b, wilma = 2)
4099  self.assertEqual(p.a.fred.value(),1)
4100  self.assertEqual(p.b.wilma.value(),1)
4101  self.assertEqual(p.isUsingModifier(m1),False)
4102  #make sure clones get the changes
4103  m1 = Modifier()
4104  Process._firstProcess = True
4105  p = Process("test",m1)
4106  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4107  m1.toModify(p.a, fred = int32(2))
4108  p.b = p.a.clone(wilma = int32(3))
4109  self.assertEqual(p.a.fred.value(),2)
4110  self.assertEqual(p.a.wilma.value(),1)
4111  self.assertEqual(p.b.fred.value(),2)
4112  self.assertEqual(p.b.wilma.value(),3)
4113  #test removal of parameter
4114  m1 = Modifier()
4115  Process._firstProcess = True
4116  p = Process("test",m1)
4117  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1), fintstones = PSet(fred = int32(1)))
4118  m1.toModify(p.a, fred = None, fintstones = dict(fred = None))
4119  self.assertEqual(hasattr(p.a, "fred"), False)
4120  self.assertEqual(hasattr(p.a.fintstones, "fred"), False)
4121  self.assertEqual(p.a.wilma.value(),1)
4122  #test adding a parameter
4123  m1 = Modifier()
4124  Process._firstProcess = True
4125  p = Process("test",m1)
4126  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
4127  m1.toModify(p.a, wilma = int32(2))
4128  self.assertEqual(p.a.fred.value(), 1)
4129  self.assertEqual(p.a.wilma.value(),2)
4130  #test setting of value in PSet
4131  m1 = Modifier()
4132  Process._firstProcess = True
4133  p = Process("test",m1)
4134  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = int32(1), wilma = int32(1)))
4135  m1.toModify(p.a, flintstones = dict(fred = int32(2)))
4136  self.assertEqual(p.a.flintstones.fred.value(),2)
4137  self.assertEqual(p.a.flintstones.wilma.value(),1)
4138  #test proper exception from nonexisting parameter name
4139  m1 = Modifier()
4140  Process._firstProcess = True
4141  p = Process("test",m1)
4142  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = PSet(wilma = int32(1))))
4143  self.assertRaises(KeyError, lambda: m1.toModify(p.a, flintstones = dict(imnothere = dict(wilma=2))))
4144  self.assertRaises(KeyError, lambda: m1.toModify(p.a, foo = 1))
4145  #test setting a value in a VPSet
4146  m1 = Modifier()
4147  Process._firstProcess = True
4148  p = Process("test",m1)
4149  p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
4150  m1.toModify(p.a, flintstones = {1:dict(wilma = int32(2))})
4151  self.assertEqual(p.a.flintstones[0].fred.value(),1)
4152  self.assertEqual(p.a.flintstones[1].wilma.value(),2)
4153  #test setting a value in a list of values
4154  m1 = Modifier()
4155  Process._firstProcess = True
4156  p = Process("test",m1)
4157  p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
4158  m1.toModify(p.a, fred = {1:7})
4159  self.assertEqual(p.a.fred[0],1)
4160  self.assertEqual(p.a.fred[1],7)
4161  self.assertEqual(p.a.fred[2],3)
4162  #test IndexError setting a value in a list to an item key not in the list
4163  m1 = Modifier()
4164  Process._firstProcess = True
4165  p = Process("test",m1)
4166  p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
4167  raised = False
4168  try: m1.toModify(p.a, fred = {5:7})
4169  except IndexError as e: raised = True
4170  self.assertEqual(raised, True)
4171  #test TypeError setting a value in a list using a key that is not an int
4172  m1 = Modifier()
4173  Process._firstProcess = True
4174  p = Process("test",m1)
4175  p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
4176  raised = False
4177  try: m1.toModify(p.a, flintstones = dict(bogus = int32(37)))
4178  except TypeError as e: raised = True
4179  self.assertEqual(raised, True)
4180  #test that load causes process wide methods to run
4181  def _rem_a(proc):
4182  del proc.a
4183  class ProcModifierMod(object):
4184  def __init__(self,modifier,func):
4185  self.proc_mod_ = modifier.makeProcessModifier(func)
4186  class DummyMod(object):
4187  def __init__(self):
4188  self.a = EDAnalyzer("Dummy")
4189  testMod = DummyMod()
4190  p.extend(testMod)
4191  self.assertTrue(hasattr(p,"a"))
4192  m1 = Modifier()
4193  Process._firstProcess = True
4194  p = Process("test",m1)
4195  testProcMod = ProcModifierMod(m1,_rem_a)
4196  p.extend(testMod)
4197  p.extend(testProcMod)
4198  self.assertTrue(not hasattr(p,"a"))
4199  #test ModifierChain
4200  m1 = Modifier()
4201  mc = ModifierChain(m1)
4202  Process._firstProcess = True
4203  p = Process("test",mc)
4204  self.assertTrue(p.isUsingModifier(m1))
4205  self.assertTrue(p.isUsingModifier(mc))
4206  testMod = DummyMod()
4207  p.b = EDAnalyzer("Dummy2", fred = int32(1))
4208  m1.toModify(p.b, fred = int32(3))
4209  p.extend(testMod)
4210  testProcMod = ProcModifierMod(m1,_rem_a)
4211  p.extend(testProcMod)
4212  self.assertTrue(not hasattr(p,"a"))
4213  self.assertEqual(p.b.fred.value(),3)
4214  #check cloneAndExclude
4215  m1 = Modifier()
4216  m2 = Modifier()
4217  mc = ModifierChain(m1,m2)
4218  mclone = mc.copyAndExclude([m2])
4219  self.assertTrue(not mclone._isOrContains(m2))
4220  self.assertTrue(mclone._isOrContains(m1))
4221  m3 = Modifier()
4222  mc2 = ModifierChain(mc,m3)
4223  mclone = mc2.copyAndExclude([m2])
4224  self.assertTrue(not mclone._isOrContains(m2))
4225  self.assertTrue(mclone._isOrContains(m1))
4226  self.assertTrue(mclone._isOrContains(m3))
4227  #check combining
4228  m1 = Modifier()
4229  m2 = Modifier()
4230  Process._firstProcess = True
4231  p = Process("test",m1)
4232  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4233  (m1 & m2).toModify(p.a, fred = int32(2))
4234  self.assertRaises(TypeError, lambda: (m1 & m2).toModify(p.a, 1, wilma=2))
4235  self.assertEqual(p.a.fred, 1)
4236  m1 = Modifier()
4237  m2 = Modifier()
4238  Process._firstProcess = True
4239  p = Process("test",m1,m2)
4240  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4241  (m1 & m2).toModify(p.a, fred = int32(2))
4242  self.assertEqual(p.a.fred, 2)
4243  m1 = Modifier()
4244  m2 = Modifier()
4245  m3 = Modifier()
4246  Process._firstProcess = True
4247  p = Process("test",m1,m2,m3)
4248  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4249  (m1 & m2 & m3).toModify(p.a, fred = int32(2))
4250  self.assertEqual(p.a.fred, 2)
4251  (m1 & (m2 & m3)).toModify(p.a, fred = int32(3))
4252  self.assertEqual(p.a.fred, 3)
4253  ((m1 & m2) & m3).toModify(p.a, fred = int32(4))
4254  self.assertEqual(p.a.fred, 4)
4255  #check inverse
4256  m1 = Modifier()
4257  m2 = Modifier()
4258  Process._firstProcess = True
4259  p = Process("test", m1)
4260  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4261  (~m1).toModify(p.a, fred=2)
4262  self.assertEqual(p.a.fred, 1)
4263  (~m2).toModify(p.a, wilma=2)
4264  self.assertEqual(p.a.wilma, 2)
4265  self.assertRaises(TypeError, lambda: (~m1).toModify(p.a, 1, wilma=2))
4266  self.assertRaises(TypeError, lambda: (~m2).toModify(p.a, 1, wilma=2))
4267  # check or
4268  m1 = Modifier()
4269  m2 = Modifier()
4270  m3 = Modifier()
4271  Process._firstProcess = True
4272  p = Process("test", m1)
4273  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4274  (m1 | m2).toModify(p.a, fred=2)
4275  self.assertEqual(p.a.fred, 2)
4276  (m1 | m2 | m3).toModify(p.a, fred=3)
4277  self.assertEqual(p.a.fred, 3)
4278  (m3 | m2 | m1).toModify(p.a, fred=4)
4279  self.assertEqual(p.a.fred, 4)
4280  ((m1 | m2) | m3).toModify(p.a, fred=5)
4281  self.assertEqual(p.a.fred, 5)
4282  (m1 | (m2 | m3)).toModify(p.a, fred=6)
4283  self.assertEqual(p.a.fred, 6)
4284  (m2 | m3).toModify(p.a, fred=7)
4285  self.assertEqual(p.a.fred, 6)
4286  self.assertRaises(TypeError, lambda: (m1 | m2).toModify(p.a, 1, wilma=2))
4287  self.assertRaises(TypeError, lambda: (m2 | m3).toModify(p.a, 1, wilma=2))
4288  # check combinations
4289  m1 = Modifier()
4290  m2 = Modifier()
4291  m3 = Modifier()
4292  m4 = Modifier()
4293  Process._firstProcess = True
4294  p = Process("test", m1, m2)
4295  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4296  (m1 & ~m2).toModify(p.a, fred=2)
4297  self.assertEqual(p.a.fred, 1)
4298  (m1 & ~m3).toModify(p.a, fred=2)
4299  self.assertEqual(p.a.fred, 2)
4300  (m1 | ~m2).toModify(p.a, fred=3)
4301  self.assertEqual(p.a.fred, 3)
4302  (~m1 | ~m2).toModify(p.a, fred=4)
4303  self.assertEqual(p.a.fred, 3)
4304  (~m3 & ~m4).toModify(p.a, fred=4)
4305  self.assertEqual(p.a.fred, 4)
4306  ((m1 & m3) | ~m4).toModify(p.a, fred=5)
4307  self.assertEqual(p.a.fred, 5)
4308  #check toReplaceWith
4309  m1 = Modifier()
4310  Process._firstProcess = True
4311  p = Process("test",m1)
4312  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
4313  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
4314  self.assertRaises(TypeError, lambda: m1.toReplaceWith(p.a, EDProducer("YourProducer")))
4315  #Task
4316  p.b =EDAnalyzer("BAn")
4317  p.c =EDProducer("c")
4318  p.d =EDProducer("d")
4319  p.tc = Task(p.c)
4320  p.td = Task(p.d)
4321  p.s = Sequence(p.a, p.tc)
4322  m1.toReplaceWith(p.s, Sequence(p.a+p.b, p.td))
4323  self.assertEqual(p.a.wilma.value(),3)
4324  self.assertEqual(p.a.type_(),"YourAnalyzer")
4325  self.assertEqual(hasattr(p,"fred"),False)
4326  self.assertTrue(p.s.dumpPython() == "cms.Sequence(process.a+process.b, process.td)\n")
4327  p.e =EDProducer("e")
4328  m1.toReplaceWith(p.td, Task(p.e))
4329  self.assertTrue(p.td._collection == OrderedSet([p.e]))
4330  #ConditionalTask
4331  p.b =EDAnalyzer("BAn")
4332  p.c =EDProducer("c")
4333  p.d =EDProducer("d")
4334  del p.tc
4335  del p.td
4336  p.tc = ConditionalTask(p.c)
4337  p.td = ConditionalTask(p.d)
4338  p.s = Sequence(p.a, p.tc)
4339  m1.toReplaceWith(p.s, Sequence(p.a+p.b, p.td))
4340  self.assertEqual(p.a.wilma.value(),3)
4341  self.assertEqual(p.a.type_(),"YourAnalyzer")
4342  self.assertEqual(hasattr(p,"fred"),False)
4343  self.assertTrue(p.s.dumpPython() == "cms.Sequence(process.a+process.b, process.td)\n")
4344  p.e =EDProducer("e")
4345  m1.toReplaceWith(p.td, ConditionalTask(p.e))
4346  self.assertTrue(p.td._collection == OrderedSet([p.e]))
4347  #check toReplaceWith doesn't activate not chosen
4348  m1 = Modifier()
4349  Process._firstProcess = True
4350  p = Process("test")
4351  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
4352  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
4353  self.assertEqual(p.a.type_(),"MyAnalyzer")
4354  #check toReplaceWith and and/not/or combinations
4355  m1 = Modifier()
4356  m2 = Modifier()
4357  m3 = Modifier()
4358  m4 = Modifier()
4359  Process._firstProcess = True
4360  p = Process("test", m1, m2)
4361  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4362  self.assertRaises(TypeError, lambda: (m1 & m2).toReplaceWith(p.a, EDProducer("YourProducer")))
4363  self.assertRaises(TypeError, lambda: (m3 & m4).toReplaceWith(p.a, EDProducer("YourProducer")))
4364  self.assertRaises(TypeError, lambda: (~m3).toReplaceWith(p.a, EDProducer("YourProducer")))
4365  self.assertRaises(TypeError, lambda: (~m1).toReplaceWith(p.a, EDProducer("YourProducer")))
4366  self.assertRaises(TypeError, lambda: (m1 | m3).toReplaceWith(p.a, EDProducer("YourProducer")))
4367  self.assertRaises(TypeError, lambda: (m3 | m4).toReplaceWith(p.a, EDProducer("YourProducer")))
4368  (m1 & m2).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer1"))
4369  self.assertEqual(p.a.type_(), "YourAnalyzer1")
4370  (m1 & m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
4371  self.assertEqual(p.a.type_(), "YourAnalyzer1")
4372  (~m1).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
4373  self.assertEqual(p.a.type_(), "YourAnalyzer1")
4374  (~m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
4375  self.assertEqual(p.a.type_(), "YourAnalyzer2")
4376  (m1 | m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer3"))
4377  self.assertEqual(p.a.type_(), "YourAnalyzer3")
4378  (m3 | m4).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer4"))
4379  self.assertEqual(p.a.type_(), "YourAnalyzer3")
4380  #check chaining of toModify and toReplaceWith
4381  m1 = Modifier()
4382  m2 = Modifier()
4383  m3 = Modifier()
4384  Process._firstProcess = True
4385  p = Process("test", m1, m2)
4386  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4387  p.b = EDProducer("MyProducer", barney = int32(1), betty = int32(1))
4388  (m1 & m2).toModify(p.a, fred = 2).toModify(p.b, betty = 3)
4389  self.assertEqual(p.a.fred, 2)
4390  self.assertEqual(p.a.wilma, 1)
4391  self.assertEqual(p.b.barney, 1)
4392  self.assertEqual(p.b.betty, 3)
4393  (m1 | m3).toModify(p.a, wilma = 4).toModify(p.b, barney = 5)
4394  self.assertEqual(p.a.fred, 2)
4395  self.assertEqual(p.a.wilma, 4)
4396  self.assertEqual(p.b.barney, 5)
4397  self.assertEqual(p.b.betty, 3)
4398  (m2 & ~m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer")).toModify(p.b, barney = 6)
4399  self.assertEqual(p.a.type_(), "YourAnalyzer")
4400  self.assertEqual(p.b.barney, 6)
4401  self.assertEqual(p.b.betty, 3)
4402  (m1 & ~m3).toModify(p.a, param=int32(42)).toReplaceWith(p.b, EDProducer("YourProducer"))
4403  self.assertEqual(p.a.type_(), "YourAnalyzer")
4404  self.assertEqual(p.a.param, 42)
4405  self.assertEqual(p.b.type_(), "YourProducer")
4406 
4407  # EDAlias
4408  a = EDAlias(foo2 = VPSet(PSet(type = string("Foo2"))))
4409  m = Modifier()
4410  m._setChosen()
4411  # Modify parameters
4412  m.toModify(a, foo2 = {0: dict(type = "Foo3")})
4413  self.assertEqual(a.foo2[0].type, "Foo3")
4414  # Add an alias
4415  m.toModify(a, foo4 = VPSet(PSet(type = string("Foo4"))))
4416  self.assertEqual(a.foo2[0].type, "Foo3")
4417  self.assertEqual(a.foo4[0].type, "Foo4")
4418  # Remove an alias
4419  m.toModify(a, foo2 = None)
4420  self.assertFalse(hasattr(a, "foo2"))
4421  self.assertEqual(a.foo4[0].type, "Foo4")
4422  # Replace (doesn't work out of the box because EDAlias is not _Parameterizable
4423  m.toReplaceWith(a, EDAlias(bar = VPSet(PSet(type = string("Bar")))))
4424  self.assertFalse(hasattr(a, "foo2"))
4425  self.assertFalse(hasattr(a, "foo4"))
4426  self.assertTrue(hasattr(a, "bar"))
4427  self.assertEqual(a.bar[0].type, "Bar")
4428 
4429  # SwitchProducer
4430  sp = SwitchProducerTest(test1 = EDProducer("Foo",
4431  a = int32(1),
4432  b = PSet(c = int32(2))),
4433  test2 = EDProducer("Bar",
4434  aa = int32(11),
4435  bb = PSet(cc = int32(12))))
4436  m = Modifier()
4437  m._setChosen()
4438  # Modify parameters
4439  m.toModify(sp,
4440  test1 = dict(a = 4, b = dict(c = None)),
4441  test2 = dict(aa = 15, bb = dict(cc = 45, dd = string("foo"))))
4442  self.assertEqual(sp.test1.a.value(), 4)
4443  self.assertEqual(sp.test1.b.hasParameter("c"), False)
4444  self.assertEqual(sp.test2.aa.value(), 15)
4445  self.assertEqual(sp.test2.bb.cc.value(), 45)
4446  self.assertEqual(sp.test2.bb.dd.value(), "foo")
4447  # Replace a producer
4448  m.toReplaceWith(sp.test1, EDProducer("Fred", x = int32(42)))
4449  self.assertEqual(sp.test1.type_(), "Fred")
4450  self.assertEqual(sp.test1.x.value(), 42)
4451  self.assertRaises(TypeError, lambda: m.toReplaceWith(sp.test1, EDAnalyzer("Foo")))
4452  # Alternative way (only to be allow same syntax to be used as for adding)
4453  m.toModify(sp, test2 = EDProducer("Xyzzy", x = int32(24)))
4454  self.assertEqual(sp.test2.type_(), "Xyzzy")
4455  self.assertEqual(sp.test2.x.value(), 24)
4456  self.assertRaises(TypeError, lambda: m.toModify(sp, test2 = EDAnalyzer("Foo")))
4457  # Add a producer
4458  m.toModify(sp, test3 = EDProducer("Wilma", y = int32(24)))
4459  self.assertEqual(sp.test3.type_(), "Wilma")
4460  self.assertEqual(sp.test3.y.value(), 24)
4461  self.assertRaises(TypeError, lambda: m.toModify(sp, test4 = EDAnalyzer("Foo")))
4462  # Remove a producer
4463  m.toModify(sp, test2 = None)
4464  self.assertEqual(hasattr(sp, "test2"), False)
4465  # Add an alias
4466  m.toModify(sp, test2 = EDAlias(foo = VPSet(PSet(type = string("int")))))
4467  self.assertTrue(hasattr(sp.test2, "foo"))
4468  # Replace an alias
4469  m.toReplaceWith(sp.test2, EDAlias(bar = VPSet(PSet(type = string("int")))))
4470  self.assertTrue(hasattr(sp.test2, "bar"))
4471  # Alternative way
4472  m.toModify(sp, test2 = EDAlias(xyzzy = VPSet(PSet(type = string("int")))))
4473  self.assertTrue(hasattr(sp.test2, "xyzzy"))
4474  # Replace an alias with EDProducer
4475  self.assertRaises(TypeError, lambda: m.toReplaceWith(sp.test2, EDProducer("Foo")))
4476  m.toModify(sp, test2 = EDProducer("Foo"))
submitPVValidationJobs.__init__
def __init__(self, dataset, job_number, job_id, job_name, isDA, isMC, applyBOWS, applyEXTRACOND, extraconditions, runboundary, lumilist, intlumi, maxevents, gt, allFromGT, alignmentDB, alignmentTAG, apeDB, apeTAG, bowDB, bowTAG, vertextype, tracktype, refittertype, ttrhtype, applyruncontrol, ptcut, CMSSW_dir, the_dir)
Definition: submitPVValidationJobs.py:365
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HistogramManager_cfi.VPSet
def VPSet(args)
Definition: HistogramManager_cfi.py:408
resolutioncreator_cfi.object
object
Definition: resolutioncreator_cfi.py:4

◆ testOptions()

def Config.TestModuleCommand.testOptions (   self)

Definition at line 3492 of file Config.py.

3492  def testOptions(self):
3493  p = Process('test')
3494  self.assertEqual(p.options.numberOfThreads.value(),1)
3495  p.options.numberOfThreads = 8
3496  self.assertEqual(p.options.numberOfThreads.value(),8)
3497  p.options = PSet()
3498  self.assertEqual(p.options.numberOfThreads.value(),1)
3499  p.options = dict(numberOfStreams =2,
3500  numberOfThreads =2)
3501  self.assertEqual(p.options.numberOfThreads.value(),2)
3502  self.assertEqual(p.options.numberOfStreams.value(),2)
3503 

◆ testOverride()

def Config.TestModuleCommand.testOverride (   self)

Definition at line 3469 of file Config.py.

3469  def testOverride(self):
3470  p = Process('test')
3471  a = EDProducer("A", a1=int32(0))
3472  self.assertTrue(not a.isModified())
3473  a.a1 = 1
3474  self.assertTrue(a.isModified())
3475  p.a = a
3476  self.assertEqual(p.a.a1.value(), 1)
3477  # try adding an unmodified module.
3478  # should accept it
3479  p.a = EDProducer("A", a1=int32(2))
3480  self.assertEqual(p.a.a1.value(), 2)
3481  # try adding a modified module. Should throw
3482  # no longer, since the same (modified) say, geometry
3483  # could come from more than one cff
3484  b = EDProducer("A", a1=int32(3))
3485  b.a1 = 4
3486  #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
3487  ps1 = PSet(a = int32(1))
3488  ps2 = PSet(a = int32(2))
3489  self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
3490  self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
3491 

◆ testParameterizable()

def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 2177 of file Config.py.

2177  def testParameterizable(self):
2178  p = _Parameterizable()
2179  self.assertEqual(len(p.parameterNames_()),0)
2180  p.a = int32(1)
2181  self.assertTrue('a' in p.parameterNames_())
2182  self.assertEqual(p.a.value(), 1)
2183  p.a = 10
2184  self.assertEqual(p.a.value(), 10)
2185  p.a = untracked(int32(1))
2186  self.assertEqual(p.a.value(), 1)
2187  self.assertFalse(p.a.isTracked())
2188  p.a = untracked.int32(1)
2189  self.assertEqual(p.a.value(), 1)
2190  self.assertFalse(p.a.isTracked())
2191  p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
2192  self.assertEqual(p.foo.value(), 10)
2193  self.assertEqual(p.bar.value(),1.0)
2194  self.assertFalse(p.bar.isTracked())
2195  self.assertRaises(TypeError,setattr,(p,'c',1))
2196  p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
2197  self.assertEqual(p.a.foo.value(),10)
2198  self.assertEqual(p.a.bar.value(),1.0)
2199  p.b = untracked(PSet(fii = int32(1)))
2200  self.assertEqual(p.b.fii.value(),1)
2201  self.assertFalse(p.b.isTracked())
2202  #test the fact that values can be shared
2203  v = int32(10)
2204  p=_Parameterizable(a=v)
2205  v.setValue(11)
2206  self.assertEqual(p.a.value(),11)
2207  p.a = 12
2208  self.assertEqual(p.a.value(),12)
2209  self.assertEqual(v.value(),12)
Types.untracked
untracked
Definition: Types.py:34

◆ testPath()

def Config.TestModuleCommand.testPath (   self)

Definition at line 3150 of file Config.py.

References SequenceTypes.ignore(), and str.

3150  def testPath(self):
3151  p = Process("test")
3152  p.a = EDAnalyzer("MyAnalyzer")
3153  p.b = EDAnalyzer("YourAnalyzer")
3154  p.c = EDAnalyzer("OurAnalyzer")
3155  path = Path(p.a)
3156  path *= p.b
3157  path += p.c
3158  self.assertEqual(str(path),'a+b+c')
3159  path = Path(p.a*p.b+p.c)
3160  self.assertEqual(str(path),'a+b+c')
3161 # path = Path(p.a)*p.b+p.c #This leads to problems with sequences
3162 # self.assertEqual(str(path),'((a*b)+c)')
3163  path = Path(p.a+ p.b*p.c)
3164  self.assertEqual(str(path),'a+b+c')
3165  path = Path(p.a*(p.b+p.c))
3166  self.assertEqual(str(path),'a+b+c')
3167  path = Path(p.a*(p.b+~p.c))
3168  pathx = Path(p.a*(p.b+ignore(p.c)))
3169  self.assertEqual(str(path),'a+b+~c')
3170  p.es = ESProducer("AnESProducer")
3171  self.assertRaises(TypeError,Path,p.es)
3172 
3173  t = Path()
3174  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path()\n')
3175 
3176  t = Path(p.a)
3177  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a)\n')
3178 
3179  t = Path(Task())
3180  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(cms.Task())\n')
3181 
3182  t = Path(p.a, Task())
3183  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.Task())\n')
3184 
3185  p.prod = EDProducer("prodName")
3186  p.t1 = Task(p.prod)
3187  t = Path(p.a, p.t1, Task(), p.t1)
3188  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.Task(), process.t1)\n')
3189 
3190  t = Path(ConditionalTask())
3191  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(cms.ConditionalTask())\n')
3192 
3193  t = Path(p.a, ConditionalTask())
3194  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.ConditionalTask())\n')
3195 
3196  p.prod = EDProducer("prodName")
3197  p.t1 = ConditionalTask(p.prod)
3198  t = Path(p.a, p.t1, Task(), p.t1)
3199  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.Task(), process.t1)\n')
3200 
mixOne_cfi.ESProducer
ESProducer
Definition: mixOne_cfi.py:33
mps_fire.Path
Path
Definition: mps_fire.py:298
SequenceTypes.ignore
def ignore(seq)
Definition: SequenceTypes.py:638
str
#define str(s)
Definition: TestProcessor.cc:55

◆ testPrefers()

def Config.TestModuleCommand.testPrefers (   self)

Definition at line 3531 of file Config.py.

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

3531  def testPrefers(self):
3532  p = Process("Test")
3533  p.add_(ESSource("ForceSource"))
3534  p.juicer = ESProducer("JuicerProducer")
3535  p.prefer("ForceSource")
3536  p.prefer("juicer")
3537  self.assertEqual(_lineDiff(p.dumpPython(), Process('Test').dumpPython()),
3538 """process.juicer = cms.ESProducer("JuicerProducer")
3539 process.ForceSource = cms.ESSource("ForceSource")
3540 process.prefer("ForceSource")
3541 process.prefer("juicer")""")
3542  p.prefer("juicer",fooRcd=vstring("Foo"))
3543  self.assertEqual(_lineDiff(p.dumpPython(), Process('Test').dumpPython()),
3544 """process.juicer = cms.ESProducer("JuicerProducer")
3545 process.ForceSource = cms.ESSource("ForceSource")
3546 process.prefer("ForceSource")
3547 process.prefer("juicer",
3548  fooRcd = cms.vstring('Foo')
3549 )""")
3550 
mixOne_cfi.ESProducer
ESProducer
Definition: mixOne_cfi.py:33
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2023
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:95

◆ testProcessAccelerator()

def Config.TestModuleCommand.testProcessAccelerator (   self)

Definition at line 4508 of file Config.py.

4508  def testProcessAccelerator(self):
4509  proc = Process("TEST")
4510  p = TestMakePSet()
4511  proc.fillProcessDesc(p)
4512  self.assertTrue(["cpu"], p.values["@available_accelerators"][1])
4513  self.assertFalse(p.values["@selected_accelerators"][0])
4514  self.assertTrue(["cpu"], p.values["@selected_accelerators"][1])
4515 
4516  proc = Process("TEST")
4517  self.assertRaises(TypeError, setattr, proc, "processAcceleratorTest", ProcessAcceleratorTest())
4518  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4519  del proc.MessageLogger # remove boilerplate unnecessary for this test case
4520  self.maxDiff = None
4521  self.assertEqual(proc.dumpPython(),
4522 """import FWCore.ParameterSet.Config as cms
4523 from test import ProcessAcceleratorTest
4524 
4525 process = cms.Process("TEST")
4526 
4527 process.maxEvents = cms.untracked.PSet(
4528  input = cms.optional.untracked.int32,
4529  output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
4530 )
4531 
4532 process.maxLuminosityBlocks = cms.untracked.PSet(
4533  input = cms.untracked.int32(-1)
4534 )
4535 
4536 process.options = cms.untracked.PSet(
4537  FailPath = cms.untracked.vstring(),
4538  IgnoreCompletely = cms.untracked.vstring(),
4539  Rethrow = cms.untracked.vstring(),
4540  SkipEvent = cms.untracked.vstring(),
4541  accelerators = cms.untracked.vstring('*'),
4542  allowUnscheduled = cms.obsolete.untracked.bool,
4543  canDeleteEarly = cms.untracked.vstring(),
4544  deleteNonConsumedUnscheduledModules = cms.untracked.bool(True),
4545  dumpOptions = cms.untracked.bool(False),
4546  emptyRunLumiMode = cms.obsolete.untracked.string,
4547  eventSetup = cms.untracked.PSet(
4548  forceNumberOfConcurrentIOVs = cms.untracked.PSet(
4549  allowAnyLabel_=cms.required.untracked.uint32
4550  ),
4551  numberOfConcurrentIOVs = cms.untracked.uint32(0)
4552  ),
4553  fileMode = cms.untracked.string('FULLMERGE'),
4554  forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False),
4555  holdsReferencesToDeleteEarly = cms.untracked.VPSet(),
4556  makeTriggerResults = cms.obsolete.untracked.bool,
4557  modulesToIgnoreForDeleteEarly = cms.untracked.vstring(),
4558  numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0),
4559  numberOfConcurrentRuns = cms.untracked.uint32(1),
4560  numberOfStreams = cms.untracked.uint32(0),
4561  numberOfThreads = cms.untracked.uint32(1),
4562  printDependencies = cms.untracked.bool(False),
4563  sizeOfStackForThreadsInKB = cms.optional.untracked.uint32,
4564  throwIfIllegalParameter = cms.untracked.bool(True),
4565  wantSummary = cms.untracked.bool(False)
4566 )
4567 
4568 process.ProcessAcceleratorTest = ProcessAcceleratorTest(
4569  enabled = ['test1', 'test2', 'anothertest3']
4570 )
4571 
4572 
4573 """)
4574  p = TestMakePSet()
4575  proc.fillProcessDesc(p)
4576  self.assertEqual(["*"], p.values["options"][1].values["accelerators"][1])
4577  self.assertFalse(p.values["options"][1].values["accelerators"][0])
4578  self.assertTrue(["anothertest3", "cpu", "test1", "test2"], p.values["@selected_accelerators"][1])
4579  self.assertEqual("AcceleratorTestService", p.values["services"][1][0].values["@service_type"][1])
4580  self.assertFalse(p.values["@available_accelerators"][0])
4581  self.assertTrue(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4582 
4583  proc = Process("TEST")
4584  proc.ProcessAcceleratorTest = ProcessAcceleratorTest(enabled=["test1"])
4585  p = TestMakePSet()
4586  proc.fillProcessDesc(p)
4587  self.assertEqual(["cpu", "test1"], p.values["@selected_accelerators"][1])
4588  self.assertEqual(["cpu", "test1"], p.values["@available_accelerators"][1])
4589 
4590  proc = Process("TEST")
4591  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4592  proc.options.accelerators = ["test2"]
4593  p = TestMakePSet()
4594  proc.fillProcessDesc(p)
4595  self.assertEqual(["test2"], p.values["@selected_accelerators"][1])
4596  self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4597 
4598  proc = Process("TEST")
4599  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4600  proc.options.accelerators = ["test*"]
4601  proc.fillProcessDesc(p)
4602  self.assertEqual(["test1", "test2"], p.values["@selected_accelerators"][1])
4603  self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4604 
4605  proc = Process("TEST")
4606  proc.ProcessAcceleratorTest = ProcessAcceleratorTest(enabled=["test1"])
4607  proc.options.accelerators = ["test2"]
4608  p = TestMakePSet()
4609  proc.fillProcessDesc(p)
4610  self.assertEqual([], p.values["@selected_accelerators"][1])
4611  self.assertEqual(["cpu", "test1"], p.values["@available_accelerators"][1])
4612 
4613  proc = Process("TEST")
4614  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4615  proc.options.accelerators = ["cpu*"]
4616  p = TestMakePSet()
4617  proc.fillProcessDesc(p)
4618  self.assertEqual(["cpu"], p.values["@selected_accelerators"][1])
4619  self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4620 
4621  proc = Process("TEST")
4622  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4623  proc.options.accelerators = ["test3"]
4624  p = TestMakePSet()
4625  self.assertRaises(ValueError, proc.fillProcessDesc, p)
4626 
4627  proc = Process("TEST")
4628  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4629  proc.options.accelerators = ["*", "test1"]
4630  p = TestMakePSet()
4631  self.assertRaises(ValueError, proc.fillProcessDesc, p)
4632 
4633  proc = Process("TEST")
4634  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4635  proc.ProcessAcceleratorTest2 = ProcessAcceleratorTest2()
4636  p = TestMakePSet()
4637  proc.fillProcessDesc(p)
4638  self.assertEqual(["anothertest3", "anothertest4", "cpu", "test1", "test2"], p.values["@selected_accelerators"][1])
4639  self.assertEqual(["anothertest3", "anothertest4", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4640 
4641  proc = Process("TEST")
4642  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4643  proc.ProcessAcceleratorTest2 = ProcessAcceleratorTest2()
4644  proc.options.accelerators = ["*test3", "c*"]
4645  p = TestMakePSet()
4646  proc.fillProcessDesc(p)
4647  self.assertEqual(["anothertest3", "cpu"], p.values["@selected_accelerators"][1])
4648  self.assertEqual(["anothertest3", "anothertest4", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4649 
4650  proc = Process("TEST")
4651  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4652  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4653  a = int32(1),
4654  b = PSet(c = int32(2))),
4655  test1 = EDProducer("Bar",
4656  aa = int32(11),
4657  bb = PSet(cc = int32(12))))
4658  proc.p = Path(proc.sp)
4659  p = TestMakePSet()
4660  proc.fillProcessDesc(p)
4661  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
4662 
4663  proc = Process("TEST")
4664  proc.ProcessAcceleratorTest = ProcessAcceleratorTest(enabled=["test1"])
4665  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4666  a = int32(1),
4667  b = PSet(c = int32(2))),
4668  test1 = EDProducer("Bar",
4669  aa = int32(11),
4670  bb = PSet(cc = int32(12))))
4671  proc.p = Path(proc.sp)
4672  p = TestMakePSet()
4673  proc.fillProcessDesc(p)
4674  self.assertEqual((False, "sp@test1"), p.values["sp"][1].values["@chosen_case"])
4675 
4676  proc = Process("TEST")
4677  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4678  proc.options.accelerators = ["test1"]
4679  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4680  a = int32(1),
4681  b = PSet(c = int32(2))),
4682  test1 = EDProducer("Bar",
4683  aa = int32(11),
4684  bb = PSet(cc = int32(12))))
4685  proc.p = Path(proc.sp)
4686  p = TestMakePSet()
4687  proc.fillProcessDesc(p)
4688  self.assertEqual((False, "sp@test1"), p.values["sp"][1].values["@chosen_case"])
4689 
4690  proc = Process("TEST")
4691  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4692  proc.options.accelerators = ["test*"]
4693  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4694  a = int32(1),
4695  b = PSet(c = int32(2))),
4696  test1 = EDProducer("Bar",
4697  aa = int32(11),
4698  bb = PSet(cc = int32(12))))
4699  proc.p = Path(proc.sp)
4700  p = TestMakePSet()
4701  proc.fillProcessDesc(p)
4702  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
4703 
4704  proc = Process("TEST")
4705  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4706  proc.options.accelerators = ["anothertest3"]
4707  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4708  a = int32(1),
4709  b = PSet(c = int32(2))),
4710  test1 = EDProducer("Bar",
4711  aa = int32(11),
4712  bb = PSet(cc = int32(12))))
4713  proc.p = Path(proc.sp)
4714  p = TestMakePSet()
4715  self.assertRaises(RuntimeError, proc.fillProcessDesc, p)
4716 
4717  import pickle
4718  proc = Process("TEST")
4719  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4720  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4721  a = int32(1),
4722  b = PSet(c = int32(2))),
4723  test1 = EDProducer("Bar",
4724  aa = int32(11),
4725  bb = PSet(cc = int32(12))))
4726  proc.p = Path(proc.sp)
4727  pkl = pickle.dumps(proc)
4728  unpkl = pickle.loads(pkl)
4729  p = TestMakePSet()
4730  unpkl.fillProcessDesc(p)
4731  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
4732  self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4733  unpkl = pickle.loads(pkl)
4734  unpkl.ProcessAcceleratorTest.setEnabled(["test1"])
4735  p = TestMakePSet()
4736  unpkl.fillProcessDesc(p)
4737  self.assertEqual((False, "sp@test1"), p.values["sp"][1].values["@chosen_case"])
4738  self.assertEqual(["cpu", "test1"], p.values["@available_accelerators"][1])
4739 
4740  unittest.main()
mps_fire.Path
Path
Definition: mps_fire.py:298

◆ testProcessDumpPython()

def Config.TestModuleCommand.testProcessDumpPython (   self)

Definition at line 2337 of file Config.py.

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

2337  def testProcessDumpPython(self):
2338  self.assertEqual(Process("test").dumpPython(),
2339 """import FWCore.ParameterSet.Config as cms
2340 
2341 process = cms.Process("test")
2342 
2343 process.maxEvents = cms.untracked.PSet(
2344  input = cms.optional.untracked.int32,
2345  output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
2346 )
2347 
2348 process.maxLuminosityBlocks = cms.untracked.PSet(
2349  input = cms.untracked.int32(-1)
2350 )
2351 
2352 process.options = cms.untracked.PSet(
2353  FailPath = cms.untracked.vstring(),
2354  IgnoreCompletely = cms.untracked.vstring(),
2355  Rethrow = cms.untracked.vstring(),
2356  SkipEvent = cms.untracked.vstring(),
2357  accelerators = cms.untracked.vstring('*'),
2358  allowUnscheduled = cms.obsolete.untracked.bool,
2359  canDeleteEarly = cms.untracked.vstring(),
2360  deleteNonConsumedUnscheduledModules = cms.untracked.bool(True),
2361  dumpOptions = cms.untracked.bool(False),
2362  emptyRunLumiMode = cms.obsolete.untracked.string,
2363  eventSetup = cms.untracked.PSet(
2364  forceNumberOfConcurrentIOVs = cms.untracked.PSet(
2365  allowAnyLabel_=cms.required.untracked.uint32
2366  ),
2367  numberOfConcurrentIOVs = cms.untracked.uint32(0)
2368  ),
2369  fileMode = cms.untracked.string('FULLMERGE'),
2370  forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False),
2371  holdsReferencesToDeleteEarly = cms.untracked.VPSet(),
2372  makeTriggerResults = cms.obsolete.untracked.bool,
2373  modulesToIgnoreForDeleteEarly = cms.untracked.vstring(),
2374  numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0),
2375  numberOfConcurrentRuns = cms.untracked.uint32(1),
2376  numberOfStreams = cms.untracked.uint32(0),
2377  numberOfThreads = cms.untracked.uint32(1),
2378  printDependencies = cms.untracked.bool(False),
2379  sizeOfStackForThreadsInKB = cms.optional.untracked.uint32,
2380  throwIfIllegalParameter = cms.untracked.bool(True),
2381  wantSummary = cms.untracked.bool(False)
2382 )
2383 
2384 process.MessageLogger = cms.Service("MessageLogger",
2385  cerr = cms.untracked.PSet(
2386  FwkReport = cms.untracked.PSet(
2387  limit = cms.untracked.int32(10000000),
2388  reportEvery = cms.untracked.int32(1)
2389  ),
2390  FwkSummary = cms.untracked.PSet(
2391  limit = cms.untracked.int32(10000000),
2392  reportEvery = cms.untracked.int32(1)
2393  ),
2394  INFO = cms.untracked.PSet(
2395  limit = cms.untracked.int32(0)
2396  ),
2397  Root_NoDictionary = cms.untracked.PSet(
2398  limit = cms.untracked.int32(0)
2399  ),
2400  default = cms.untracked.PSet(
2401  limit = cms.untracked.int32(10000000)
2402  ),
2403  enable = cms.untracked.bool(True),
2404  enableStatistics = cms.untracked.bool(False),
2405  lineLength = cms.optional.untracked.int32,
2406  noLineBreaks = cms.optional.untracked.bool,
2407  noTimeStamps = cms.untracked.bool(False),
2408  resetStatistics = cms.untracked.bool(False),
2409  statisticsThreshold = cms.untracked.string('WARNING'),
2410  threshold = cms.untracked.string('INFO'),
2411  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2412  limit = cms.optional.untracked.int32,
2413  reportEvery = cms.untracked.int32(1),
2414  timespan = cms.optional.untracked.int32
2415  )
2416  ),
2417  cout = cms.untracked.PSet(
2418  enable = cms.untracked.bool(False),
2419  enableStatistics = cms.untracked.bool(False),
2420  lineLength = cms.optional.untracked.int32,
2421  noLineBreaks = cms.optional.untracked.bool,
2422  noTimeStamps = cms.optional.untracked.bool,
2423  resetStatistics = cms.untracked.bool(False),
2424  statisticsThreshold = cms.optional.untracked.string,
2425  threshold = cms.optional.untracked.string,
2426  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2427  limit = cms.optional.untracked.int32,
2428  reportEvery = cms.untracked.int32(1),
2429  timespan = cms.optional.untracked.int32
2430  )
2431  ),
2432  debugModules = cms.untracked.vstring(),
2433  default = cms.untracked.PSet(
2434  limit = cms.optional.untracked.int32,
2435  lineLength = cms.untracked.int32(80),
2436  noLineBreaks = cms.untracked.bool(False),
2437  noTimeStamps = cms.untracked.bool(False),
2438  reportEvery = cms.untracked.int32(1),
2439  statisticsThreshold = cms.untracked.string('INFO'),
2440  threshold = cms.untracked.string('INFO'),
2441  timespan = cms.optional.untracked.int32,
2442  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2443  limit = cms.optional.untracked.int32,
2444  reportEvery = cms.untracked.int32(1),
2445  timespan = cms.optional.untracked.int32
2446  )
2447  ),
2448  files = cms.untracked.PSet(
2449  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2450  enableStatistics = cms.untracked.bool(False),
2451  extension = cms.optional.untracked.string,
2452  filename = cms.optional.untracked.string,
2453  lineLength = cms.optional.untracked.int32,
2454  noLineBreaks = cms.optional.untracked.bool,
2455  noTimeStamps = cms.optional.untracked.bool,
2456  output = cms.optional.untracked.string,
2457  resetStatistics = cms.untracked.bool(False),
2458  statisticsThreshold = cms.optional.untracked.string,
2459  threshold = cms.optional.untracked.string,
2460  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2461  limit = cms.optional.untracked.int32,
2462  reportEvery = cms.untracked.int32(1),
2463  timespan = cms.optional.untracked.int32
2464  )
2465  )
2466  ),
2467  suppressDebug = cms.untracked.vstring(),
2468  suppressFwkInfo = cms.untracked.vstring(),
2469  suppressInfo = cms.untracked.vstring(),
2470  suppressWarning = cms.untracked.vstring(),
2471  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2472  limit = cms.optional.untracked.int32,
2473  reportEvery = cms.untracked.int32(1),
2474  timespan = cms.optional.untracked.int32
2475  )
2476 )
2477 
2478 
2479 """)
2480  p = Process("test")
2481  p.a = EDAnalyzer("MyAnalyzer")
2482  p.p = Path(p.a)
2483  p.s = Sequence(p.a)
2484  p.r = Sequence(p.s)
2485  p.p2 = Path(p.s)
2486  p.schedule = Schedule(p.p2,p.p)
2487  d=p.dumpPython()
2488  self.assertEqual(_lineDiff(d,Process("test").dumpPython()),
2489 """process.a = cms.EDAnalyzer("MyAnalyzer")
2490 process.s = cms.Sequence(process.a)
2491 process.r = cms.Sequence(process.s)
2492 process.p = cms.Path(process.a)
2493 process.p2 = cms.Path(process.s)
2494 process.schedule = cms.Schedule(*[ process.p2, process.p ])""")
2495  #Reverse order of 'r' and 's'
2496  p = Process("test")
2497  p.a = EDAnalyzer("MyAnalyzer")
2498  p.p = Path(p.a)
2499  p.r = Sequence(p.a)
2500  p.s = Sequence(p.r)
2501  p.p2 = Path(p.r)
2502  p.schedule = Schedule(p.p2,p.p)
2503  p.b = EDAnalyzer("YourAnalyzer")
2504  d=p.dumpPython()
2505  self.assertEqual(_lineDiff(d,Process("test").dumpPython()),
2506 """process.a = cms.EDAnalyzer("MyAnalyzer")
2507 process.b = cms.EDAnalyzer("YourAnalyzer")
2508 process.r = cms.Sequence(process.a)
2509 process.s = cms.Sequence(process.r)
2510 process.p = cms.Path(process.a)
2511 process.p2 = cms.Path(process.r)
2512 process.schedule = cms.Schedule(*[ process.p2, process.p ])""")
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2023
mps_fire.Path
Path
Definition: mps_fire.py:298
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:95

◆ testProcessExtend()

def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 2242 of file Config.py.

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

2242  def testProcessExtend(self):
2243  class FromArg(object):
2244  def __init__(self,*arg,**args):
2245  for name in args.keys():
2246  self.__dict__[name]=args[name]
2247 
2248  a=EDAnalyzer("MyAnalyzer")
2249  t=EDAnalyzer("MyAnalyzer")
2250  t.setLabel("foo")
2251  s1 = Sequence(a)
2252  s2 = Sequence(s1)
2253  s3 = Sequence(s2)
2254  d = FromArg(
2255  a=a,
2256  b=Service("Full"),
2257  c=Path(a),
2258  d=s2,
2259  e=s1,
2260  f=s3,
2261  g=Sequence(s1+s2+s3)
2262  )
2263  p = Process("Test")
2264  p.extend(d)
2265  self.assertEqual(p.a.type_(),"MyAnalyzer")
2266  self.assertEqual(p.a.label_(),"a")
2267  self.assertRaises(AttributeError,getattr,p,'b')
2268  self.assertEqual(p.Full.type_(),"Full")
2269  self.assertEqual(str(p.c),'a')
2270  self.assertEqual(str(p.d),'a')
2271 
2272  z1 = FromArg(
2273  a=a,
2274  b=Service("Full"),
2275  c=Path(a),
2276  d=s2,
2277  e=s1,
2278  f=s3,
2279  s4=s3,
2280  g=Sequence(s1+s2+s3)
2281  )
2282 
2283  p1 = Process("Test")
2284  #p1.extend(z1)
2285  self.assertRaises(ValueError, p1.extend, z1)
2286 
2287  z2 = FromArg(
2288  a=a,
2289  b=Service("Full"),
2290  c=Path(a),
2291  d=s2,
2292  e=s1,
2293  f=s3,
2294  aaa=copy.deepcopy(a),
2295  s4=copy.deepcopy(s3),
2296  g=Sequence(s1+s2+s3),
2297  t=t
2298  )
2299  p2 = Process("Test")
2300  p2.extend(z2)
2301  #self.assertRaises(ValueError, p2.extend, z2)
2302  self.assertEqual(p2.s4.label_(),"s4")
2303  #p2.s4.setLabel("foo")
2304  self.assertRaises(ValueError, p2.s4.setLabel, "foo")
2305  p2.s4.setLabel("s4")
2306  p2.s4.setLabel(None)
2307  p2.s4.setLabel("foo")
2308  p2._Process__setObjectLabel(p2.s4, "foo")
2309  p2._Process__setObjectLabel(p2.s4, None)
2310  p2._Process__setObjectLabel(p2.s4, "bar")
2311 
2312 
2313  p = Process('test')
2314  p.a = EDProducer("MyProducer")
2315  p.t = Task(p.a)
2316  p.p = Path(p.t)
2317  self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
2318  self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
2319  self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())
2320 
2321  p = Process('test')
2322  p.a = EDProducer("MyProducer")
2323  p.t = ConditionalTask(p.a)
2324  p.p = Path(p.t)
2325  self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
2326  self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
2327  self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())
2328 
2329  p = Process('test')
2330  p.a = EDProducer("MyProducer")
2331  p.s = Sequence(p.a)
2332  p.p = Path(p.s)
2333  self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
2334  self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
2335  self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())
2336 
submitPVValidationJobs.__init__
def __init__(self, dataset, job_number, job_id, job_name, isDA, isMC, applyBOWS, applyEXTRACOND, extraconditions, runboundary, lumilist, intlumi, maxevents, gt, allFromGT, alignmentDB, alignmentTAG, apeDB, apeTAG, bowDB, bowTAG, vertextype, tracktype, refittertype, ttrhtype, applyruncontrol, ptcut, CMSSW_dir, the_dir)
Definition: submitPVValidationJobs.py:365
mps_fire.Path
Path
Definition: mps_fire.py:298
str
#define str(s)
Definition: TestProcessor.cc:55
resolutioncreator_cfi.object
object
Definition: resolutioncreator_cfi.py:4

◆ testProcessForProcessAccelerator()

def Config.TestModuleCommand.testProcessForProcessAccelerator (   self)

Definition at line 4494 of file Config.py.

4494  def testProcessForProcessAccelerator(self):
4495  proc = Process("TEST")
4496  p = ProcessForProcessAccelerator(proc)
4497  p.TestService = Service("TestService")
4498  self.assertTrue(hasattr(proc, "TestService"))
4499  self.assertEqual(proc.TestService.type_(), "TestService")
4500  self.assertRaises(TypeError, setattr, p, "a", EDProducer("Foo"))
4501  p.add_(Service("TestServiceTwo"))
4502  self.assertTrue(hasattr(proc, "TestServiceTwo"))
4503  self.assertEqual(proc.TestServiceTwo.type_(), "TestServiceTwo")
4504  p.TestService.foo = untracked.uint32(42)
4505  self.assertEqual(proc.TestService.foo.value(), 42)
4506  proc.mod = EDProducer("Producer")
4507  self.assertRaises(TypeError, getattr, p, "mod")

◆ testProcessFragment()

def Config.TestModuleCommand.testProcessFragment (   self)

Definition at line 4477 of file Config.py.

4477  def testProcessFragment(self):
4478  #check defaults are not overwritten
4479  f = ProcessFragment('Fragment')
4480  p = Process('PROCESS')
4481  p.maxEvents.input = 10
4482  p.options.numberOfThreads = 4
4483  p.maxLuminosityBlocks.input = 2
4484  p.extend(f)
4485  self.assertEqual(p.maxEvents.input.value(),10)
4486  self.assertEqual(p.options.numberOfThreads.value(), 4)
4487  self.assertEqual(p.maxLuminosityBlocks.input.value(),2)
4488  #general checks
4489  f = ProcessFragment("Fragment")
4490  f.fltr = EDFilter("Foo")
4491  p = Process('PROCESS')
4492  p.extend(f)
4493  self.assertTrue(hasattr(p,'fltr'))

◆ testProcessInsertion()

def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 2217 of file Config.py.

2217  def testProcessInsertion(self):
2218  p = Process("test")
2219  p.a = EDAnalyzer("MyAnalyzer")
2220  self.assertTrue( 'a' in p.analyzers_() )
2221  self.assertTrue( 'a' in p.analyzers)
2222  p.add_(Service("SomeService"))
2223  self.assertTrue('SomeService' in p.services_())
2224  self.assertEqual(p.SomeService.type_(), "SomeService")
2225  p.Tracer = Service("Tracer")
2226  self.assertTrue('Tracer' in p.services_())
2227  self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
2228  self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
2229  self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
2230  p.out = OutputModule("Outer")
2231  self.assertEqual(p.out.type_(), 'Outer')
2232  self.assertTrue( 'out' in p.outputModules_() )
2233 
2234  p.geom = ESSource("GeomProd")
2235  self.assertTrue('geom' in p.es_sources_())
2236  p.add_(ESSource("ConfigDB"))
2237  self.assertTrue('ConfigDB' in p.es_sources_())
2238 
2239  p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
2240  self.assertTrue('aliasfoo1' in p.aliases_())
2241 
CollectionTags_cfi.Source
Source
Definition: CollectionTags_cfi.py:11
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HistogramManager_cfi.VPSet
def VPSet(args)
Definition: HistogramManager_cfi.py:408

◆ testPrune()

def Config.TestModuleCommand.testPrune (   self)

Definition at line 3728 of file Config.py.

3728  def testPrune(self):
3729  p = Process("test")
3730  p.a = EDAnalyzer("MyAnalyzer")
3731  p.b = EDAnalyzer("YourAnalyzer")
3732  p.c = EDAnalyzer("OurAnalyzer")
3733  p.d = EDAnalyzer("OurAnalyzer")
3734  p.e = EDProducer("MyProducer")
3735  p.f = EDProducer("YourProducer")
3736  p.g = EDProducer("TheirProducer")
3737  p.h = EDProducer("OnesProducer")
3738  p.s = Sequence(p.d)
3739  p.t1 = Task(p.e)
3740  p.t2 = Task(p.f)
3741  p.t3 = Task(p.g, p.t1)
3742  p.ct1 = ConditionalTask(p.h)
3743  p.ct2 = ConditionalTask(p.f)
3744  p.ct3 = ConditionalTask(p.ct1)
3745  p.path1 = Path(p.a, p.t3, p.ct3)
3746  p.path2 = Path(p.b)
3747  self.assertTrue(p.schedule is None)
3748  pths = p.paths
3749  keys = pths.keys()
3750  self.assertEqual(pths[keys[0]],p.path1)
3751  self.assertEqual(pths[keys[1]],p.path2)
3752  p.pset1 = PSet(parA = string("pset1"))
3753  p.pset2 = untracked.PSet(parA = string("pset2"))
3754  p.vpset1 = VPSet()
3755  p.vpset2 = untracked.VPSet()
3756  p.prune()
3757  self.assertTrue(hasattr(p, 'a'))
3758  self.assertTrue(hasattr(p, 'b'))
3759  self.assertTrue(not hasattr(p, 'c'))
3760  self.assertTrue(not hasattr(p, 'd'))
3761  self.assertTrue(hasattr(p, 'e'))
3762  self.assertTrue(not hasattr(p, 'f'))
3763  self.assertTrue(hasattr(p, 'g'))
3764  self.assertTrue(hasattr(p, 'h'))
3765  self.assertTrue(not hasattr(p, 's'))
3766  self.assertTrue(hasattr(p, 't1'))
3767  self.assertTrue(not hasattr(p, 't2'))
3768  self.assertTrue(hasattr(p, 't3'))
3769  self.assertTrue(hasattr(p, 'path1'))
3770  self.assertTrue(hasattr(p, 'path2'))
3771 # self.assertTrue(not hasattr(p, 'pset1'))
3772 # self.assertTrue(hasattr(p, 'pset2'))
3773 # self.assertTrue(not hasattr(p, 'vpset1'))
3774 # self.assertTrue(not hasattr(p, 'vpset2'))
3775 
3776  p = Process("test")
3777  p.a = EDAnalyzer("MyAnalyzer")
3778  p.b = EDAnalyzer("YourAnalyzer")
3779  p.c = EDAnalyzer("OurAnalyzer")
3780  p.d = EDAnalyzer("OurAnalyzer")
3781  p.e = EDAnalyzer("OurAnalyzer")
3782  p.f = EDProducer("MyProducer")
3783  p.g = EDProducer("YourProducer")
3784  p.h = EDProducer("TheirProducer")
3785  p.i = EDProducer("OurProducer")
3786  p.j = EDProducer("OurProducer")
3787  p.k = EDProducer("OurProducer")
3788  p.l = EDProducer("OurProducer")
3789  p.t1 = Task(p.f)
3790  p.t2 = Task(p.g)
3791  p.t3 = Task(p.h)
3792  p.t4 = Task(p.i)
3793  p.ct1 = Task(p.f)
3794  p.ct2 = Task(p.j)
3795  p.ct3 = Task(p.k)
3796  p.ct4 = Task(p.l)
3797  p.s = Sequence(p.d, p.t1, p.ct1)
3798  p.s2 = Sequence(p.b, p.t2, p.ct2)
3799  p.s3 = Sequence(p.e)
3800  p.path1 = Path(p.a, p.t3, p.ct3)
3801  p.path2 = Path(p.b)
3802  p.path3 = Path(p.b+p.s2)
3803  p.path4 = Path(p.b+p.s3)
3804  p.schedule = Schedule(p.path1,p.path2,p.path3)
3805  p.schedule.associate(p.t4)
3806  pths = p.paths
3807  keys = pths.keys()
3808  self.assertEqual(pths[keys[0]],p.path1)
3809  self.assertEqual(pths[keys[1]],p.path2)
3810  p.prune()
3811  self.assertTrue(hasattr(p, 'a'))
3812  self.assertTrue(hasattr(p, 'b'))
3813  self.assertTrue(not hasattr(p, 'c'))
3814  self.assertTrue(not hasattr(p, 'd'))
3815  self.assertTrue(not hasattr(p, 'e'))
3816  self.assertTrue(not hasattr(p, 'f'))
3817  self.assertTrue(hasattr(p, 'g'))
3818  self.assertTrue(hasattr(p, 'h'))
3819  self.assertTrue(hasattr(p, 'i'))
3820  self.assertTrue(hasattr(p, 'j'))
3821  self.assertTrue(hasattr(p, 'k'))
3822  self.assertTrue(not hasattr(p, 'l'))
3823  self.assertTrue(not hasattr(p, 't1'))
3824  self.assertTrue(hasattr(p, 't2'))
3825  self.assertTrue(hasattr(p, 't3'))
3826  self.assertTrue(hasattr(p, 't4'))
3827  self.assertTrue(not hasattr(p, 'ct1'))
3828  self.assertTrue(hasattr(p, 'ct2'))
3829  self.assertTrue(hasattr(p, 'ct3'))
3830  self.assertTrue(not hasattr(p, 'ct4'))
3831  self.assertTrue(not hasattr(p, 's'))
3832  self.assertTrue(hasattr(p, 's2'))
3833  self.assertTrue(not hasattr(p, 's3'))
3834  self.assertTrue(hasattr(p, 'path1'))
3835  self.assertTrue(hasattr(p, 'path2'))
3836  self.assertTrue(hasattr(p, 'path3'))
3837  self.assertTrue(not hasattr(p, 'path4'))
3838  #test SequencePlaceholder
3839  p = Process("test")
3840  p.a = EDAnalyzer("MyAnalyzer")
3841  p.b = EDAnalyzer("YourAnalyzer")
3842  p.s = Sequence(SequencePlaceholder("a")+p.b)
3843  p.pth = Path(p.s)
3844  p.prune()
3845  self.assertTrue(hasattr(p, 'a'))
3846  self.assertTrue(hasattr(p, 'b'))
3847  self.assertTrue(hasattr(p, 's'))
3848  self.assertTrue(hasattr(p, 'pth'))
3849  #test unresolved SequencePlaceholder
3850  p = Process("test")
3851  p.b = EDAnalyzer("YourAnalyzer")
3852  p.s = Sequence(SequencePlaceholder("a")+p.b)
3853  p.pth = Path(p.s)
3854  p.prune(keepUnresolvedSequencePlaceholders=True)
3855  self.assertTrue(hasattr(p, 'b'))
3856  self.assertTrue(hasattr(p, 's'))
3857  self.assertTrue(hasattr(p, 'pth'))
3858  self.assertEqual(p.s.dumpPython(),'cms.Sequence(cms.SequencePlaceholder("a")+process.b)\n')
3859  #test TaskPlaceholder
3860  p = Process("test")
3861  p.a = EDProducer("MyProducer")
3862  p.b = EDProducer("YourProducer")
3863  p.s = Task(TaskPlaceholder("a"),p.b)
3864  p.pth = Path(p.s)
3865  p.prune()
3866  self.assertTrue(hasattr(p, 'a'))
3867  self.assertTrue(hasattr(p, 'b'))
3868  self.assertTrue(hasattr(p, 's'))
3869  self.assertTrue(hasattr(p, 'pth'))
3870  #test ConditionalTaskPlaceholder
3871  p = Process("test")
3872  p.a = EDProducer("MyProducer")
3873  p.b = EDProducer("YourProducer")
3874  p.s = ConditionalTask(ConditionalTaskPlaceholder("a"),p.b)
3875  p.pth = Path(p.s)
3876  p.prune()
3877  self.assertTrue(hasattr(p, 'a'))
3878  self.assertTrue(hasattr(p, 'b'))
3879  self.assertTrue(hasattr(p, 's'))
3880  self.assertTrue(hasattr(p, 'pth'))
3881  #test unresolved SequencePlaceholder
3882  p = Process("test")
3883  p.b = EDProducer("YourAnalyzer")
3884  p.s = Task(TaskPlaceholder("a"),p.b)
3885  p.pth = Path(p.s)
3886  p.prune(keepUnresolvedSequencePlaceholders=True)
3887  self.assertTrue(hasattr(p, 'b'))
3888  self.assertTrue(hasattr(p, 's'))
3889  self.assertTrue(hasattr(p, 'pth'))
3890  self.assertEqual(p.s.dumpPython(),'cms.Task(cms.TaskPlaceholder("a"), process.b)\n')
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
mps_fire.Path
Path
Definition: mps_fire.py:298
HistogramManager_cfi.VPSet
def VPSet(args)
Definition: HistogramManager_cfi.py:408

◆ testRefToPSet()

def Config.TestModuleCommand.testRefToPSet (   self)

Definition at line 3604 of file Config.py.

3604  def testRefToPSet(self):
3605  proc = Process("test")
3606  proc.top = PSet(a = int32(1))
3607  proc.ref = PSet(refToPSet_ = string("top"))
3608  proc.ref2 = PSet( a = int32(1), b = PSet( refToPSet_ = string("top")))
3609  proc.ref3 = PSet(refToPSet_ = string("ref"))
3610  proc.ref4 = VPSet(PSet(refToPSet_ = string("top")),
3611  PSet(refToPSet_ = string("ref2")))
3612  p = TestMakePSet()
3613  proc.fillProcessDesc(p)
3614  self.assertEqual((True,1),p.values["ref"][1].values["a"])
3615  self.assertEqual((True,1),p.values["ref3"][1].values["a"])
3616  self.assertEqual((True,1),p.values["ref2"][1].values["a"])
3617  self.assertEqual((True,1),p.values["ref2"][1].values["b"][1].values["a"])
3618  self.assertEqual((True,1),p.values["ref4"][1][0].values["a"])
3619  self.assertEqual((True,1),p.values["ref4"][1][1].values["a"])
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HistogramManager_cfi.VPSet
def VPSet(args)
Definition: HistogramManager_cfi.py:408

◆ testSchedule()

def Config.TestModuleCommand.testSchedule (   self)

Definition at line 3324 of file Config.py.

3324  def testSchedule(self):
3325  p = Process("test")
3326  p.a = EDAnalyzer("MyAnalyzer")
3327  p.b = EDAnalyzer("YourAnalyzer")
3328  p.c = EDAnalyzer("OurAnalyzer")
3329  p.d = EDAnalyzer("OurAnalyzer")
3330  p.path1 = Path(p.a)
3331  p.path2 = Path(p.b)
3332  p.path3 = Path(p.d)
3333 
3334  s = Schedule(p.path1,p.path2)
3335  self.assertEqual(s[0],p.path1)
3336  self.assertEqual(s[1],p.path2)
3337  p.schedule = s
3338  self.assertTrue('b' in p.schedule.moduleNames())
3339  self.assertTrue(hasattr(p, 'b'))
3340  self.assertTrue(hasattr(p, 'c'))
3341  self.assertTrue(hasattr(p, 'd'))
3342  self.assertTrue(hasattr(p, 'path1'))
3343  self.assertTrue(hasattr(p, 'path2'))
3344  self.assertTrue(hasattr(p, 'path3'))
3345  p.prune()
3346  self.assertTrue('b' in p.schedule.moduleNames())
3347  self.assertTrue(hasattr(p, 'b'))
3348  self.assertTrue(not hasattr(p, 'c'))
3349  self.assertTrue(not hasattr(p, 'd'))
3350  self.assertTrue(hasattr(p, 'path1'))
3351  self.assertTrue(hasattr(p, 'path2'))
3352  self.assertTrue(not hasattr(p, 'path3'))
3353 
3354  self.assertTrue(len(p.schedule._tasks) == 0)
3355 
3356  p = Process("test")
3357  p.a = EDAnalyzer("MyAnalyzer")
3358  p.b = EDAnalyzer("YourAnalyzer")
3359  p.c = EDAnalyzer("OurAnalyzer")
3360  p.d = EDAnalyzer("dAnalyzer")
3361  p.e = EDProducer("eProducer")
3362  p.f = EDProducer("fProducer")
3363  p.Tracer = Service("Tracer")
3364  p.path1 = Path(p.a)
3365  p.path2 = Path(p.b)
3366  p.path3 = Path(p.d)
3367  p.task1 = Task(p.e)
3368  p.task2 = Task(p.f, p.Tracer)
3369  s = Schedule(p.path1,p.path2,tasks=[p.task1,p.task2,p.task1])
3370  self.assertEqual(s[0],p.path1)
3371  self.assertEqual(s[1],p.path2)
3372  self.assertTrue(len(s._tasks) == 2)
3373  self.assertTrue(p.task1 in s._tasks)
3374  self.assertTrue(p.task2 in s._tasks)
3375  listOfTasks = list(s._tasks)
3376  self.assertTrue(len(listOfTasks) == 2)
3377  self.assertTrue(p.task1 == listOfTasks[0])
3378  self.assertTrue(p.task2 == listOfTasks[1])
3379  p.schedule = s
3380  self.assertTrue('b' in p.schedule.moduleNames())
3381 
3382  process2 = Process("test")
3383  process2.a = EDAnalyzer("MyAnalyzer")
3384  process2.e = EDProducer("eProducer")
3385  process2.path1 = Path(process2.a)
3386  process2.task1 = Task(process2.e)
3387  process2.schedule = Schedule(process2.path1,tasks=process2.task1)
3388  listOfTasks = list(process2.schedule._tasks)
3389  self.assertTrue(listOfTasks[0] == process2.task1)
3390 
3391  # test Schedule copy
3392  s2 = s.copy()
3393  self.assertEqual(s2[0],p.path1)
3394  self.assertEqual(s2[1],p.path2)
3395  self.assertTrue(len(s2._tasks) == 2)
3396  self.assertTrue(p.task1 in s2._tasks)
3397  self.assertTrue(p.task2 in s2._tasks)
3398  listOfTasks = list(s2._tasks)
3399  self.assertTrue(len(listOfTasks) == 2)
3400  self.assertTrue(p.task1 == listOfTasks[0])
3401  self.assertTrue(p.task2 == listOfTasks[1])
3402 
3403  names = s.moduleNames()
3404  self.assertTrue(names == set(['a', 'b', 'e', 'Tracer', 'f']))
3405  #adding a path not attached to the Process should cause an exception
3406  p = Process("test")
3407  p.a = EDAnalyzer("MyAnalyzer")
3408  path1 = Path(p.a)
3409  s = Schedule(path1)
3410  self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
3411 
3412  #make sure anonymous sequences work
3413  p = Process("test")
3414  p.a = EDAnalyzer("MyAnalyzer")
3415  p.b = EDAnalyzer("MyOtherAnalyzer")
3416  p.c = EDProducer("MyProd")
3417  path1 = Path(p.c*Sequence(p.a+p.b))
3418  s = Schedule(path1)
3419  self.assertTrue('a' in s.moduleNames())
3420  self.assertTrue('b' in s.moduleNames())
3421  self.assertTrue('c' in s.moduleNames())
3422  p.path1 = path1
3423  p.schedule = s
3424  p.prune()
3425  self.assertTrue('a' in s.moduleNames())
3426  self.assertTrue('b' in s.moduleNames())
3427  self.assertTrue('c' in s.moduleNames())
3428 
mps_fire.Path
Path
Definition: mps_fire.py:298

◆ testSecSource()

def Config.TestModuleCommand.testSecSource (   self)

Definition at line 2651 of file Config.py.

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

2651  def testSecSource(self):
2652  p = Process('test')
2653  p.a = SecSource("MySecSource")
2654  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),'process.a = cms.SecSource("MySecSource")')
2655 
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2023
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:95

◆ testSequence()

def Config.TestModuleCommand.testSequence (   self)

Definition at line 2727 of file Config.py.

References str.

2727  def testSequence(self):
2728  p = Process('test')
2729  p.a = EDAnalyzer("MyAnalyzer")
2730  p.b = EDAnalyzer("YourAnalyzer")
2731  p.c = EDAnalyzer("OurAnalyzer")
2732  p.s = Sequence(p.a*p.b)
2733  self.assertEqual(str(p.s),'a+b')
2734  self.assertEqual(p.s.label_(),'s')
2735  path = Path(p.c+p.s)
2736  self.assertEqual(str(path),'c+a+b')
2737  p._validateSequence(path, 'p1')
2738  notInProcess = EDAnalyzer('NotInProcess')
2739  p2 = Path(p.c+p.s*notInProcess)
2740  self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
2741 
mps_fire.Path
Path
Definition: mps_fire.py:298
str
#define str(s)
Definition: TestProcessor.cc:55

◆ testSequence2()

def Config.TestModuleCommand.testSequence2 (   self)

Definition at line 2742 of file Config.py.

2742  def testSequence2(self):
2743  p = Process('test')
2744  p.a = EDAnalyzer("MyAnalyzer")
2745  p.b = EDAnalyzer("YourAnalyzer")
2746  p.c = EDAnalyzer("OurAnalyzer")
2747  testseq = Sequence(p.a*p.b)
2748  p.s = testseq
2749  #p.y = testseq
2750  self.assertRaises(ValueError, p.__setattr__, "y", testseq)
2751 

◆ testServiceInProcess()

def Config.TestModuleCommand.testServiceInProcess (   self)

Definition at line 2752 of file Config.py.

2752  def testServiceInProcess(self):
2753  service = Service("d")
2754  self.assertFalse(service._inProcess)
2755  process = Process("test")
2756  process.d = service
2757  self.assertTrue(service._inProcess)
2758  service2 = Service("d")
2759  process.d = service2
2760  self.assertFalse(service._inProcess)
2761  self.assertTrue(service2._inProcess)
2762  del process.d
2763  self.assertFalse(service2._inProcess)
2764 

◆ testSubProcess()

def Config.TestModuleCommand.testSubProcess (   self)

Definition at line 3569 of file Config.py.

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

3569  def testSubProcess(self):
3570  process = Process("Parent")
3571  subProcess = Process("Child")
3572  subProcess.a = EDProducer("A")
3573  subProcess.p = Path(subProcess.a)
3574  subProcess.add_(Service("Foo"))
3575  process.addSubProcess(SubProcess(subProcess))
3576  d = process.dumpPython()
3577  equalD ="""parentProcess = process
3578 process.a = cms.EDProducer("A")
3579 process.Foo = cms.Service("Foo")
3580 process.p = cms.Path(process.a)
3581 childProcess = process
3582 process = parentProcess
3583 process.addSubProcess(cms.SubProcess(process = childProcess, SelectEvents = cms.untracked.PSet(
3584 ), outputCommands = cms.untracked.vstring()))"""
3585  equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcesses_()[0])))
3586  # SubProcesses are dumped before Services, so in order to
3587  # craft the dump of the Parent and Child manually the dump
3588  # of the Parent needs to be split at the MessageLogger
3589  # boundary (now when it is part of Process by default),
3590  # and insert the dump of the Child between the top part of
3591  # the Parent (before MessageLogger) and the bottom part of
3592  # the Parent (after and including MessageLogger)
3593  messageLoggerSplit = 'process.MessageLogger = cms.Service'
3594  parentDumpSplit = Process('Parent').dumpPython().split(messageLoggerSplit)
3595  childProcess = Process('Child')
3596  del childProcess.MessageLogger
3597  combinedDump = parentDumpSplit[0] + childProcess.dumpPython() + messageLoggerSplit + parentDumpSplit[1]
3598  self.assertEqual(_lineDiff(d, combinedDump), equalD)
3599  p = TestMakePSet()
3600  process.fillProcessDesc(p)
3601  self.assertEqual((True,['a']),p.values["subProcesses"][1][0].values["process"][1].values['@all_modules'])
3602  self.assertEqual((True,['p']),p.values["subProcesses"][1][0].values["process"][1].values['@paths'])
3603  self.assertEqual({'@service_type':(True,'Foo')}, p.values["subProcesses"][1][0].values["process"][1].values["services"][1][0].values)
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2023
mps_fire.Path
Path
Definition: mps_fire.py:298
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:95
str
#define str(s)
Definition: TestProcessor.cc:55

◆ testSwitchProducer()

def Config.TestModuleCommand.testSwitchProducer (   self)

Definition at line 3620 of file Config.py.

References jetsAK4_CHS_cff.sort.

3620  def testSwitchProducer(self):
3621  proc = Process("test")
3622  proc.sp = SwitchProducerTest(test2 = EDProducer("Foo",
3623  a = int32(1),
3624  b = PSet(c = int32(2))),
3625  test1 = EDProducer("Bar",
3626  aa = int32(11),
3627  bb = PSet(cc = int32(12))))
3628  self.assertEqual(proc.sp.label_(), "sp")
3629  self.assertEqual(proc.sp.test1.label_(), "sp@test1")
3630  self.assertEqual(proc.sp.test2.label_(), "sp@test2")
3631 
3632  proc.a = EDProducer("A")
3633  proc.s = Sequence(proc.a + proc.sp)
3634  proc.t = Task(proc.a, proc.sp)
3635  proc.p = Path()
3636  proc.p.associate(proc.t)
3637  p = TestMakePSet()
3638  proc.fillProcessDesc(p)
3639  self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
3640  self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
3641  self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
3642  all_cases = copy.deepcopy(p.values["sp"][1].values["@all_cases"])
3643  all_cases[1].sort() # names of all cases come via dict, i.e. their order is undefined
3644  self.assertEqual((True, ["sp@test1", "sp@test2"]), all_cases)
3645  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
3646  self.assertEqual(["a", "sp", "sp@test1", "sp@test2"], p.values["@all_modules"][1])
3647  self.assertEqual((True,"EDProducer"), p.values["sp@test1"][1].values["@module_edm_type"])
3648  self.assertEqual((True,"Bar"), p.values["sp@test1"][1].values["@module_type"])
3649  self.assertEqual((True,"EDProducer"), p.values["sp@test2"][1].values["@module_edm_type"])
3650  self.assertEqual((True,"Foo"), p.values["sp@test2"][1].values["@module_type"])
3651  dump = proc.dumpPython()
3652  self.assertEqual(dump.find('@'), -1)
3653  self.assertEqual(specialImportRegistry.getSpecialImports(), ["from test import SwitchProducerTest"])
3654  self.assertTrue(dump.find("\nfrom test import SwitchProducerTest\n") != -1)
3655 
3656  # EDAlias as non-chosen case
3657  proc = Process("test")
3658  proc.sp = SwitchProducerTest(test2 = EDProducer("Foo",
3659  a = int32(1),
3660  b = PSet(c = int32(2))),
3661  test1 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
3662  proc.a = EDProducer("A")
3663  proc.s = Sequence(proc.a + proc.sp)
3664  proc.t = Task(proc.a, proc.sp)
3665  proc.p = Path()
3666  proc.p.associate(proc.t)
3667  p = TestMakePSet()
3668  proc.fillProcessDesc(p)
3669  self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
3670  self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
3671  self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
3672  all_cases = copy.deepcopy(p.values["sp"][1].values["@all_cases"])
3673  all_cases[1].sort()
3674  self.assertEqual((True, ["sp@test1", "sp@test2"]), all_cases)
3675  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
3676  self.assertEqual(["a", "sp", "sp@test2"], p.values["@all_modules"][1])
3677  self.assertEqual(["sp@test1"], p.values["@all_aliases"][1])
3678  self.assertEqual((True,"EDProducer"), p.values["sp@test2"][1].values["@module_edm_type"])
3679  self.assertEqual((True,"Foo"), p.values["sp@test2"][1].values["@module_type"])
3680  self.assertEqual((True,"EDAlias"), p.values["sp@test1"][1].values["@module_edm_type"])
3681  self.assertEqual((True,"Bar"), p.values["sp@test1"][1].values["a"][1][0].values["type"])
3682 
3683  # EDAlias as chosen case
3684  proc = Process("test")
3685  proc.sp = SwitchProducerTest(test1 = EDProducer("Foo",
3686  a = int32(1),
3687  b = PSet(c = int32(2))),
3688  test2 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
3689  proc.a = EDProducer("A")
3690  proc.s = Sequence(proc.a + proc.sp)
3691  proc.t = Task(proc.a, proc.sp)
3692  proc.p = Path()
3693  proc.p.associate(proc.t)
3694  p = TestMakePSet()
3695  proc.fillProcessDesc(p)
3696  self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
3697  self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
3698  self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
3699  self.assertEqual((True, ["sp@test1", "sp@test2"]), p.values["sp"][1].values["@all_cases"])
3700  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
3701  self.assertEqual(["a", "sp", "sp@test1"], p.values["@all_modules"][1])
3702  self.assertEqual(["sp@test2"], p.values["@all_aliases"][1])
3703  self.assertEqual((True,"EDProducer"), p.values["sp@test1"][1].values["@module_edm_type"])
3704  self.assertEqual((True,"Foo"), p.values["sp@test1"][1].values["@module_type"])
3705  self.assertEqual((True,"EDAlias"), p.values["sp@test2"][1].values["@module_edm_type"])
3706  self.assertEqual((True,"Bar"), p.values["sp@test2"][1].values["a"][1][0].values["type"])
3707 
3708  # ConditionalTask
3709  proc = Process("test")
3710  proc.spct = SwitchProducerTest(test2 = EDProducer("Foo",
3711  a = int32(1),
3712  b = PSet(c = int32(2))),
3713  test1 = EDProducer("Bar",
3714  aa = int32(11),
3715  bb = PSet(cc = int32(12))),
3716  test3 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
3717  proc.spp = proc.spct.clone()
3718  proc.a = EDProducer("A")
3719  proc.ct = ConditionalTask(proc.spct)
3720  proc.p = Path(proc.a, proc.ct)
3721  proc.pp = Path(proc.a + proc.spp)
3722  p = TestMakePSet()
3723  proc.fillProcessDesc(p)
3724  self.assertEqual(["a", "spct", "spct@test1", "spct@test2", "spp", "spp@test1", "spp@test2"], p.values["@all_modules"][1])
3725  self.assertEqual(["a", "#", "spct", "spct@test1", "spct@test2", "@"], p.values["p"][1])
3726  self.assertEqual(["a", "spp", "#", "spp@test1", "spp@test2", "@"], p.values["pp"][1])
3727 
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
mps_fire.Path
Path
Definition: mps_fire.py:298
jetsAK4_CHS_cff.sort
sort
Definition: jetsAK4_CHS_cff.py:39
HistogramManager_cfi.VPSet
def VPSet(args)
Definition: HistogramManager_cfi.py:408

◆ testTask()

def Config.TestModuleCommand.testTask (   self)

Definition at line 2765 of file Config.py.

2765  def testTask(self):
2766 
2767  # create some objects to use in tests
2768  edanalyzer = EDAnalyzer("a")
2769  edproducer = EDProducer("b")
2770  edproducer2 = EDProducer("b2")
2771  edproducer3 = EDProducer("b3")
2772  edproducer4 = EDProducer("b4")
2773  edproducer8 = EDProducer("b8")
2774  edproducer9 = EDProducer("b9")
2775  edfilter = EDFilter("c")
2776  service = Service("d")
2777  service3 = Service("d", v = untracked.uint32(3))
2778  essource = ESSource("e")
2779  esproducer = ESProducer("f")
2780  testTask2 = Task()
2781 
2782  # test adding things to Tasks
2783  testTask1 = Task(edproducer, edfilter)
2784  self.assertRaises(RuntimeError, testTask1.add, edanalyzer)
2785  testTask1.add(essource, service)
2786  testTask1.add(essource, esproducer)
2787  testTask1.add(testTask2)
2788  coll = testTask1._collection
2789  self.assertTrue(edproducer in coll)
2790  self.assertTrue(edfilter in coll)
2791  self.assertTrue(service in coll)
2792  self.assertTrue(essource in coll)
2793  self.assertTrue(esproducer in coll)
2794  self.assertTrue(testTask2 in coll)
2795  self.assertTrue(len(coll) == 6)
2796  self.assertTrue(len(testTask2._collection) == 0)
2797 
2798  taskContents = []
2799  for i in testTask1:
2800  taskContents.append(i)
2801  self.assertTrue(taskContents == [edproducer, edfilter, essource, service, esproducer, testTask2])
2802 
2803  # test attaching Task to Process
2804  process = Process("test")
2805 
2806  process.mproducer = edproducer
2807  process.mproducer2 = edproducer2
2808  process.mfilter = edfilter
2809  process.messource = essource
2810  process.mesproducer = esproducer
2811  process.d = service
2812 
2813  testTask3 = Task(edproducer, edproducer2)
2814  testTask1.add(testTask3)
2815  process.myTask1 = testTask1
2816 
2817  # test the validation that occurs when attaching a Task to a Process
2818  # first a case that passes, then one the fails on an EDProducer
2819  # then one that fails on a service
2820  l = set()
2821  visitor = NodeNameVisitor(l)
2822  testTask1.visit(visitor)
2823  self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
2824  l2 = testTask1.moduleNames
2825  self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
2826 
2827  testTask4 = Task(edproducer3)
2828  l.clear()
2829  self.assertRaises(RuntimeError, testTask4.visit, visitor)
2830  try:
2831  process.myTask4 = testTask4
2832  self.assertTrue(False)
2833  except RuntimeError:
2834  pass
2835 
2836  testTask5 = Task(service3)
2837  l.clear()
2838  self.assertRaises(RuntimeError, testTask5.visit, visitor)
2839  try:
2840  process.myTask5 = testTask5
2841  self.assertTrue(False)
2842  except RuntimeError:
2843  pass
2844 
2845  process.d = service3
2846  process.myTask5 = testTask5
2847 
2848  # test placement into the Process and the tasks property
2849  expectedDict = { 'myTask1' : testTask1, 'myTask5' : testTask5 }
2850  expectedFixedDict = DictTypes.FixedKeysDict(expectedDict);
2851  self.assertTrue(process.tasks == expectedFixedDict)
2852  self.assertTrue(process.tasks['myTask1'] == testTask1)
2853  self.assertTrue(process.myTask1 == testTask1)
2854 
2855  # test replacing an EDProducer in a Task when calling __settattr__
2856  # for the EDProducer on the Process.
2857  process.mproducer2 = edproducer4
2858  process.d = service
2859  l = list()
2860  visitor1 = ModuleNodeVisitor(l)
2861  testTask1.visit(visitor1)
2862  l.sort(key=lambda mod: mod.__str__())
2863  expectedList = sorted([edproducer,essource,esproducer,service,edfilter,edproducer,edproducer4],key=lambda mod: mod.__str__())
2864  self.assertTrue(expectedList == l)
2865  process.myTask6 = Task()
2866  process.myTask7 = Task()
2867  process.mproducer8 = edproducer8
2868  process.myTask8 = Task(process.mproducer8)
2869  process.myTask6.add(process.myTask7)
2870  process.myTask7.add(process.myTask8)
2871  process.myTask1.add(process.myTask6)
2872  process.myTask8.add(process.myTask5)
2873 
2874  testDict = process._itemsInDependencyOrder(process.tasks)
2875  expectedLabels = ["myTask5", "myTask8", "myTask7", "myTask6", "myTask1"]
2876  expectedTasks = [process.myTask5, process.myTask8, process.myTask7, process.myTask6, process.myTask1]
2877  index = 0
2878  for testLabel, testTask in testDict.items():
2879  self.assertTrue(testLabel == expectedLabels[index])
2880  self.assertTrue(testTask == expectedTasks[index])
2881  index += 1
2882 
2883  pythonDump = testTask1.dumpPython(PrintOptions())
2884 
2885 
2886  expectedPythonDump = 'cms.Task(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer, process.mproducer2, process.myTask6)\n'
2887  self.assertTrue(pythonDump == expectedPythonDump)
2888 
2889  process.myTask5 = Task()
2890  process.myTask100 = Task()
2891  process.mproducer9 = edproducer9
2892  sequence1 = Sequence(process.mproducer8, process.myTask1, process.myTask5, testTask2, testTask3)
2893  sequence2 = Sequence(process.mproducer8 + process.mproducer9)
2894  process.sequence3 = Sequence((process.mproducer8 + process.mfilter))
2895  sequence4 = Sequence()
2896  process.path1 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+sequence4)
2897  process.path1.associate(process.myTask1, process.myTask5, testTask2, testTask3)
2898  process.path11 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+ sequence4,process.myTask1, process.myTask5, testTask2, testTask3, process.myTask100)
2899  process.path2 = Path(process.mproducer)
2900  process.path3 = Path(process.mproducer9+process.mproducer8,testTask2)
2901 
2902  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')
2903 
2904  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')
2905 
2906  # test NodeNameVisitor and moduleNames
2907  l = set()
2908  nameVisitor = NodeNameVisitor(l)
2909  process.path1.visit(nameVisitor)
2910  self.assertTrue(l == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
2911  self.assertTrue(process.path1.moduleNames() == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
2912 
2913  # test copy
2914  process.mproducer10 = EDProducer("b10")
2915  process.path21 = process.path11.copy()
2916  process.path21.replace(process.mproducer, process.mproducer10)
2917 
2918  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')
2919 
2920  # Some peculiarities of the way things work show up here. dumpPython sorts tasks and
2921  # removes duplication at the level of strings. The Task and Sequence objects themselves
2922  # remove duplicate tasks in their contents if the instances are the same (exact same python
2923  # object id which is not the same as the string representation being the same).
2924  # Also note that the mutating visitor replaces sequences and tasks that have
2925  # modified contents with their modified contents, it does not modify the sequence
2926  # or task itself.
2927  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')
2928 
2929  process.path22 = process.path21.copyAndExclude([process.d, process.mesproducer, process.mfilter])
2930  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')
2931 
2932  process.path23 = process.path22.copyAndExclude([process.messource, process.mproducer10])
2933  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')
2934 
2935  process.a = EDAnalyzer("MyAnalyzer")
2936  process.b = OutputModule("MyOutputModule")
2937  process.c = EDFilter("MyFilter")
2938  process.d = EDProducer("MyProducer")
2939  process.e = ESProducer("MyESProducer")
2940  process.f = ESSource("MyESSource")
2941  process.g = ESProducer("g")
2942  process.path24 = Path(process.a+process.b+process.c+process.d)
2943  process.path25 = process.path24.copyAndExclude([process.a,process.b,process.c])
2944  self.assertTrue(process.path25.dumpPython() == 'cms.Path(process.d)\n')
2945  #print process.path3
2946  #print process.dumpPython()
2947 
2948  process.path200 = EndPath(Sequence(process.c,Task(process.e)))
2949  process.path200.replace(process.c,process.b)
2950  process.path200.replace(process.e,process.f)
2951  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.b, cms.Task(process.f))\n")
2952  process.path200.replace(process.b,process.c)
2953  process.path200.replace(process.f,process.e)
2954  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.c, cms.Task(process.e))\n")
2955  process.path200.replace(process.c,process.a)
2956  process.path200.replace(process.e,process.g)
2957  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.a, cms.Task(process.g))\n")
2958  process.path200.replace(process.a,process.c)
2959  process.path200.replace(process.g,process.e)
2960  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.c, cms.Task(process.e))\n")
2961 
mixOne_cfi.ESProducer
ESProducer
Definition: mixOne_cfi.py:33
mps_fire.Path
Path
Definition: mps_fire.py:298
TestTask.testTask
testTask
Definition: TestTask.py:3

◆ testTaskPlaceholder()

def Config.TestModuleCommand.testTaskPlaceholder (   self)

Definition at line 3891 of file Config.py.

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

3891  def testTaskPlaceholder(self):
3892  p = Process("test")
3893  p.a = EDProducer("ma")
3894  p.b = EDAnalyzer("mb")
3895  p.t1 = Task(TaskPlaceholder("c"))
3896  p.t2 = Task(p.a, TaskPlaceholder("d"), p.t1)
3897  p.t3 = Task(TaskPlaceholder("e"))
3898  p.path1 = Path(p.b, p.t2, p.t3)
3899  p.t5 = Task(p.a, TaskPlaceholder("g"), TaskPlaceholder("t4"))
3900  p.t4 = Task(TaskPlaceholder("f"))
3901  p.endpath1 = EndPath(p.b, p.t5)
3902  p.t6 = Task(TaskPlaceholder("h"))
3903  p.t7 = Task(p.a, TaskPlaceholder("i"), p.t6)
3904  p.t8 = Task(TaskPlaceholder("j"))
3905  p.schedule = Schedule(p.path1, p.endpath1,tasks=[p.t7,p.t8])
3906  p.c = EDProducer("mc")
3907  p.d = EDProducer("md")
3908  p.e = EDProducer("me")
3909  p.f = EDProducer("mf")
3910  p.g = EDProducer("mg")
3911  p.h = EDProducer("mh")
3912  p.i = EDProducer("mi")
3913  p.j = EDProducer("mj")
3914  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
3915 """process.a = cms.EDProducer("ma")
3916 process.c = cms.EDProducer("mc")
3917 process.d = cms.EDProducer("md")
3918 process.e = cms.EDProducer("me")
3919 process.f = cms.EDProducer("mf")
3920 process.g = cms.EDProducer("mg")
3921 process.h = cms.EDProducer("mh")
3922 process.i = cms.EDProducer("mi")
3923 process.j = cms.EDProducer("mj")
3924 process.b = cms.EDAnalyzer("mb")
3925 process.t1 = cms.Task(cms.TaskPlaceholder("c"))
3926 process.t2 = cms.Task(cms.TaskPlaceholder("d"), process.a, process.t1)
3927 process.t3 = cms.Task(cms.TaskPlaceholder("e"))
3928 process.t5 = cms.Task(cms.TaskPlaceholder("g"), cms.TaskPlaceholder("t4"), process.a)
3929 process.t4 = cms.Task(cms.TaskPlaceholder("f"))
3930 process.t6 = cms.Task(cms.TaskPlaceholder("h"))
3931 process.t7 = cms.Task(cms.TaskPlaceholder("i"), process.a, process.t6)
3932 process.t8 = cms.Task(cms.TaskPlaceholder("j"))
3933 process.path1 = cms.Path(process.b, process.t2, process.t3)
3934 process.endpath1 = cms.EndPath(process.b, process.t5)
3935 process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])""")
3936  p.resolve()
3937  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
3938 """process.a = cms.EDProducer("ma")
3939 process.c = cms.EDProducer("mc")
3940 process.d = cms.EDProducer("md")
3941 process.e = cms.EDProducer("me")
3942 process.f = cms.EDProducer("mf")
3943 process.g = cms.EDProducer("mg")
3944 process.h = cms.EDProducer("mh")
3945 process.i = cms.EDProducer("mi")
3946 process.j = cms.EDProducer("mj")
3947 process.b = cms.EDAnalyzer("mb")
3948 process.t1 = cms.Task(process.c)
3949 process.t2 = cms.Task(process.a, process.d, process.t1)
3950 process.t3 = cms.Task(process.e)
3951 process.t4 = cms.Task(process.f)
3952 process.t6 = cms.Task(process.h)
3953 process.t7 = cms.Task(process.a, process.i, process.t6)
3954 process.t8 = cms.Task(process.j)
3955 process.t5 = cms.Task(process.a, process.g, process.t4)
3956 process.path1 = cms.Path(process.b, process.t2, process.t3)
3957 process.endpath1 = cms.EndPath(process.b, process.t5)
3958 process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])""")
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2023
mps_fire.Path
Path
Definition: mps_fire.py:298
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:95

◆ testTypedParameterizable()

def Config.TestModuleCommand.testTypedParameterizable (   self)

Definition at line 2210 of file Config.py.

2210  def testTypedParameterizable(self):
2211  p = _TypedParameterizable("blah", b=int32(1))
2212  #see if copy works deeply
2213  other = p.copy()
2214  other.b = 2
2215  self.assertNotEqual(p.b,other.b)
2216 

◆ testUsing()

def Config.TestModuleCommand.testUsing (   self)

Definition at line 3462 of file Config.py.

3462  def testUsing(self):
3463  p = Process('test')
3464  p.block = PSet(a = int32(1))
3465  p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
3466  self.assertEqual(p.modu.a.value(),1)
3467  self.assertEqual(p.modu.b.value(),2)
3468 

Member Data Documentation

◆ a

Config.TestModuleCommand.a
static

Definition at line 2515 of file Config.py.

◆ b

Config.TestModuleCommand.b
static

Definition at line 2532 of file Config.py.

◆ c

Config.TestModuleCommand.c
static

Definition at line 2533 of file Config.py.

◆ d

Config.TestModuleCommand.d
static

Definition at line 2521 of file Config.py.

◆ e

Config.TestModuleCommand.e
static

Definition at line 2535 of file Config.py.

◆ f

Config.TestModuleCommand.f
static

Definition at line 2536 of file Config.py.

◆ g

Config.TestModuleCommand.g
static

Definition at line 2537 of file Config.py.

◆ maxDiff

Config.TestModuleCommand.maxDiff

Definition at line 4520 of file Config.py.

◆ p

Config.TestModuleCommand.p
static

Definition at line 2514 of file Config.py.

Referenced by Electron.Electron.ptErr().

◆ p2

Config.TestModuleCommand.p2
static

Definition at line 2519 of file Config.py.

◆ proc_mod_

Config.TestModuleCommand.proc_mod_

Definition at line 4185 of file Config.py.

◆ process

Config.TestModuleCommand.process
static

Definition at line 2630 of file Config.py.

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

◆ r

Config.TestModuleCommand.r
static

Definition at line 2518 of file Config.py.

◆ s

Config.TestModuleCommand.s
static

Definition at line 2517 of file Config.py.

◆ s1

Config.TestModuleCommand.s1
static

Definition at line 2638 of file Config.py.

◆ s2

Config.TestModuleCommand.s2
static

Definition at line 2628 of file Config.py.

◆ s3

Config.TestModuleCommand.s3
static

Definition at line 2640 of file Config.py.

◆ schedule

Config.TestModuleCommand.schedule
static

Definition at line 2520 of file Config.py.

◆ task1

Config.TestModuleCommand.task1
static

Definition at line 2542 of file Config.py.

◆ task2

Config.TestModuleCommand.task2
static

Definition at line 2540 of file Config.py.

◆ task3

Config.TestModuleCommand.task3
static

Definition at line 2539 of file Config.py.

◆ task4

Config.TestModuleCommand.task4
static

Definition at line 2541 of file Config.py.

◆ task5

Config.TestModuleCommand.task5
static

Definition at line 2538 of file Config.py.

◆ tasks

Config.TestModuleCommand.tasks
static

Definition at line 2548 of file Config.py.

Generated for CMSSW Reference Manual by doxygen 1.8.14