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 2285 of file Config.py.

Member Function Documentation

◆ setUp()

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

Definition at line 2286 of file Config.py.

2286  def setUp(self):
2287  """Nothing to do """
2288  None

◆ testCloneSequence()

def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 3352 of file Config.py.

References l1ctLayer2EG_cff.id, and str.

3352  def testCloneSequence(self):
3353  p = Process("test")
3354  a = EDAnalyzer("MyAnalyzer")
3355  p.a = a
3356  a.setLabel("a")
3357  b = EDAnalyzer("YOurAnalyzer")
3358  p.b = b
3359  b.setLabel("b")
3360  path = Path(a * b)
3361  p.path = Path(p.a*p.b)
3362  lookuptable = {id(a): p.a, id(b): p.b}
3363  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
3364  #lookuptable = p._cloneToObjectDict
3365  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
3366  self.assertEqual(str(path),str(p.path))
3367 
l1ctLayer2EG_cff.id
id
Definition: l1ctLayer2EG_cff.py:85
mps_fire.Path
Path
Definition: mps_fire.py:298
str
#define str(s)
Definition: TestProcessor.cc:56

◆ testConditionalTask()

def Config.TestModuleCommand.testConditionalTask (   self)

Definition at line 3074 of file Config.py.

3074  def testConditionalTask(self):
3075 
3076  # create some objects to use in tests
3077  edanalyzer = EDAnalyzer("a")
3078  edproducer = EDProducer("b")
3079  edproducer2 = EDProducer("b2")
3080  edproducer3 = EDProducer("b3")
3081  edproducer4 = EDProducer("b4")
3082  edproducer8 = EDProducer("b8")
3083  edproducer9 = EDProducer("b9")
3084  edfilter = EDFilter("c")
3085  service = Service("d")
3086  service3 = Service("d", v = untracked.uint32(3))
3087  essource = ESSource("e")
3088  esproducer = ESProducer("f")
3089  testTask2 = Task()
3090  testCTask2 = ConditionalTask()
3091 
3092  # test adding things to Tasks
3093  testTask1 = ConditionalTask(edproducer, edfilter)
3094  self.assertRaises(RuntimeError, testTask1.add, edanalyzer)
3095  testTask1.add(essource, service)
3096  testTask1.add(essource, esproducer)
3097  testTask1.add(testTask2)
3098  testTask1.add(testCTask2)
3099  coll = testTask1._collection
3100  self.assertTrue(edproducer in coll)
3101  self.assertTrue(edfilter in coll)
3102  self.assertTrue(service in coll)
3103  self.assertTrue(essource in coll)
3104  self.assertTrue(esproducer in coll)
3105  self.assertTrue(testTask2 in coll)
3106  self.assertTrue(testCTask2 in coll)
3107  self.assertTrue(len(coll) == 7)
3108  self.assertTrue(len(testTask2._collection) == 0)
3109 
3110  taskContents = []
3111  for i in testTask1:
3112  taskContents.append(i)
3113  self.assertEqual(taskContents, [edproducer, edfilter, essource, service, esproducer, testTask2, testCTask2])
3114 
3115  # test attaching Task to Process
3116  process = Process("test")
3117 
3118  process.mproducer = edproducer
3119  process.mproducer2 = edproducer2
3120  process.mfilter = edfilter
3121  process.messource = essource
3122  process.mesproducer = esproducer
3123  process.d = service
3124 
3125  testTask3 = ConditionalTask(edproducer, edproducer2)
3126  testTask1.add(testTask3)
3127  process.myTask1 = testTask1
3128 
3129  # test the validation that occurs when attaching a ConditionalTask to a Process
3130  # first a case that passes, then one the fails on an EDProducer
3131  # then one that fails on a service
3132  l = set()
3133  visitor = NodeNameVisitor(l)
3134  testTask1.visit(visitor)
3135  self.assertEqual(l, set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
3136  l2 = testTask1.moduleNames()
3137  self.assertEqual(l2, set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
3138 
3139  testTask4 = ConditionalTask(edproducer3)
3140  l.clear()
3141  self.assertRaises(RuntimeError, testTask4.visit, visitor)
3142  try:
3143  process.myTask4 = testTask4
3144  self.assertTrue(False)
3145  except RuntimeError:
3146  pass
3147 
3148  testTask5 = ConditionalTask(service3)
3149  l.clear()
3150  self.assertRaises(RuntimeError, testTask5.visit, visitor)
3151  try:
3152  process.myTask5 = testTask5
3153  self.assertTrue(False)
3154  except RuntimeError:
3155  pass
3156 
3157  process.d = service3
3158  process.myTask5 = testTask5
3159 
3160  # test placement into the Process and the tasks property
3161  expectedDict = { 'myTask1' : testTask1, 'myTask5' : testTask5 }
3162  expectedFixedDict = DictTypes.FixedKeysDict(expectedDict);
3163  self.assertEqual(process.conditionaltasks, expectedFixedDict)
3164  self.assertEqual(process.conditionaltasks['myTask1'], testTask1)
3165  self.assertEqual(process.myTask1, testTask1)
3166 
3167  # test replacing an EDProducer in a ConditionalTask when calling __settattr__
3168  # for the EDProducer on the Process.
3169  process.mproducer2 = edproducer4
3170  process.d = service
3171  l = list()
3172  visitor1 = ModuleNodeVisitor(l)
3173  testTask1.visit(visitor1)
3174  l.sort(key=lambda mod: mod.__str__())
3175  expectedList = sorted([edproducer,essource,esproducer,service,edfilter,edproducer,edproducer4],key=lambda mod: mod.__str__())
3176  self.assertEqual(expectedList, l)
3177  process.myTask6 = ConditionalTask()
3178  process.myTask7 = ConditionalTask()
3179  process.mproducer8 = edproducer8
3180  process.myTask8 = ConditionalTask(process.mproducer8)
3181  process.myTask6.add(process.myTask7)
3182  process.myTask7.add(process.myTask8)
3183  process.myTask1.add(process.myTask6)
3184  process.myTask8.add(process.myTask5)
3185  self.assertEqual(process.myTask8.dumpPython(), "cms.ConditionalTask(process.mproducer8, process.myTask5)\n")
3186 
3187  testDict = process._itemsInDependencyOrder(process.conditionaltasks)
3188  expectedLabels = ["myTask5", "myTask8", "myTask7", "myTask6", "myTask1"]
3189  expectedTasks = [process.myTask5, process.myTask8, process.myTask7, process.myTask6, process.myTask1]
3190  index = 0
3191  for testLabel, testTask in testDict.items():
3192  self.assertEqual(testLabel, expectedLabels[index])
3193  self.assertEqual(testTask, expectedTasks[index])
3194  index += 1
3195 
3196  pythonDump = testTask1.dumpPython(PrintOptions())
3197 
3198 
3199  expectedPythonDump = 'cms.ConditionalTask(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer, process.mproducer2, process.myTask6)\n'
3200  self.assertEqual(pythonDump, expectedPythonDump)
3201 
3202  process.myTask5 = ConditionalTask()
3203  self.assertEqual(process.myTask8.dumpPython(), "cms.ConditionalTask(process.mproducer8, process.myTask5)\n")
3204  process.myTask100 = ConditionalTask()
3205  process.mproducer9 = edproducer9
3206  sequence1 = Sequence(process.mproducer8, process.myTask1, process.myTask5, testTask2, testTask3)
3207  sequence2 = Sequence(process.mproducer8 + process.mproducer9)
3208  process.sequence3 = Sequence((process.mproducer8 + process.mfilter))
3209  sequence4 = Sequence()
3210  process.path1 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+sequence4)
3211  process.path1.associate(process.myTask1, process.myTask5, testTask2, testTask3)
3212  process.path11 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+ sequence4,process.myTask1, process.myTask5, testTask2, testTask3, process.myTask100)
3213  process.path2 = Path(process.mproducer)
3214  process.path3 = Path(process.mproducer9+process.mproducer8,testTask2)
3215 
3216  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')
3217 
3218  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')
3219 
3220  # test NodeNameVisitor and moduleNames
3221  l = set()
3222  nameVisitor = NodeNameVisitor(l)
3223  process.path1.visit(nameVisitor)
3224  self.assertTrue(l == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
3225  self.assertTrue(process.path1.moduleNames() == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
3226 
3227  # test copy
3228  process.mproducer10 = EDProducer("b10")
3229  process.path21 = process.path11.copy()
3230  process.path21.replace(process.mproducer, process.mproducer10)
3231 
3232  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')
3233 
3234  # Some peculiarities of the way things work show up here. dumpPython sorts tasks and
3235  # removes duplication at the level of strings. The Task and Sequence objects themselves
3236  # remove duplicate tasks in their contents if the instances are the same (exact same python
3237  # object id which is not the same as the string representation being the same).
3238  # Also note that the mutating visitor replaces sequences and tasks that have
3239  # modified contents with their modified contents, it does not modify the sequence
3240  # or task itself.
3241  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')
3242 
3243  process.path22 = process.path21.copyAndExclude([process.d, process.mesproducer, process.mfilter])
3244  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')
3245 
3246  process.path23 = process.path22.copyAndExclude([process.messource, process.mproducer10])
3247  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')
3248 
3249  process = Process("Test")
3250 
3251  process.b = EDProducer("b")
3252  process.b2 = EDProducer("b2")
3253  process.b3 = EDProducer("b3")
3254  process.p = Path(process.b, ConditionalTask(process.b3, process.b2))
3255  p = TestMakePSet()
3256  process.fillProcessDesc(p)
3257  self.assertEqual(p.values["@all_modules"], (True, ['b', 'b2', 'b3']))
3258  self.assertEqual(p.values["@paths"], (True, ['p']))
3259  self.assertEqual(p.values["p"], (True, ['b','#','b2','b3','@']))
3260 
3261 
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 4078 of file Config.py.

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

4078  def testConditionalTaskPlaceholder(self):
4079  p = Process("test")
4080  p.a = EDProducer("ma")
4081  p.b = EDAnalyzer("mb")
4082  p.t1 = ConditionalTask(ConditionalTaskPlaceholder("c"))
4083  p.t2 = ConditionalTask(p.a, ConditionalTaskPlaceholder("d"), p.t1)
4084  p.t3 = ConditionalTask(ConditionalTaskPlaceholder("e"))
4085  p.path1 = Path(p.b, p.t2, p.t3)
4086  p.t5 = ConditionalTask(p.a, ConditionalTaskPlaceholder("g"), ConditionalTaskPlaceholder("t4"))
4087  p.t4 = ConditionalTask(ConditionalTaskPlaceholder("f"))
4088  p.path2 = Path(p.b, p.t5)
4089  p.schedule = Schedule(p.path1, p.path2)
4090  p.c = EDProducer("mc")
4091  p.d = EDProducer("md")
4092  p.e = EDProducer("me")
4093  p.f = EDProducer("mf")
4094  p.g = EDProducer("mg")
4095  p.h = EDProducer("mh")
4096  p.i = EDProducer("mi")
4097  p.j = EDProducer("mj")
4098  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
4099 """process.a = cms.EDProducer("ma")
4100 process.c = cms.EDProducer("mc")
4101 process.d = cms.EDProducer("md")
4102 process.e = cms.EDProducer("me")
4103 process.f = cms.EDProducer("mf")
4104 process.g = cms.EDProducer("mg")
4105 process.h = cms.EDProducer("mh")
4106 process.i = cms.EDProducer("mi")
4107 process.j = cms.EDProducer("mj")
4108 process.b = cms.EDAnalyzer("mb")
4109 process.t1 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("c"))
4110 process.t2 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("d"), process.a, process.t1)
4111 process.t3 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("e"))
4112 process.t5 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("g"), cms.ConditionalTaskPlaceholder("t4"), process.a)
4113 process.t4 = cms.ConditionalTask(cms.ConditionalTaskPlaceholder("f"))
4114 process.path1 = cms.Path(process.b, process.t2, process.t3)
4115 process.path2 = cms.Path(process.b, process.t5)
4116 process.schedule = cms.Schedule(*[ process.path1, process.path2 ])""")
4117  p.resolve()
4118  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
4119 """process.a = cms.EDProducer("ma")
4120 process.c = cms.EDProducer("mc")
4121 process.d = cms.EDProducer("md")
4122 process.e = cms.EDProducer("me")
4123 process.f = cms.EDProducer("mf")
4124 process.g = cms.EDProducer("mg")
4125 process.h = cms.EDProducer("mh")
4126 process.i = cms.EDProducer("mi")
4127 process.j = cms.EDProducer("mj")
4128 process.b = cms.EDAnalyzer("mb")
4129 process.t1 = cms.ConditionalTask(process.c)
4130 process.t2 = cms.ConditionalTask(process.a, process.d, process.t1)
4131 process.t3 = cms.ConditionalTask(process.e)
4132 process.t4 = cms.ConditionalTask(process.f)
4133 process.t5 = cms.ConditionalTask(process.a, process.g, process.t4)
4134 process.path1 = cms.Path(process.b, process.t2, process.t3)
4135 process.path2 = cms.Path(process.b, process.t5)
4136 process.schedule = cms.Schedule(*[ process.path1, process.path2 ])""")
4137 
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2095
mps_fire.Path
Path
Definition: mps_fire.py:298
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:96

◆ testContains()

def Config.TestModuleCommand.testContains (   self)

Definition at line 3368 of file Config.py.

3368  def testContains(self):
3369 
3370  a = EDProducer("a")
3371  b = EDProducer("b")
3372  c = EDProducer("c")
3373  d = EDProducer("d")
3374  e = EDProducer("e")
3375  f = EDProducer("f")
3376  g = EDProducer("g")
3377  h = EDProducer("h")
3378  i = EDProducer("i")
3379  j = EDProducer("j")
3380  k = EDProducer("k")
3381  l = EDProducer("l")
3382  m = EDProducer("m")
3383  n = EDProducer("n")
3384 
3385  seq1 = Sequence(e)
3386  task1 = Task(g)
3387  ctask1 = ConditionalTask(h)
3388  path = Path(a * c * seq1, task1, ctask1)
3389 
3390  self.assertTrue(path.contains(a))
3391  self.assertFalse(path.contains(b))
3392  self.assertTrue(path.contains(c))
3393  self.assertFalse(path.contains(d))
3394  self.assertTrue(path.contains(e))
3395  self.assertFalse(path.contains(f))
3396  self.assertTrue(path.contains(g))
3397  self.assertTrue(path.contains(h))
3398 
3399  endpath = EndPath(h * i)
3400  self.assertFalse(endpath.contains(b))
3401  self.assertTrue(endpath.contains(i))
3402 
3403  seq = Sequence(a * c)
3404  self.assertFalse(seq.contains(b))
3405  self.assertTrue(seq.contains(c))
3406 
3407  task2 = Task(l)
3408  task = Task(j, k, task2)
3409  self.assertFalse(task.contains(b))
3410  self.assertTrue(task.contains(j))
3411  self.assertTrue(task.contains(k))
3412  self.assertTrue(task.contains(l))
3413 
3414  task3 = Task(m)
3415  path2 = Path(n)
3416  sch = Schedule(path, path2, tasks=[task,task3])
3417  self.assertFalse(sch.contains(b))
3418  self.assertTrue(sch.contains(a))
3419  self.assertTrue(sch.contains(c))
3420  self.assertTrue(sch.contains(e))
3421  self.assertTrue(sch.contains(g))
3422  self.assertTrue(sch.contains(n))
3423  self.assertTrue(sch.contains(j))
3424  self.assertTrue(sch.contains(k))
3425  self.assertTrue(sch.contains(l))
3426  self.assertTrue(sch.contains(m))
3427 
3428  ctask2 = ConditionalTask(l, task1)
3429  ctask = ConditionalTask(j, k, ctask2)
3430  self.assertFalse(ctask.contains(b))
3431  self.assertTrue(ctask.contains(j))
3432  self.assertTrue(ctask.contains(k))
3433  self.assertTrue(ctask.contains(l))
3434  self.assertTrue(ctask.contains(g))
3435 
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 4138 of file Config.py.

References ConfigBuilder.dumpPython().

4138  def testDelete(self):
4139  p = Process("test")
4140  p.a = EDAnalyzer("MyAnalyzer")
4141  p.b = EDAnalyzer("YourAnalyzer")
4142  p.c = EDAnalyzer("OurAnalyzer")
4143  p.d = EDAnalyzer("OurAnalyzer")
4144  p.e = EDAnalyzer("OurAnalyzer")
4145  p.f = EDAnalyzer("OurAnalyzer")
4146  p.g = EDProducer("OurProducer")
4147  p.h = EDProducer("YourProducer")
4148  p.i = SwitchProducerTest(
4149  test1 = EDProducer("OneProducer"),
4150  test2 = EDProducer("TwoProducer")
4151  )
4152  p.t1 = Task(p.g, p.h, p.i)
4153  t2 = Task(p.g, p.h, p.i)
4154  t3 = Task(p.g, p.h)
4155  p.t4 = Task(p.h)
4156  p.ct1 = ConditionalTask(p.g, p.h, p.i)
4157  ct2 = ConditionalTask(p.g, p.h)
4158  ct3 = ConditionalTask(p.g, p.h)
4159  p.ct4 = ConditionalTask(p.h)
4160  p.s = Sequence(p.d+p.e)
4161  p.path1 = Path(p.a+p.f+p.s,t2,ct2)
4162  p.path2 = Path(p.a)
4163  p.path3 = Path(ct3, p.ct4)
4164  p.endpath2 = EndPath(p.b)
4165  p.endpath1 = EndPath(p.b+p.f)
4166  p.schedule = Schedule(p.path2, p.path3, p.endpath2, tasks=[t3, p.t4])
4167  self.assertTrue(hasattr(p, 'f'))
4168  self.assertTrue(hasattr(p, 'g'))
4169  self.assertTrue(hasattr(p, 'i'))
4170  del p.e
4171  del p.f
4172  del p.g
4173  del p.i
4174  self.assertFalse(hasattr(p, 'f'))
4175  self.assertFalse(hasattr(p, 'g'))
4176  self.assertEqual(p.t1.dumpPython(), 'cms.Task(process.h)\n')
4177  self.assertEqual(p.ct1.dumpPython(), 'cms.ConditionalTask(process.h)\n')
4178  self.assertEqual(p.s.dumpPython(), 'cms.Sequence(process.d)\n')
4179  self.assertEqual(p.path1.dumpPython(), 'cms.Path(process.a+process.s, cms.ConditionalTask(process.h), cms.Task(process.h))\n')
4180  self.assertEqual(p.endpath1.dumpPython(), 'cms.EndPath(process.b)\n')
4181  self.assertEqual(p.path3.dumpPython(), 'cms.Path(cms.ConditionalTask(process.h), process.ct4)\n')
4182  del p.s
4183  self.assertEqual(p.path1.dumpPython(), 'cms.Path(process.a+(process.d), cms.ConditionalTask(process.h), cms.Task(process.h))\n')
4184  self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(*[ process.path2, process.path3, process.endpath2 ], tasks=[cms.Task(process.h), process.t4])\n')
4185  del p.path2
4186  self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(*[ process.path3, process.endpath2 ], tasks=[cms.Task(process.h), process.t4])\n')
4187  del p.path3
4188  self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(*[ process.endpath2 ], tasks=[cms.Task(process.h), process.t4])\n')
4189  del p.endpath2
4190  self.assertEqual(p.schedule_().dumpPython(), 'cms.Schedule(tasks=[cms.Task(process.h), process.t4])\n')
4191  del p.t4
4192  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:96

◆ testExamples()

def Config.TestModuleCommand.testExamples (   self)

Definition at line 3638 of file Config.py.

References Types.untracked.

3638  def testExamples(self):
3639  p = Process("Test")
3640  p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
3641  p.foos = EDProducer("FooProducer")
3642  p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
3643  p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
3644  p.bars.foos = 'Foosball'
3645  self.assertEqual(p.bars.foos, InputTag('Foosball'))
3646  p.p = Path(p.foos*p.bars)
3647  p.e = EndPath(p.out)
3648  p.add_(Service("MessageLogger"))
3649 
ProducerED_cfi.InputTag
InputTag
Definition: ProducerED_cfi.py:5
CollectionTags_cfi.Source
Source
Definition: CollectionTags_cfi.py:11
Types.untracked
untracked
Definition: Types.py:34
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 3313 of file Config.py.

References str.

3313  def testFinalPath(self):
3314  p = Process("test")
3315  p.a = OutputModule("MyOutputModule")
3316  p.b = OutputModule("YourOutputModule")
3317  p.c = OutputModule("OurOutputModule")
3318  path = FinalPath(p.a)
3319  path *= p.b
3320  path += p.c
3321  self.assertEqual(str(path),'a+b+c')
3322  path = FinalPath(p.a*p.b+p.c)
3323  self.assertEqual(str(path),'a+b+c')
3324  path = FinalPath(p.a+ p.b*p.c)
3325  self.assertEqual(str(path),'a+b+c')
3326  path = FinalPath(p.a*(p.b+p.c))
3327  self.assertEqual(str(path),'a+b+c')
3328  p.es = ESProducer("AnESProducer")
3329  self.assertRaises(TypeError,FinalPath,p.es)
3330 
3331  t = FinalPath()
3332  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.FinalPath()\n')
3333 
3334  t = FinalPath(p.a)
3335  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.FinalPath(process.a)\n')
3336 
3337  self.assertRaises(TypeError, FinalPath, Task())
3338  self.assertRaises(TypeError, FinalPath, p.a, Task())
3339 
3340  p.prod = EDProducer("prodName")
3341  p.t1 = Task(p.prod)
3342  self.assertRaises(TypeError, FinalPath, p.a, p.t1, Task(), p.t1)
3343 
3344  p.prod = EDProducer("prodName")
3345  p.t1 = ConditionalTask(p.prod)
3346  self.assertRaises(TypeError, FinalPath, p.a, p.t1, ConditionalTask(), p.t1)
3347 
3348  p.t = FinalPath(p.a)
3349  p.a = OutputModule("ReplacedOutputModule")
3350  self.assertEqual(p.t.dumpPython(PrintOptions()), 'cms.FinalPath(process.a)\n')
3351 
mixOne_cfi.ESProducer
ESProducer
Definition: mixOne_cfi.py:33
str
#define str(s)
Definition: TestProcessor.cc:56

◆ testFreeze()

def Config.TestModuleCommand.testFreeze (   self)

Definition at line 3670 of file Config.py.

3670  def testFreeze(self):
3671  process = Process("Freeze")
3672  m = EDProducer("M", p=PSet(i = int32(1)))
3673  m.p.i = 2
3674  process.m = m
3675  # should be frozen
3676  #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
3677  #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
3678  #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
3679  #self.assertRaises(ValueError, setattr, m, 'j', 1)
3680  # But OK to change through the process
3681  process.m.p.i = 4
3682  self.assertEqual(process.m.p.i.value(), 4)
3683  process.m.p = PSet(j=int32(1))
3684  # should work to clone it, though
3685  m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
3686  m2.p.i = 6
3687  m2.j = 8
PSet
Definition: PSet.py:1

◆ testGlobalReplace()

def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 2768 of file Config.py.

2768  def testGlobalReplace(self):
2769  p = Process('test')
2770  p.a = EDAnalyzer("MyAnalyzer")
2771  old = p.a
2772  p.b = EDAnalyzer("YourAnalyzer")
2773  p.c = EDAnalyzer("OurAnalyzer")
2774  p.d = EDProducer("MyProducer")
2775  old2 = p.d
2776  p.t1 = Task(p.d)
2777  t2 = Task(p.d)
2778  t3 = Task(p.d)
2779  t4 = Task(p.d)
2780  t5 = Task(p.d)
2781  t6 = Task(p.d)
2782  p.ct1 = ConditionalTask(p.d)
2783  s = Sequence(p.a*p.b)
2784  p.s4 = Sequence(p.a*p.b, p.ct1)
2785  s.associate(t2)
2786  p.s4.associate(t2)
2787  p.p = Path(p.c+s+p.a)
2788  p.p2 = Path(p.c+p.s4+p.a, p.ct1)
2789  p.e3 = EndPath(p.c+s+p.a)
2790  new = EDAnalyzer("NewAnalyzer")
2791  new2 = EDProducer("NewProducer")
2792  visitor1 = NodeVisitor()
2793  p.p.visit(visitor1)
2794  self.assertTrue(visitor1.modules == set([old,old2,p.b,p.c]))
2795  p.schedule = Schedule(tasks=[t6])
2796  p.globalReplace("a",new)
2797  p.globalReplace("d",new2)
2798  visitor2 = NodeVisitor()
2799  p.p.visit(visitor2)
2800  self.assertTrue(visitor2.modules == set([new,new2,p.b,p.c]))
2801  self.assertEqual(p.p.dumpPython()[:-1], "cms.Path(process.c+process.a+process.b+process.a, cms.Task(process.d))")
2802  visitor_p2 = NodeVisitor()
2803  p.p2.visit(visitor_p2)
2804  self.assertTrue(visitor_p2.modules == set([new,new2,p.b,p.c]))
2805  self.assertEqual(p.p2.dumpPython()[:-1], "cms.Path(process.c+process.s4+process.a, process.ct1)")
2806  visitor3 = NodeVisitor()
2807  p.e3.visit(visitor3)
2808  self.assertTrue(visitor3.modules == set([new,new2,p.b,p.c]))
2809  visitor4 = NodeVisitor()
2810  p.s4.visit(visitor4)
2811  self.assertTrue(visitor4.modules == set([new,new2,p.b]))
2812  self.assertEqual(p.s4.dumpPython()[:-1],"cms.Sequence(process.a+process.b, cms.Task(process.d), process.ct1)")
2813  visitor5 = NodeVisitor()
2814  p.t1.visit(visitor5)
2815  self.assertTrue(visitor5.modules == set([new2]))
2816  visitor6 = NodeVisitor()
2817  listOfTasks = list(p.schedule._tasks)
2818  listOfTasks[0].visit(visitor6)
2819  self.assertTrue(visitor6.modules == set([new2]))
2820  visitor7 = NodeVisitor()
2821  p.ct1.visit(visitor7)
2822  self.assertTrue(visitor7.modules == set([new2]))
2823  visitor8 = NodeVisitor()
2824  listOfConditionalTasks = list(p.conditionaltasks.values())
2825  listOfConditionalTasks[0].visit(visitor8)
2826  self.assertTrue(visitor8.modules == set([new2]))
2827 
2828 
2829  p.d2 = EDProducer("YourProducer")
2830  p.schedule = Schedule(p.p, p.p2, p.e3, tasks=[p.t1])
2831  self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
2832  p.p = Path(p.c+s)
2833  self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
2834  p.e3 = EndPath(p.c)
2835  self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
2836  p.t1 = Task(p.d2)
2837  self.assertEqual(p.schedule.dumpPython()[:-1], "cms.Schedule(*[ process.p, process.p2, process.e3 ], tasks=[process.t1])")
2838 
mps_fire.Path
Path
Definition: mps_fire.py:298

◆ testImplicitSchedule()

def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 3541 of file Config.py.

3541  def testImplicitSchedule(self):
3542  p = Process("test")
3543  p.a = EDAnalyzer("MyAnalyzer")
3544  p.b = EDAnalyzer("YourAnalyzer")
3545  p.c = EDAnalyzer("OurAnalyzer")
3546  p.path1 = Path(p.a)
3547  p.path2 = Path(p.b)
3548  self.assertTrue(p.schedule is None)
3549  pths = p.paths
3550  keys = pths.keys()
3551  self.assertEqual(pths[keys[0]],p.path1)
3552  self.assertEqual(pths[keys[1]],p.path2)
3553  p.prune()
3554  self.assertTrue(hasattr(p, 'a'))
3555  self.assertTrue(hasattr(p, 'b'))
3556  self.assertTrue(not hasattr(p, 'c'))
3557  self.assertTrue(hasattr(p, 'path1'))
3558  self.assertTrue(hasattr(p, 'path2'))
3559 
3560 
3561  p = Process("test")
3562  p.a = EDAnalyzer("MyAnalyzer")
3563  p.b = EDAnalyzer("YourAnalyzer")
3564  p.c = EDAnalyzer("OurAnalyzer")
3565  p.path2 = Path(p.b)
3566  p.path1 = Path(p.a)
3567  self.assertTrue(p.schedule is None)
3568  pths = p.paths
3569  keys = pths.keys()
3570  self.assertEqual(pths[keys[1]],p.path1)
3571  self.assertEqual(pths[keys[0]],p.path2)
3572 
3573 
mps_fire.Path
Path
Definition: mps_fire.py:298

◆ testMaxEvents()

def Config.TestModuleCommand.testMaxEvents (   self)

Definition at line 3620 of file Config.py.

3620  def testMaxEvents(self):
3621  p = Process("Test")
3622  p.maxEvents.input = 10
3623  self.assertEqual(p.maxEvents.input.value(),10)
3624  p = Process("Test")
3625  p.maxEvents.output = 10
3626  self.assertEqual(p.maxEvents.output.value(),10)
3627  p = Process("Test")
3628  p.maxEvents.output = PSet(out=untracked.int32(10))
3629  self.assertEqual(p.maxEvents.output.out.value(), 10)
3630  p = Process("Test")
3631  p.maxEvents = untracked.PSet(input = untracked.int32(5))
3632  self.assertEqual(p.maxEvents.input.value(), 5)
3633  del p.maxEvents
3634  self.assertRaises(TypeError, setattr, p, 'maxEvents', untracked.PSet(input = untracked.uint32(1)))
3635  p.maxEvents = untracked.PSet(input = untracked.int32(1))
3636  self.assertEqual(p.maxEvents.input.value(), 1)
3637 
PSet
Definition: PSet.py:1

◆ testModifier()

def Config.TestModuleCommand.testModifier (   self)

Definition at line 4193 of file Config.py.

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

4193  def testModifier(self):
4194  m1 = Modifier()
4195  Process._firstProcess = True
4196  p = Process("test")
4197  self.assertRaises(RuntimeError, lambda: Process("test2", m1))
4198  m1 = Modifier()
4199  Process._firstProcess = True
4200  p = Process("test",m1)
4201  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
4202  def _mod_fred(obj):
4203  obj.fred = 2
4204  m1.toModify(p.a,_mod_fred)
4205  self.assertEqual(p.a.fred.value(),2)
4206  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
4207  m1.toModify(p.b, wilma = 2)
4208  self.assertEqual(p.b.wilma.value(),2)
4209  self.assertTrue(p.isUsingModifier(m1))
4210  #check that Modifier not attached to a process doesn't run
4211  m1 = Modifier()
4212  Process._firstProcess = True
4213  p = Process("test")
4214  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
4215  m1.toModify(p.a,_mod_fred)
4216  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
4217  m1.toModify(p.b, wilma = 2)
4218  self.assertEqual(p.a.fred.value(),1)
4219  self.assertEqual(p.b.wilma.value(),1)
4220  self.assertEqual(p.isUsingModifier(m1),False)
4221  #make sure clones get the changes
4222  m1 = Modifier()
4223  Process._firstProcess = True
4224  p = Process("test",m1)
4225  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4226  m1.toModify(p.a, fred = int32(2))
4227  p.b = p.a.clone(wilma = int32(3))
4228  self.assertEqual(p.a.fred.value(),2)
4229  self.assertEqual(p.a.wilma.value(),1)
4230  self.assertEqual(p.b.fred.value(),2)
4231  self.assertEqual(p.b.wilma.value(),3)
4232  #test removal of parameter
4233  m1 = Modifier()
4234  Process._firstProcess = True
4235  p = Process("test",m1)
4236  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1), fintstones = PSet(fred = int32(1)))
4237  m1.toModify(p.a, fred = None, fintstones = dict(fred = None))
4238  self.assertEqual(hasattr(p.a, "fred"), False)
4239  self.assertEqual(hasattr(p.a.fintstones, "fred"), False)
4240  self.assertEqual(p.a.wilma.value(),1)
4241  #test adding a parameter
4242  m1 = Modifier()
4243  Process._firstProcess = True
4244  p = Process("test",m1)
4245  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
4246  m1.toModify(p.a, wilma = int32(2))
4247  self.assertEqual(p.a.fred.value(), 1)
4248  self.assertEqual(p.a.wilma.value(),2)
4249  #test setting of value in PSet
4250  m1 = Modifier()
4251  Process._firstProcess = True
4252  p = Process("test",m1)
4253  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = int32(1), wilma = int32(1)))
4254  m1.toModify(p.a, flintstones = dict(fred = int32(2)))
4255  self.assertEqual(p.a.flintstones.fred.value(),2)
4256  self.assertEqual(p.a.flintstones.wilma.value(),1)
4257  #test proper exception from nonexisting parameter name
4258  m1 = Modifier()
4259  Process._firstProcess = True
4260  p = Process("test",m1)
4261  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = PSet(wilma = int32(1))))
4262  self.assertRaises(KeyError, lambda: m1.toModify(p.a, flintstones = dict(imnothere = dict(wilma=2))))
4263  self.assertRaises(KeyError, lambda: m1.toModify(p.a, foo = 1))
4264  #test setting a value in a VPSet
4265  m1 = Modifier()
4266  Process._firstProcess = True
4267  p = Process("test",m1)
4268  p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
4269  m1.toModify(p.a, flintstones = {1:dict(wilma = int32(2))})
4270  self.assertEqual(p.a.flintstones[0].fred.value(),1)
4271  self.assertEqual(p.a.flintstones[1].wilma.value(),2)
4272  #test setting a value in a list of values
4273  m1 = Modifier()
4274  Process._firstProcess = True
4275  p = Process("test",m1)
4276  p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
4277  m1.toModify(p.a, fred = {1:7})
4278  self.assertEqual(p.a.fred[0],1)
4279  self.assertEqual(p.a.fred[1],7)
4280  self.assertEqual(p.a.fred[2],3)
4281  #test IndexError setting a value in a list to an item key not in the list
4282  m1 = Modifier()
4283  Process._firstProcess = True
4284  p = Process("test",m1)
4285  p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
4286  raised = False
4287  try: m1.toModify(p.a, fred = {5:7})
4288  except IndexError as e: raised = True
4289  self.assertEqual(raised, True)
4290  #test TypeError setting a value in a list using a key that is not an int
4291  m1 = Modifier()
4292  Process._firstProcess = True
4293  p = Process("test",m1)
4294  p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
4295  raised = False
4296  try: m1.toModify(p.a, flintstones = dict(bogus = int32(37)))
4297  except TypeError as e: raised = True
4298  self.assertEqual(raised, True)
4299  #test that load causes process wide methods to run
4300  def _rem_a(proc):
4301  del proc.a
4302  class ProcModifierMod(object):
4303  def __init__(self,modifier,func):
4304  self.proc_mod_ = modifier.makeProcessModifier(func)
4305  class DummyMod(object):
4306  def __init__(self):
4307  self.a = EDAnalyzer("Dummy")
4308  testMod = DummyMod()
4309  p.extend(testMod)
4310  self.assertTrue(hasattr(p,"a"))
4311  m1 = Modifier()
4312  Process._firstProcess = True
4313  p = Process("test",m1)
4314  testProcMod = ProcModifierMod(m1,_rem_a)
4315  p.extend(testMod)
4316  p.extend(testProcMod)
4317  self.assertTrue(not hasattr(p,"a"))
4318  #test ModifierChain
4319  m1 = Modifier()
4320  mc = ModifierChain(m1)
4321  Process._firstProcess = True
4322  p = Process("test",mc)
4323  self.assertTrue(p.isUsingModifier(m1))
4324  self.assertTrue(p.isUsingModifier(mc))
4325  testMod = DummyMod()
4326  p.b = EDAnalyzer("Dummy2", fred = int32(1))
4327  m1.toModify(p.b, fred = int32(3))
4328  p.extend(testMod)
4329  testProcMod = ProcModifierMod(m1,_rem_a)
4330  p.extend(testProcMod)
4331  self.assertTrue(not hasattr(p,"a"))
4332  self.assertEqual(p.b.fred.value(),3)
4333  #check cloneAndExclude
4334  m1 = Modifier()
4335  m2 = Modifier()
4336  mc = ModifierChain(m1,m2)
4337  mclone = mc.copyAndExclude([m2])
4338  self.assertTrue(not mclone._isOrContains(m2))
4339  self.assertTrue(mclone._isOrContains(m1))
4340  m3 = Modifier()
4341  mc2 = ModifierChain(mc,m3)
4342  mclone = mc2.copyAndExclude([m2])
4343  self.assertTrue(not mclone._isOrContains(m2))
4344  self.assertTrue(mclone._isOrContains(m1))
4345  self.assertTrue(mclone._isOrContains(m3))
4346  #check combining
4347  m1 = Modifier()
4348  m2 = Modifier()
4349  Process._firstProcess = True
4350  p = Process("test",m1)
4351  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4352  (m1 & m2).toModify(p.a, fred = int32(2))
4353  self.assertRaises(TypeError, lambda: (m1 & m2).toModify(p.a, 1, wilma=2))
4354  self.assertEqual(p.a.fred, 1)
4355  m1 = Modifier()
4356  m2 = Modifier()
4357  Process._firstProcess = True
4358  p = Process("test",m1,m2)
4359  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4360  (m1 & m2).toModify(p.a, fred = int32(2))
4361  self.assertEqual(p.a.fred, 2)
4362  m1 = Modifier()
4363  m2 = Modifier()
4364  m3 = Modifier()
4365  Process._firstProcess = True
4366  p = Process("test",m1,m2,m3)
4367  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4368  (m1 & m2 & m3).toModify(p.a, fred = int32(2))
4369  self.assertEqual(p.a.fred, 2)
4370  (m1 & (m2 & m3)).toModify(p.a, fred = int32(3))
4371  self.assertEqual(p.a.fred, 3)
4372  ((m1 & m2) & m3).toModify(p.a, fred = int32(4))
4373  self.assertEqual(p.a.fred, 4)
4374  #check inverse
4375  m1 = Modifier()
4376  m2 = Modifier()
4377  Process._firstProcess = True
4378  p = Process("test", m1)
4379  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4380  (~m1).toModify(p.a, fred=2)
4381  self.assertEqual(p.a.fred, 1)
4382  (~m2).toModify(p.a, wilma=2)
4383  self.assertEqual(p.a.wilma, 2)
4384  self.assertRaises(TypeError, lambda: (~m1).toModify(p.a, 1, wilma=2))
4385  self.assertRaises(TypeError, lambda: (~m2).toModify(p.a, 1, wilma=2))
4386  # check or
4387  m1 = Modifier()
4388  m2 = Modifier()
4389  m3 = Modifier()
4390  Process._firstProcess = True
4391  p = Process("test", m1)
4392  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4393  (m1 | m2).toModify(p.a, fred=2)
4394  self.assertEqual(p.a.fred, 2)
4395  (m1 | m2 | m3).toModify(p.a, fred=3)
4396  self.assertEqual(p.a.fred, 3)
4397  (m3 | m2 | m1).toModify(p.a, fred=4)
4398  self.assertEqual(p.a.fred, 4)
4399  ((m1 | m2) | m3).toModify(p.a, fred=5)
4400  self.assertEqual(p.a.fred, 5)
4401  (m1 | (m2 | m3)).toModify(p.a, fred=6)
4402  self.assertEqual(p.a.fred, 6)
4403  (m2 | m3).toModify(p.a, fred=7)
4404  self.assertEqual(p.a.fred, 6)
4405  self.assertRaises(TypeError, lambda: (m1 | m2).toModify(p.a, 1, wilma=2))
4406  self.assertRaises(TypeError, lambda: (m2 | m3).toModify(p.a, 1, wilma=2))
4407  # check combinations
4408  m1 = Modifier()
4409  m2 = Modifier()
4410  m3 = Modifier()
4411  m4 = Modifier()
4412  Process._firstProcess = True
4413  p = Process("test", m1, m2)
4414  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4415  (m1 & ~m2).toModify(p.a, fred=2)
4416  self.assertEqual(p.a.fred, 1)
4417  (m1 & ~m3).toModify(p.a, fred=2)
4418  self.assertEqual(p.a.fred, 2)
4419  (m1 | ~m2).toModify(p.a, fred=3)
4420  self.assertEqual(p.a.fred, 3)
4421  (~m1 | ~m2).toModify(p.a, fred=4)
4422  self.assertEqual(p.a.fred, 3)
4423  (~m3 & ~m4).toModify(p.a, fred=4)
4424  self.assertEqual(p.a.fred, 4)
4425  ((m1 & m3) | ~m4).toModify(p.a, fred=5)
4426  self.assertEqual(p.a.fred, 5)
4427  #check toReplaceWith
4428  m1 = Modifier()
4429  Process._firstProcess = True
4430  p = Process("test",m1)
4431  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
4432  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
4433  self.assertRaises(TypeError, lambda: m1.toReplaceWith(p.a, EDProducer("YourProducer")))
4434  #Task
4435  p.b =EDAnalyzer("BAn")
4436  p.c =EDProducer("c")
4437  p.d =EDProducer("d")
4438  p.tc = Task(p.c)
4439  p.td = Task(p.d)
4440  p.s = Sequence(p.a, p.tc)
4441  m1.toReplaceWith(p.s, Sequence(p.a+p.b, p.td))
4442  self.assertEqual(p.a.wilma.value(),3)
4443  self.assertEqual(p.a.type_(),"YourAnalyzer")
4444  self.assertEqual(hasattr(p,"fred"),False)
4445  self.assertTrue(p.s.dumpPython() == "cms.Sequence(process.a+process.b, process.td)\n")
4446  p.e =EDProducer("e")
4447  m1.toReplaceWith(p.td, Task(p.e))
4448  self.assertTrue(p.td._collection == OrderedSet([p.e]))
4449  #ConditionalTask
4450  p.b =EDAnalyzer("BAn")
4451  p.c =EDProducer("c")
4452  p.d =EDProducer("d")
4453  del p.tc
4454  del p.td
4455  p.tc = ConditionalTask(p.c)
4456  p.td = ConditionalTask(p.d)
4457  p.s = Sequence(p.a, p.tc)
4458  m1.toReplaceWith(p.s, Sequence(p.a+p.b, p.td))
4459  self.assertEqual(p.a.wilma.value(),3)
4460  self.assertEqual(p.a.type_(),"YourAnalyzer")
4461  self.assertEqual(hasattr(p,"fred"),False)
4462  self.assertTrue(p.s.dumpPython() == "cms.Sequence(process.a+process.b, process.td)\n")
4463  p.e =EDProducer("e")
4464  m1.toReplaceWith(p.td, ConditionalTask(p.e))
4465  self.assertTrue(p.td._collection == OrderedSet([p.e]))
4466  #check toReplaceWith doesn't activate not chosen
4467  m1 = Modifier()
4468  Process._firstProcess = True
4469  p = Process("test")
4470  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
4471  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
4472  self.assertEqual(p.a.type_(),"MyAnalyzer")
4473  #check toReplaceWith and and/not/or combinations
4474  m1 = Modifier()
4475  m2 = Modifier()
4476  m3 = Modifier()
4477  m4 = Modifier()
4478  Process._firstProcess = True
4479  p = Process("test", m1, m2)
4480  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4481  self.assertRaises(TypeError, lambda: (m1 & m2).toReplaceWith(p.a, EDProducer("YourProducer")))
4482  self.assertRaises(TypeError, lambda: (m3 & m4).toReplaceWith(p.a, EDProducer("YourProducer")))
4483  self.assertRaises(TypeError, lambda: (~m3).toReplaceWith(p.a, EDProducer("YourProducer")))
4484  self.assertRaises(TypeError, lambda: (~m1).toReplaceWith(p.a, EDProducer("YourProducer")))
4485  self.assertRaises(TypeError, lambda: (m1 | m3).toReplaceWith(p.a, EDProducer("YourProducer")))
4486  self.assertRaises(TypeError, lambda: (m3 | m4).toReplaceWith(p.a, EDProducer("YourProducer")))
4487  (m1 & m2).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer1"))
4488  self.assertEqual(p.a.type_(), "YourAnalyzer1")
4489  (m1 & m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
4490  self.assertEqual(p.a.type_(), "YourAnalyzer1")
4491  (~m1).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
4492  self.assertEqual(p.a.type_(), "YourAnalyzer1")
4493  (~m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
4494  self.assertEqual(p.a.type_(), "YourAnalyzer2")
4495  (m1 | m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer3"))
4496  self.assertEqual(p.a.type_(), "YourAnalyzer3")
4497  (m3 | m4).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer4"))
4498  self.assertEqual(p.a.type_(), "YourAnalyzer3")
4499  #check chaining of toModify and toReplaceWith
4500  m1 = Modifier()
4501  m2 = Modifier()
4502  m3 = Modifier()
4503  Process._firstProcess = True
4504  p = Process("test", m1, m2)
4505  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
4506  p.b = EDProducer("MyProducer", barney = int32(1), betty = int32(1))
4507  (m1 & m2).toModify(p.a, fred = 2).toModify(p.b, betty = 3)
4508  self.assertEqual(p.a.fred, 2)
4509  self.assertEqual(p.a.wilma, 1)
4510  self.assertEqual(p.b.barney, 1)
4511  self.assertEqual(p.b.betty, 3)
4512  (m1 | m3).toModify(p.a, wilma = 4).toModify(p.b, barney = 5)
4513  self.assertEqual(p.a.fred, 2)
4514  self.assertEqual(p.a.wilma, 4)
4515  self.assertEqual(p.b.barney, 5)
4516  self.assertEqual(p.b.betty, 3)
4517  (m2 & ~m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer")).toModify(p.b, barney = 6)
4518  self.assertEqual(p.a.type_(), "YourAnalyzer")
4519  self.assertEqual(p.b.barney, 6)
4520  self.assertEqual(p.b.betty, 3)
4521  (m1 & ~m3).toModify(p.a, param=int32(42)).toReplaceWith(p.b, EDProducer("YourProducer"))
4522  self.assertEqual(p.a.type_(), "YourAnalyzer")
4523  self.assertEqual(p.a.param, 42)
4524  self.assertEqual(p.b.type_(), "YourProducer")
4525 
4526  # EDAlias
4527  a = EDAlias(foo2 = VPSet(PSet(type = string("Foo2"))))
4528  m = Modifier()
4529  m._setChosen()
4530  # Modify parameters
4531  m.toModify(a, foo2 = {0: dict(type = "Foo3")})
4532  self.assertEqual(a.foo2[0].type, "Foo3")
4533  # Add an alias
4534  m.toModify(a, foo4 = VPSet(PSet(type = string("Foo4"))))
4535  self.assertEqual(a.foo2[0].type, "Foo3")
4536  self.assertEqual(a.foo4[0].type, "Foo4")
4537  # Remove an alias
4538  m.toModify(a, foo2 = None)
4539  self.assertFalse(hasattr(a, "foo2"))
4540  self.assertEqual(a.foo4[0].type, "Foo4")
4541  # Replace (doesn't work out of the box because EDAlias is not _Parameterizable
4542  m.toReplaceWith(a, EDAlias(bar = VPSet(PSet(type = string("Bar")))))
4543  self.assertFalse(hasattr(a, "foo2"))
4544  self.assertFalse(hasattr(a, "foo4"))
4545  self.assertTrue(hasattr(a, "bar"))
4546  self.assertEqual(a.bar[0].type, "Bar")
4547 
4548  # SwitchProducer
4549  sp = SwitchProducerTest(test1 = EDProducer("Foo",
4550  a = int32(1),
4551  b = PSet(c = int32(2))),
4552  test2 = EDProducer("Bar",
4553  aa = int32(11),
4554  bb = PSet(cc = int32(12))))
4555  m = Modifier()
4556  m._setChosen()
4557  # Modify parameters
4558  m.toModify(sp,
4559  test1 = dict(a = 4, b = dict(c = None)),
4560  test2 = dict(aa = 15, bb = dict(cc = 45, dd = string("foo"))))
4561  self.assertEqual(sp.test1.a.value(), 4)
4562  self.assertEqual(sp.test1.b.hasParameter("c"), False)
4563  self.assertEqual(sp.test2.aa.value(), 15)
4564  self.assertEqual(sp.test2.bb.cc.value(), 45)
4565  self.assertEqual(sp.test2.bb.dd.value(), "foo")
4566  # Replace a producer
4567  m.toReplaceWith(sp.test1, EDProducer("Fred", x = int32(42)))
4568  self.assertEqual(sp.test1.type_(), "Fred")
4569  self.assertEqual(sp.test1.x.value(), 42)
4570  self.assertRaises(TypeError, lambda: m.toReplaceWith(sp.test1, EDAnalyzer("Foo")))
4571  # Alternative way (only to be allow same syntax to be used as for adding)
4572  m.toModify(sp, test2 = EDProducer("Xyzzy", x = int32(24)))
4573  self.assertEqual(sp.test2.type_(), "Xyzzy")
4574  self.assertEqual(sp.test2.x.value(), 24)
4575  self.assertRaises(TypeError, lambda: m.toModify(sp, test2 = EDAnalyzer("Foo")))
4576  # Add a producer
4577  m.toModify(sp, test3 = EDProducer("Wilma", y = int32(24)))
4578  self.assertEqual(sp.test3.type_(), "Wilma")
4579  self.assertEqual(sp.test3.y.value(), 24)
4580  self.assertRaises(TypeError, lambda: m.toModify(sp, test4 = EDAnalyzer("Foo")))
4581  # Remove a producer
4582  m.toModify(sp, test2 = None)
4583  self.assertEqual(hasattr(sp, "test2"), False)
4584  # Add an alias
4585  m.toModify(sp, test2 = EDAlias(foo = VPSet(PSet(type = string("int")))))
4586  self.assertTrue(hasattr(sp.test2, "foo"))
4587  # Replace an alias
4588  m.toReplaceWith(sp.test2, EDAlias(bar = VPSet(PSet(type = string("int")))))
4589  self.assertTrue(hasattr(sp.test2, "bar"))
4590  # Alternative way
4591  m.toModify(sp, test2 = EDAlias(xyzzy = VPSet(PSet(type = string("int")))))
4592  self.assertTrue(hasattr(sp.test2, "xyzzy"))
4593  # Replace an alias with EDProducer
4594  self.assertRaises(TypeError, lambda: m.toReplaceWith(sp.test2, EDProducer("Foo")))
4595  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
PSet
Definition: PSet.py:1
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 3604 of file Config.py.

3604  def testOptions(self):
3605  p = Process('test')
3606  self.assertEqual(p.options.numberOfThreads.value(),1)
3607  p.options.numberOfThreads = 8
3608  self.assertEqual(p.options.numberOfThreads.value(),8)
3609  p.options = PSet()
3610  self.assertEqual(p.options.numberOfThreads.value(),1)
3611  p.options = dict(numberOfStreams =2,
3612  numberOfThreads =2)
3613  self.assertEqual(p.options.numberOfThreads.value(),2)
3614  self.assertEqual(p.options.numberOfStreams.value(),2)
3615  del p.options
3616  self.assertRaises(TypeError, setattr, p, 'options', untracked.PSet(numberOfThreads = int32(-1)))
3617  p.options = untracked.PSet(numberOfThreads = untracked.uint32(4))
3618  self.assertEqual(p.options.numberOfThreads.value(), 4)
3619 
PSet
Definition: PSet.py:1

◆ testOverride()

def Config.TestModuleCommand.testOverride (   self)

Definition at line 3581 of file Config.py.

3581  def testOverride(self):
3582  p = Process('test')
3583  a = EDProducer("A", a1=int32(0))
3584  self.assertTrue(not a.isModified())
3585  a.a1 = 1
3586  self.assertTrue(a.isModified())
3587  p.a = a
3588  self.assertEqual(p.a.a1.value(), 1)
3589  # try adding an unmodified module.
3590  # should accept it
3591  p.a = EDProducer("A", a1=int32(2))
3592  self.assertEqual(p.a.a1.value(), 2)
3593  # try adding a modified module. Should throw
3594  # no longer, since the same (modified) say, geometry
3595  # could come from more than one cff
3596  b = EDProducer("A", a1=int32(3))
3597  b.a1 = 4
3598  #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
3599  ps1 = PSet(a = int32(1))
3600  ps2 = PSet(a = int32(2))
3601  self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
3602  self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
3603 
PSet
Definition: PSet.py:1

◆ testParameterizable()

def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 2289 of file Config.py.

2289  def testParameterizable(self):
2290  p = _Parameterizable()
2291  self.assertEqual(len(p.parameterNames_()),0)
2292  p.a = int32(1)
2293  self.assertTrue('a' in p.parameterNames_())
2294  self.assertEqual(p.a.value(), 1)
2295  p.a = 10
2296  self.assertEqual(p.a.value(), 10)
2297  p.a = untracked(int32(1))
2298  self.assertEqual(p.a.value(), 1)
2299  self.assertFalse(p.a.isTracked())
2300  p.a = untracked.int32(1)
2301  self.assertEqual(p.a.value(), 1)
2302  self.assertFalse(p.a.isTracked())
2303  p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
2304  self.assertEqual(p.foo.value(), 10)
2305  self.assertEqual(p.bar.value(),1.0)
2306  self.assertFalse(p.bar.isTracked())
2307  self.assertRaises(TypeError,setattr,(p,'c',1))
2308  p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
2309  self.assertEqual(p.a.foo.value(),10)
2310  self.assertEqual(p.a.bar.value(),1.0)
2311  p.b = untracked(PSet(fii = int32(1)))
2312  self.assertEqual(p.b.fii.value(),1)
2313  self.assertFalse(p.b.isTracked())
2314  #test the fact that values can be shared
2315  v = int32(10)
2316  p=_Parameterizable(a=v)
2317  v.setValue(11)
2318  self.assertEqual(p.a.value(),11)
2319  p.a = 12
2320  self.assertEqual(p.a.value(),12)
2321  self.assertEqual(v.value(),12)
Types.untracked
untracked
Definition: Types.py:34
PSet
Definition: PSet.py:1

◆ testPath()

def Config.TestModuleCommand.testPath (   self)

Definition at line 3262 of file Config.py.

References SequenceTypes.ignore(), and str.

3262  def testPath(self):
3263  p = Process("test")
3264  p.a = EDAnalyzer("MyAnalyzer")
3265  p.b = EDAnalyzer("YourAnalyzer")
3266  p.c = EDAnalyzer("OurAnalyzer")
3267  path = Path(p.a)
3268  path *= p.b
3269  path += p.c
3270  self.assertEqual(str(path),'a+b+c')
3271  path = Path(p.a*p.b+p.c)
3272  self.assertEqual(str(path),'a+b+c')
3273 # path = Path(p.a)*p.b+p.c #This leads to problems with sequences
3274 # self.assertEqual(str(path),'((a*b)+c)')
3275  path = Path(p.a+ p.b*p.c)
3276  self.assertEqual(str(path),'a+b+c')
3277  path = Path(p.a*(p.b+p.c))
3278  self.assertEqual(str(path),'a+b+c')
3279  path = Path(p.a*(p.b+~p.c))
3280  pathx = Path(p.a*(p.b+ignore(p.c)))
3281  self.assertEqual(str(path),'a+b+~c')
3282  p.es = ESProducer("AnESProducer")
3283  self.assertRaises(TypeError,Path,p.es)
3284 
3285  t = Path()
3286  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path()\n')
3287 
3288  t = Path(p.a)
3289  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a)\n')
3290 
3291  t = Path(Task())
3292  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(cms.Task())\n')
3293 
3294  t = Path(p.a, Task())
3295  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.Task())\n')
3296 
3297  p.prod = EDProducer("prodName")
3298  p.t1 = Task(p.prod)
3299  t = Path(p.a, p.t1, Task(), p.t1)
3300  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.Task(), process.t1)\n')
3301 
3302  t = Path(ConditionalTask())
3303  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(cms.ConditionalTask())\n')
3304 
3305  t = Path(p.a, ConditionalTask())
3306  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.ConditionalTask())\n')
3307 
3308  p.prod = EDProducer("prodName")
3309  p.t1 = ConditionalTask(p.prod)
3310  t = Path(p.a, p.t1, Task(), p.t1)
3311  self.assertEqual(t.dumpPython(PrintOptions()), 'cms.Path(process.a, cms.Task(), process.t1)\n')
3312 
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:56

◆ testPrefers()

def Config.TestModuleCommand.testPrefers (   self)

Definition at line 3650 of file Config.py.

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

3650  def testPrefers(self):
3651  p = Process("Test")
3652  p.add_(ESSource("ForceSource"))
3653  p.juicer = ESProducer("JuicerProducer")
3654  p.prefer("ForceSource")
3655  p.prefer("juicer")
3656  self.assertEqual(_lineDiff(p.dumpPython(), Process('Test').dumpPython()),
3657 """process.juicer = cms.ESProducer("JuicerProducer")
3658 process.ForceSource = cms.ESSource("ForceSource")
3659 process.prefer("ForceSource")
3660 process.prefer("juicer")""")
3661  p.prefer("juicer",fooRcd=vstring("Foo"))
3662  self.assertEqual(_lineDiff(p.dumpPython(), Process('Test').dumpPython()),
3663 """process.juicer = cms.ESProducer("JuicerProducer")
3664 process.ForceSource = cms.ESSource("ForceSource")
3665 process.prefer("ForceSource")
3666 process.prefer("juicer",
3667  fooRcd = cms.vstring('Foo')
3668 )""")
3669 
mixOne_cfi.ESProducer
ESProducer
Definition: mixOne_cfi.py:33
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2095
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:96

◆ testProcessAccelerator()

def Config.TestModuleCommand.testProcessAccelerator (   self)

Definition at line 4627 of file Config.py.

4627  def testProcessAccelerator(self):
4628  proc = Process("TEST")
4629  p = TestMakePSet()
4630  proc.fillProcessDesc(p)
4631  self.assertTrue(["cpu"], p.values["@available_accelerators"][1])
4632  self.assertFalse(p.values["@selected_accelerators"][0])
4633  self.assertTrue(["cpu"], p.values["@selected_accelerators"][1])
4634  self.assertFalse(p.values["@module_type_resolver"][0])
4635  self.assertEqual("", p.values["@module_type_resolver"][1])
4636 
4637  proc = Process("TEST")
4638  self.assertRaises(TypeError, setattr, proc, "processAcceleratorTest", ProcessAcceleratorTest())
4639  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4640  del proc.MessageLogger # remove boilerplate unnecessary for this test case
4641  self.maxDiff = None
4642  self.assertEqual(proc.dumpPython(),
4643 """import FWCore.ParameterSet.Config as cms
4644 from test import ProcessAcceleratorTest
4645 
4646 process = cms.Process("TEST")
4647 
4648 process.maxEvents = cms.untracked.PSet(
4649  input = cms.optional.untracked.int32,
4650  output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
4651 )
4652 
4653 process.maxLuminosityBlocks = cms.untracked.PSet(
4654  input = cms.untracked.int32(-1)
4655 )
4656 
4657 process.options = cms.untracked.PSet(
4658  IgnoreCompletely = cms.untracked.vstring(),
4659  Rethrow = cms.untracked.vstring(),
4660  TryToContinue = cms.untracked.vstring(),
4661  accelerators = cms.untracked.vstring('*'),
4662  allowUnscheduled = cms.obsolete.untracked.bool,
4663  canDeleteEarly = cms.untracked.vstring(),
4664  deleteNonConsumedUnscheduledModules = cms.untracked.bool(True),
4665  dumpOptions = cms.untracked.bool(False),
4666  emptyRunLumiMode = cms.obsolete.untracked.string,
4667  eventSetup = cms.untracked.PSet(
4668  forceNumberOfConcurrentIOVs = cms.untracked.PSet(
4669  allowAnyLabel_=cms.required.untracked.uint32
4670  ),
4671  numberOfConcurrentIOVs = cms.untracked.uint32(0)
4672  ),
4673  fileMode = cms.untracked.string('FULLMERGE'),
4674  forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False),
4675  holdsReferencesToDeleteEarly = cms.untracked.VPSet(),
4676  makeTriggerResults = cms.obsolete.untracked.bool,
4677  modulesToCallForTryToContinue = cms.untracked.vstring(),
4678  modulesToIgnoreForDeleteEarly = cms.untracked.vstring(),
4679  numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0),
4680  numberOfConcurrentRuns = cms.untracked.uint32(1),
4681  numberOfStreams = cms.untracked.uint32(0),
4682  numberOfThreads = cms.untracked.uint32(1),
4683  printDependencies = cms.untracked.bool(False),
4684  sizeOfStackForThreadsInKB = cms.optional.untracked.uint32,
4685  throwIfIllegalParameter = cms.untracked.bool(True),
4686  wantSummary = cms.untracked.bool(False)
4687 )
4688 
4689 process.ProcessAcceleratorTest = ProcessAcceleratorTest(
4690  enabled = ['test1', 'test2', 'anothertest3']
4691 )
4692 
4693 
4694 """)
4695  p = TestMakePSet()
4696  proc.fillProcessDesc(p)
4697  self.assertEqual(["*"], p.values["options"][1].values["accelerators"][1])
4698  self.assertFalse(p.values["options"][1].values["accelerators"][0])
4699  self.assertTrue(["anothertest3", "cpu", "test1", "test2"], p.values["@selected_accelerators"][1])
4700  self.assertEqual("AcceleratorTestService", p.values["services"][1][0].values["@service_type"][1])
4701  self.assertFalse(p.values["@available_accelerators"][0])
4702  self.assertTrue(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4703  self.assertFalse(p.values["@module_type_resolver"][0])
4704  self.assertEqual("", p.values["@module_type_resolver"][1])
4705 
4706  proc = Process("TEST")
4707  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4708  proc.add_(Service("AcceleratorTestServiceRemove"))
4709  p = TestMakePSet()
4710  proc.fillProcessDesc(p)
4711  services = [x.values["@service_type"][1] for x in p.values["services"][1]]
4712  self.assertTrue("AcceleratorTestService" in services)
4713  self.assertFalse("AcceleratorTestServiceRemove" in services)
4714 
4715  proc = Process("TEST")
4716  proc.ProcessAcceleratorTest = ProcessAcceleratorTest(enabled=["test1"])
4717  p = TestMakePSet()
4718  proc.fillProcessDesc(p)
4719  self.assertEqual(["cpu", "test1"], p.values["@selected_accelerators"][1])
4720  self.assertEqual(["cpu", "test1"], p.values["@available_accelerators"][1])
4721 
4722  proc = Process("TEST")
4723  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4724  proc.options.accelerators = ["test2"]
4725  p = TestMakePSet()
4726  proc.fillProcessDesc(p)
4727  self.assertEqual(["test2"], p.values["@selected_accelerators"][1])
4728  self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4729 
4730  proc = Process("TEST")
4731  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4732  proc.options.accelerators = ["test*"]
4733  proc.fillProcessDesc(p)
4734  self.assertEqual(["test1", "test2"], p.values["@selected_accelerators"][1])
4735  self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4736 
4737  proc = Process("TEST")
4738  proc.ProcessAcceleratorTest = ProcessAcceleratorTest(enabled=["test1"])
4739  proc.options.accelerators = ["test2"]
4740  p = TestMakePSet()
4741  proc.fillProcessDesc(p)
4742  self.assertEqual([], p.values["@selected_accelerators"][1])
4743  self.assertEqual(["cpu", "test1"], p.values["@available_accelerators"][1])
4744 
4745  proc = Process("TEST")
4746  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4747  proc.options.accelerators = ["cpu*"]
4748  p = TestMakePSet()
4749  proc.fillProcessDesc(p)
4750  self.assertEqual(["cpu"], p.values["@selected_accelerators"][1])
4751  self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4752 
4753  proc = Process("TEST")
4754  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4755  proc.options.accelerators = ["test3"]
4756  p = TestMakePSet()
4757  self.assertRaises(ValueError, proc.fillProcessDesc, p)
4758 
4759  proc = Process("TEST")
4760  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4761  proc.options.accelerators = ["*", "test1"]
4762  p = TestMakePSet()
4763  self.assertRaises(ValueError, proc.fillProcessDesc, p)
4764 
4765  proc = Process("TEST")
4766  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4767  proc.ProcessAcceleratorTest2 = ProcessAcceleratorTest2()
4768  p = TestMakePSet()
4769  proc.fillProcessDesc(p)
4770  self.assertEqual(["anothertest3", "anothertest4", "cpu", "test1", "test2"], p.values["@selected_accelerators"][1])
4771  self.assertEqual(["anothertest3", "anothertest4", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4772 
4773  proc = Process("TEST")
4774  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4775  proc.ProcessAcceleratorTest2 = ProcessAcceleratorTest2()
4776  proc.options.accelerators = ["*test3", "c*"]
4777  p = TestMakePSet()
4778  proc.fillProcessDesc(p)
4779  self.assertEqual(["anothertest3", "cpu"], p.values["@selected_accelerators"][1])
4780  self.assertEqual(["anothertest3", "anothertest4", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4781 
4782  proc = Process("TEST")
4783  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4784  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4785  a = int32(1),
4786  b = PSet(c = int32(2))),
4787  test1 = EDProducer("Bar",
4788  aa = int32(11),
4789  bb = PSet(cc = int32(12))))
4790  proc.p = Path(proc.sp)
4791  p = TestMakePSet()
4792  proc.fillProcessDesc(p)
4793  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
4794 
4795  proc = Process("TEST")
4796  proc.ProcessAcceleratorTest = ProcessAcceleratorTest(enabled=["test1"])
4797  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4798  a = int32(1),
4799  b = PSet(c = int32(2))),
4800  test1 = EDProducer("Bar",
4801  aa = int32(11),
4802  bb = PSet(cc = int32(12))))
4803  proc.p = Path(proc.sp)
4804  p = TestMakePSet()
4805  proc.fillProcessDesc(p)
4806  self.assertEqual((False, "sp@test1"), p.values["sp"][1].values["@chosen_case"])
4807 
4808  proc = Process("TEST")
4809  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4810  proc.options.accelerators = ["test1"]
4811  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4812  a = int32(1),
4813  b = PSet(c = int32(2))),
4814  test1 = EDProducer("Bar",
4815  aa = int32(11),
4816  bb = PSet(cc = int32(12))))
4817  proc.p = Path(proc.sp)
4818  p = TestMakePSet()
4819  proc.fillProcessDesc(p)
4820  self.assertEqual((False, "sp@test1"), p.values["sp"][1].values["@chosen_case"])
4821 
4822  proc = Process("TEST")
4823  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4824  proc.options.accelerators = ["test*"]
4825  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4826  a = int32(1),
4827  b = PSet(c = int32(2))),
4828  test1 = EDProducer("Bar",
4829  aa = int32(11),
4830  bb = PSet(cc = int32(12))))
4831  proc.p = Path(proc.sp)
4832  p = TestMakePSet()
4833  proc.fillProcessDesc(p)
4834  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
4835 
4836  proc = Process("TEST")
4837  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4838  proc.options.accelerators = ["anothertest3"]
4839  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4840  a = int32(1),
4841  b = PSet(c = int32(2))),
4842  test1 = EDProducer("Bar",
4843  aa = int32(11),
4844  bb = PSet(cc = int32(12))))
4845  proc.p = Path(proc.sp)
4846  p = TestMakePSet()
4847  self.assertRaises(RuntimeError, proc.fillProcessDesc, p)
4848 
4849  proc = Process("TEST")
4850  proc.ProcessAcceleratorTest = ProcessAcceleratorTest(
4851  moduleTypeResolverMaker=lambda accelerators: TestModuleTypeResolver(accelerators))
4852  proc.ProcessAcceleratorTest2 = ProcessAcceleratorTest2()
4853  proc.normalProducer = EDProducer("FooProducer")
4854  proc.testProducer = EDProducer("BarProducer@test")
4855  proc.test2Producer = EDProducer("BarProducer@test", test=untracked.PSet(backend=untracked.string("test2_backend")))
4856  proc.testAnalyzer = EDAnalyzer("Analyzer@test")
4857  proc.testFilter = EDAnalyzer("Filter@test")
4858  proc.testESProducer = ESProducer("ESProducer@test")
4859  proc.testESSource = ESSource("ESSource@test")
4860  proc.p = Path(proc.normalProducer+proc.testProducer+proc.test2Producer+proc.testAnalyzer+proc.testFilter)
4861  p = TestMakePSet()
4862  proc.fillProcessDesc(p)
4863  self.assertEqual("TestModuleTypeResolver", p.values["@module_type_resolver"][1])
4864  self.assertEqual("FooProducer", p.values["normalProducer"][1].values["@module_type"][1])
4865  self.assertEqual(len(list(filter(lambda x: not "@" in x, p.values["normalProducer"][1].values.keys()))), 0)
4866  self.assertEqual("BarProducer@test", p.values["testProducer"][1].values["@module_type"][1])
4867  self.assertEqual(False, p.values["testProducer"][1].values["test"][0])
4868  self.assertEqual(False, p.values["testProducer"][1].values["test"][1].values["backend"][0])
4869  self.assertEqual("test1_backend", p.values["testProducer"][1].values["test"][1].values["backend"][1])
4870  self.assertEqual("BarProducer@test", p.values["test2Producer"][1].values["@module_type"][1])
4871  self.assertEqual("test2_backend", p.values["test2Producer"][1].values["test"][1].values["backend"][1])
4872  self.assertEqual("Analyzer@test", p.values["testAnalyzer"][1].values["@module_type"][1])
4873  self.assertEqual("test1_backend", p.values["testAnalyzer"][1].values["test"][1].values["backend"][1])
4874  self.assertEqual("Filter@test", p.values["testFilter"][1].values["@module_type"][1])
4875  self.assertEqual("test1_backend", p.values["testFilter"][1].values["test"][1].values["backend"][1])
4876  self.assertEqual("ESProducer@test", p.values["ESProducer@test@testESProducer"][1].values["@module_type"][1])
4877  self.assertEqual("test1_backend", p.values["ESProducer@test@testESProducer"][1].values["test"][1].values["backend"][1])
4878  self.assertEqual("ESSource@test", p.values["ESSource@test@testESSource"][1].values["@module_type"][1])
4879  self.assertEqual("test1_backend", p.values["ESSource@test@testESSource"][1].values["test"][1].values["backend"][1])
4880 
4881  # No required accelerators available
4882  proc = Process("Test")
4883  proc.ProcessAcceleratorTest = ProcessAcceleratorTest(
4884  moduleTypeResolverMaker=lambda accelerators: TestModuleTypeResolver(accelerators))
4885  proc.options.accelerators = []
4886  self.assertRaises(EDMException, proc.fillProcessDesc, p)
4887 
4888  proc = Process("Test")
4889  proc.ProcessAcceleratorTest = ProcessAcceleratorTest(
4890  moduleTypeResolverMaker=lambda accelerators: TestModuleTypeResolver(accelerators))
4891  proc.options.accelerators = ["test1"]
4892  proc.test2Producer = EDProducer("BarProducer@test", test=untracked.PSet(backend=untracked.string("test2_backend")))
4893  proc.p = Path(proc.test2Producer)
4894  self.assertRaises(EDMException, proc.fillProcessDesc, p)
4895 
4896  # Two ProcessAccelerators return type resolver
4897  proc = Process("TEST")
4898  proc.ProcessAcceleratorTest = ProcessAcceleratorTest(
4899  moduleTypeResolverMaker=lambda accelerators: TestModuleTypeResolver(accelerators))
4900  proc.ProcessAcceleratorTest2 = ProcessAcceleratorTest2(
4901  moduleTypeResolverMaker=lambda accelerators: TestModuleTypeResolver(accelerators))
4902  p = TestMakePSet()
4903  self.assertRaises(RuntimeError, proc.fillProcessDesc, p)
4904 
4905  import pickle
4906  proc = Process("TEST")
4907  proc.ProcessAcceleratorTest = ProcessAcceleratorTest()
4908  proc.sp = SwitchProducerTest2(test2 = EDProducer("Foo",
4909  a = int32(1),
4910  b = PSet(c = int32(2))),
4911  test1 = EDProducer("Bar",
4912  aa = int32(11),
4913  bb = PSet(cc = int32(12))))
4914  proc.p = Path(proc.sp)
4915  pkl = pickle.dumps(proc)
4916  unpkl = pickle.loads(pkl)
4917  p = TestMakePSet()
4918  unpkl.fillProcessDesc(p)
4919  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
4920  self.assertEqual(["anothertest3", "cpu", "test1", "test2"], p.values["@available_accelerators"][1])
4921  unpkl = pickle.loads(pkl)
4922  unpkl.ProcessAcceleratorTest.setEnabled(["test1"])
4923  p = TestMakePSet()
4924  unpkl.fillProcessDesc(p)
4925  self.assertEqual((False, "sp@test1"), p.values["sp"][1].values["@chosen_case"])
4926  self.assertEqual(["cpu", "test1"], p.values["@available_accelerators"][1])
4927 
4928  unittest.main()
mixOne_cfi.ESProducer
ESProducer
Definition: mixOne_cfi.py:33
mps_fire.Path
Path
Definition: mps_fire.py:298
PSet
Definition: PSet.py:1
ALCARECOTkAlBeamHalo_cff.filter
filter
Definition: ALCARECOTkAlBeamHalo_cff.py:27

◆ testProcessDumpPython()

def Config.TestModuleCommand.testProcessDumpPython (   self)

Definition at line 2449 of file Config.py.

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

2449  def testProcessDumpPython(self):
2450  self.assertEqual(Process("test").dumpPython(),
2451 """import FWCore.ParameterSet.Config as cms
2452 
2453 process = cms.Process("test")
2454 
2455 process.maxEvents = cms.untracked.PSet(
2456  input = cms.optional.untracked.int32,
2457  output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
2458 )
2459 
2460 process.maxLuminosityBlocks = cms.untracked.PSet(
2461  input = cms.untracked.int32(-1)
2462 )
2463 
2464 process.options = cms.untracked.PSet(
2465  IgnoreCompletely = cms.untracked.vstring(),
2466  Rethrow = cms.untracked.vstring(),
2467  TryToContinue = cms.untracked.vstring(),
2468  accelerators = cms.untracked.vstring('*'),
2469  allowUnscheduled = cms.obsolete.untracked.bool,
2470  canDeleteEarly = cms.untracked.vstring(),
2471  deleteNonConsumedUnscheduledModules = cms.untracked.bool(True),
2472  dumpOptions = cms.untracked.bool(False),
2473  emptyRunLumiMode = cms.obsolete.untracked.string,
2474  eventSetup = cms.untracked.PSet(
2475  forceNumberOfConcurrentIOVs = cms.untracked.PSet(
2476  allowAnyLabel_=cms.required.untracked.uint32
2477  ),
2478  numberOfConcurrentIOVs = cms.untracked.uint32(0)
2479  ),
2480  fileMode = cms.untracked.string('FULLMERGE'),
2481  forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False),
2482  holdsReferencesToDeleteEarly = cms.untracked.VPSet(),
2483  makeTriggerResults = cms.obsolete.untracked.bool,
2484  modulesToCallForTryToContinue = cms.untracked.vstring(),
2485  modulesToIgnoreForDeleteEarly = cms.untracked.vstring(),
2486  numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(0),
2487  numberOfConcurrentRuns = cms.untracked.uint32(1),
2488  numberOfStreams = cms.untracked.uint32(0),
2489  numberOfThreads = cms.untracked.uint32(1),
2490  printDependencies = cms.untracked.bool(False),
2491  sizeOfStackForThreadsInKB = cms.optional.untracked.uint32,
2492  throwIfIllegalParameter = cms.untracked.bool(True),
2493  wantSummary = cms.untracked.bool(False)
2494 )
2495 
2496 process.MessageLogger = cms.Service("MessageLogger",
2497  cerr = cms.untracked.PSet(
2498  FwkReport = cms.untracked.PSet(
2499  limit = cms.untracked.int32(10000000),
2500  reportEvery = cms.untracked.int32(1)
2501  ),
2502  FwkSummary = cms.untracked.PSet(
2503  limit = cms.untracked.int32(10000000),
2504  reportEvery = cms.untracked.int32(1)
2505  ),
2506  INFO = cms.untracked.PSet(
2507  limit = cms.untracked.int32(0)
2508  ),
2509  Root_NoDictionary = cms.untracked.PSet(
2510  limit = cms.untracked.int32(0)
2511  ),
2512  default = cms.untracked.PSet(
2513  limit = cms.untracked.int32(10000000)
2514  ),
2515  enable = cms.untracked.bool(True),
2516  enableStatistics = cms.untracked.bool(False),
2517  lineLength = cms.optional.untracked.int32,
2518  noLineBreaks = cms.optional.untracked.bool,
2519  noTimeStamps = cms.untracked.bool(False),
2520  resetStatistics = cms.untracked.bool(False),
2521  statisticsThreshold = cms.untracked.string('WARNING'),
2522  threshold = cms.untracked.string('INFO'),
2523  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2524  limit = cms.optional.untracked.int32,
2525  reportEvery = cms.untracked.int32(1),
2526  timespan = cms.optional.untracked.int32
2527  )
2528  ),
2529  cout = cms.untracked.PSet(
2530  enable = cms.untracked.bool(False),
2531  enableStatistics = cms.untracked.bool(False),
2532  lineLength = cms.optional.untracked.int32,
2533  noLineBreaks = cms.optional.untracked.bool,
2534  noTimeStamps = cms.optional.untracked.bool,
2535  resetStatistics = cms.untracked.bool(False),
2536  statisticsThreshold = cms.optional.untracked.string,
2537  threshold = cms.optional.untracked.string,
2538  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2539  limit = cms.optional.untracked.int32,
2540  reportEvery = cms.untracked.int32(1),
2541  timespan = cms.optional.untracked.int32
2542  )
2543  ),
2544  debugModules = cms.untracked.vstring(),
2545  default = cms.untracked.PSet(
2546  limit = cms.optional.untracked.int32,
2547  lineLength = cms.untracked.int32(80),
2548  noLineBreaks = cms.untracked.bool(False),
2549  noTimeStamps = cms.untracked.bool(False),
2550  reportEvery = cms.untracked.int32(1),
2551  statisticsThreshold = cms.untracked.string('INFO'),
2552  threshold = cms.untracked.string('INFO'),
2553  timespan = cms.optional.untracked.int32,
2554  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2555  limit = cms.optional.untracked.int32,
2556  reportEvery = cms.untracked.int32(1),
2557  timespan = cms.optional.untracked.int32
2558  )
2559  ),
2560  files = cms.untracked.PSet(
2561  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2562  enableStatistics = cms.untracked.bool(False),
2563  extension = cms.optional.untracked.string,
2564  filename = cms.optional.untracked.string,
2565  lineLength = cms.optional.untracked.int32,
2566  noLineBreaks = cms.optional.untracked.bool,
2567  noTimeStamps = cms.optional.untracked.bool,
2568  output = cms.optional.untracked.string,
2569  resetStatistics = cms.untracked.bool(False),
2570  statisticsThreshold = cms.optional.untracked.string,
2571  threshold = cms.optional.untracked.string,
2572  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2573  limit = cms.optional.untracked.int32,
2574  reportEvery = cms.untracked.int32(1),
2575  timespan = cms.optional.untracked.int32
2576  )
2577  )
2578  ),
2579  suppressDebug = cms.untracked.vstring(),
2580  suppressFwkInfo = cms.untracked.vstring(),
2581  suppressInfo = cms.untracked.vstring(),
2582  suppressWarning = cms.untracked.vstring(),
2583  allowAnyLabel_=cms.optional.untracked.PSetTemplate(
2584  limit = cms.optional.untracked.int32,
2585  reportEvery = cms.untracked.int32(1),
2586  timespan = cms.optional.untracked.int32
2587  )
2588 )
2589 
2590 
2591 """)
2592  p = Process("test")
2593  p.a = EDAnalyzer("MyAnalyzer")
2594  p.p = Path(p.a)
2595  p.s = Sequence(p.a)
2596  p.r = Sequence(p.s)
2597  p.p2 = Path(p.s)
2598  p.schedule = Schedule(p.p2,p.p)
2599  d=p.dumpPython()
2600  self.assertEqual(_lineDiff(d,Process("test").dumpPython()),
2601 """process.a = cms.EDAnalyzer("MyAnalyzer")
2602 process.s = cms.Sequence(process.a)
2603 process.r = cms.Sequence(process.s)
2604 process.p = cms.Path(process.a)
2605 process.p2 = cms.Path(process.s)
2606 process.schedule = cms.Schedule(*[ process.p2, process.p ])""")
2607  #Reverse order of 'r' and 's'
2608  p = Process("test")
2609  p.a = EDAnalyzer("MyAnalyzer")
2610  p.p = Path(p.a)
2611  p.r = Sequence(p.a)
2612  p.s = Sequence(p.r)
2613  p.p2 = Path(p.r)
2614  p.schedule = Schedule(p.p2,p.p)
2615  p.b = EDAnalyzer("YourAnalyzer")
2616  d=p.dumpPython()
2617  self.assertEqual(_lineDiff(d,Process("test").dumpPython()),
2618 """process.a = cms.EDAnalyzer("MyAnalyzer")
2619 process.b = cms.EDAnalyzer("YourAnalyzer")
2620 process.r = cms.Sequence(process.a)
2621 process.s = cms.Sequence(process.r)
2622 process.p = cms.Path(process.a)
2623 process.p2 = cms.Path(process.r)
2624 process.schedule = cms.Schedule(*[ process.p2, process.p ])""")
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2095
mps_fire.Path
Path
Definition: mps_fire.py:298
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:96

◆ testProcessExtend()

def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 2354 of file Config.py.

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

2354  def testProcessExtend(self):
2355  class FromArg(object):
2356  def __init__(self,*arg,**args):
2357  for name in args.keys():
2358  self.__dict__[name]=args[name]
2359 
2360  a=EDAnalyzer("MyAnalyzer")
2361  t=EDAnalyzer("MyAnalyzer")
2362  t.setLabel("foo")
2363  s1 = Sequence(a)
2364  s2 = Sequence(s1)
2365  s3 = Sequence(s2)
2366  d = FromArg(
2367  a=a,
2368  b=Service("Full"),
2369  c=Path(a),
2370  d=s2,
2371  e=s1,
2372  f=s3,
2373  g=Sequence(s1+s2+s3)
2374  )
2375  p = Process("Test")
2376  p.extend(d)
2377  self.assertEqual(p.a.type_(),"MyAnalyzer")
2378  self.assertEqual(p.a.label_(),"a")
2379  self.assertRaises(AttributeError,getattr,p,'b')
2380  self.assertEqual(p.Full.type_(),"Full")
2381  self.assertEqual(str(p.c),'a')
2382  self.assertEqual(str(p.d),'a')
2383 
2384  z1 = FromArg(
2385  a=a,
2386  b=Service("Full"),
2387  c=Path(a),
2388  d=s2,
2389  e=s1,
2390  f=s3,
2391  s4=s3,
2392  g=Sequence(s1+s2+s3)
2393  )
2394 
2395  p1 = Process("Test")
2396  #p1.extend(z1)
2397  self.assertRaises(ValueError, p1.extend, z1)
2398 
2399  z2 = FromArg(
2400  a=a,
2401  b=Service("Full"),
2402  c=Path(a),
2403  d=s2,
2404  e=s1,
2405  f=s3,
2406  aaa=copy.deepcopy(a),
2407  s4=copy.deepcopy(s3),
2408  g=Sequence(s1+s2+s3),
2409  t=t
2410  )
2411  p2 = Process("Test")
2412  p2.extend(z2)
2413  #self.assertRaises(ValueError, p2.extend, z2)
2414  self.assertEqual(p2.s4.label_(),"s4")
2415  #p2.s4.setLabel("foo")
2416  self.assertRaises(ValueError, p2.s4.setLabel, "foo")
2417  p2.s4.setLabel("s4")
2418  p2.s4.setLabel(None)
2419  p2.s4.setLabel("foo")
2420  p2._Process__setObjectLabel(p2.s4, "foo")
2421  p2._Process__setObjectLabel(p2.s4, None)
2422  p2._Process__setObjectLabel(p2.s4, "bar")
2423 
2424 
2425  p = Process('test')
2426  p.a = EDProducer("MyProducer")
2427  p.t = Task(p.a)
2428  p.p = Path(p.t)
2429  self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
2430  self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
2431  self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())
2432 
2433  p = Process('test')
2434  p.a = EDProducer("MyProducer")
2435  p.t = ConditionalTask(p.a)
2436  p.p = Path(p.t)
2437  self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
2438  self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
2439  self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())
2440 
2441  p = Process('test')
2442  p.a = EDProducer("MyProducer")
2443  p.s = Sequence(p.a)
2444  p.p = Path(p.s)
2445  self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
2446  self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
2447  self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())
2448 
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:56
resolutioncreator_cfi.object
object
Definition: resolutioncreator_cfi.py:4

◆ testProcessForProcessAccelerator()

def Config.TestModuleCommand.testProcessForProcessAccelerator (   self)

Definition at line 4613 of file Config.py.

4613  def testProcessForProcessAccelerator(self):
4614  proc = Process("TEST")
4615  p = ProcessForProcessAccelerator(proc)
4616  p.TestService = Service("TestService")
4617  self.assertTrue(hasattr(proc, "TestService"))
4618  self.assertEqual(proc.TestService.type_(), "TestService")
4619  self.assertRaises(TypeError, setattr, p, "a", EDProducer("Foo"))
4620  p.add_(Service("TestServiceTwo"))
4621  self.assertTrue(hasattr(proc, "TestServiceTwo"))
4622  self.assertEqual(proc.TestServiceTwo.type_(), "TestServiceTwo")
4623  p.TestService.foo = untracked.uint32(42)
4624  self.assertEqual(proc.TestService.foo.value(), 42)
4625  proc.mod = EDProducer("Producer")
4626  self.assertRaises(TypeError, getattr, p, "mod")

◆ testProcessFragment()

def Config.TestModuleCommand.testProcessFragment (   self)

Definition at line 4596 of file Config.py.

4596  def testProcessFragment(self):
4597  #check defaults are not overwritten
4598  f = ProcessFragment('Fragment')
4599  p = Process('PROCESS')
4600  p.maxEvents.input = 10
4601  p.options.numberOfThreads = 4
4602  p.maxLuminosityBlocks.input = 2
4603  p.extend(f)
4604  self.assertEqual(p.maxEvents.input.value(),10)
4605  self.assertEqual(p.options.numberOfThreads.value(), 4)
4606  self.assertEqual(p.maxLuminosityBlocks.input.value(),2)
4607  #general checks
4608  f = ProcessFragment("Fragment")
4609  f.fltr = EDFilter("Foo")
4610  p = Process('PROCESS')
4611  p.extend(f)
4612  self.assertTrue(hasattr(p,'fltr'))

◆ testProcessInsertion()

def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 2329 of file Config.py.

2329  def testProcessInsertion(self):
2330  p = Process("test")
2331  p.a = EDAnalyzer("MyAnalyzer")
2332  self.assertTrue( 'a' in p.analyzers_() )
2333  self.assertTrue( 'a' in p.analyzers)
2334  p.add_(Service("SomeService"))
2335  self.assertTrue('SomeService' in p.services_())
2336  self.assertEqual(p.SomeService.type_(), "SomeService")
2337  p.Tracer = Service("Tracer")
2338  self.assertTrue('Tracer' in p.services_())
2339  self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
2340  self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
2341  self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
2342  p.out = OutputModule("Outer")
2343  self.assertEqual(p.out.type_(), 'Outer')
2344  self.assertTrue( 'out' in p.outputModules_() )
2345 
2346  p.geom = ESSource("GeomProd")
2347  self.assertTrue('geom' in p.es_sources_())
2348  p.add_(ESSource("ConfigDB"))
2349  self.assertTrue('ConfigDB' in p.es_sources_())
2350 
2351  p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
2352  self.assertTrue('aliasfoo1' in p.aliases_())
2353 
CollectionTags_cfi.Source
Source
Definition: CollectionTags_cfi.py:11
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
PSet
Definition: PSet.py:1
HistogramManager_cfi.VPSet
def VPSet(args)
Definition: HistogramManager_cfi.py:408

◆ testPrune()

def Config.TestModuleCommand.testPrune (   self)

Definition at line 3847 of file Config.py.

3847  def testPrune(self):
3848  p = Process("test")
3849  p.a = EDAnalyzer("MyAnalyzer")
3850  p.b = EDAnalyzer("YourAnalyzer")
3851  p.c = EDAnalyzer("OurAnalyzer")
3852  p.d = EDAnalyzer("OurAnalyzer")
3853  p.e = EDProducer("MyProducer")
3854  p.f = EDProducer("YourProducer")
3855  p.g = EDProducer("TheirProducer")
3856  p.h = EDProducer("OnesProducer")
3857  p.s = Sequence(p.d)
3858  p.t1 = Task(p.e)
3859  p.t2 = Task(p.f)
3860  p.t3 = Task(p.g, p.t1)
3861  p.ct1 = ConditionalTask(p.h)
3862  p.ct2 = ConditionalTask(p.f)
3863  p.ct3 = ConditionalTask(p.ct1)
3864  p.path1 = Path(p.a, p.t3, p.ct3)
3865  p.path2 = Path(p.b)
3866  self.assertTrue(p.schedule is None)
3867  pths = p.paths
3868  keys = pths.keys()
3869  self.assertEqual(pths[keys[0]],p.path1)
3870  self.assertEqual(pths[keys[1]],p.path2)
3871  p.pset1 = PSet(parA = string("pset1"))
3872  p.pset2 = untracked.PSet(parA = string("pset2"))
3873  p.vpset1 = VPSet()
3874  p.vpset2 = untracked.VPSet()
3875  p.prune()
3876  self.assertTrue(hasattr(p, 'a'))
3877  self.assertTrue(hasattr(p, 'b'))
3878  self.assertTrue(not hasattr(p, 'c'))
3879  self.assertTrue(not hasattr(p, 'd'))
3880  self.assertTrue(hasattr(p, 'e'))
3881  self.assertTrue(not hasattr(p, 'f'))
3882  self.assertTrue(hasattr(p, 'g'))
3883  self.assertTrue(hasattr(p, 'h'))
3884  self.assertTrue(not hasattr(p, 's'))
3885  self.assertTrue(hasattr(p, 't1'))
3886  self.assertTrue(not hasattr(p, 't2'))
3887  self.assertTrue(hasattr(p, 't3'))
3888  self.assertTrue(hasattr(p, 'path1'))
3889  self.assertTrue(hasattr(p, 'path2'))
3890 # self.assertTrue(not hasattr(p, 'pset1'))
3891 # self.assertTrue(hasattr(p, 'pset2'))
3892 # self.assertTrue(not hasattr(p, 'vpset1'))
3893 # self.assertTrue(not hasattr(p, 'vpset2'))
3894 
3895  p = Process("test")
3896  p.a = EDAnalyzer("MyAnalyzer")
3897  p.b = EDAnalyzer("YourAnalyzer")
3898  p.c = EDAnalyzer("OurAnalyzer")
3899  p.d = EDAnalyzer("OurAnalyzer")
3900  p.e = EDAnalyzer("OurAnalyzer")
3901  p.f = EDProducer("MyProducer")
3902  p.g = EDProducer("YourProducer")
3903  p.h = EDProducer("TheirProducer")
3904  p.i = EDProducer("OurProducer")
3905  p.j = EDProducer("OurProducer")
3906  p.k = EDProducer("OurProducer")
3907  p.l = EDProducer("OurProducer")
3908  p.t1 = Task(p.f)
3909  p.t2 = Task(p.g)
3910  p.t3 = Task(p.h)
3911  p.t4 = Task(p.i)
3912  p.ct1 = Task(p.f)
3913  p.ct2 = Task(p.j)
3914  p.ct3 = Task(p.k)
3915  p.ct4 = Task(p.l)
3916  p.s = Sequence(p.d, p.t1, p.ct1)
3917  p.s2 = Sequence(p.b, p.t2, p.ct2)
3918  p.s3 = Sequence(p.e)
3919  p.path1 = Path(p.a, p.t3, p.ct3)
3920  p.path2 = Path(p.b)
3921  p.path3 = Path(p.b+p.s2)
3922  p.path4 = Path(p.b+p.s3)
3923  p.schedule = Schedule(p.path1,p.path2,p.path3)
3924  p.schedule.associate(p.t4)
3925  pths = p.paths
3926  keys = pths.keys()
3927  self.assertEqual(pths[keys[0]],p.path1)
3928  self.assertEqual(pths[keys[1]],p.path2)
3929  p.prune()
3930  self.assertTrue(hasattr(p, 'a'))
3931  self.assertTrue(hasattr(p, 'b'))
3932  self.assertTrue(not hasattr(p, 'c'))
3933  self.assertTrue(not hasattr(p, 'd'))
3934  self.assertTrue(not hasattr(p, 'e'))
3935  self.assertTrue(not hasattr(p, 'f'))
3936  self.assertTrue(hasattr(p, 'g'))
3937  self.assertTrue(hasattr(p, 'h'))
3938  self.assertTrue(hasattr(p, 'i'))
3939  self.assertTrue(hasattr(p, 'j'))
3940  self.assertTrue(hasattr(p, 'k'))
3941  self.assertTrue(not hasattr(p, 'l'))
3942  self.assertTrue(not hasattr(p, 't1'))
3943  self.assertTrue(hasattr(p, 't2'))
3944  self.assertTrue(hasattr(p, 't3'))
3945  self.assertTrue(hasattr(p, 't4'))
3946  self.assertTrue(not hasattr(p, 'ct1'))
3947  self.assertTrue(hasattr(p, 'ct2'))
3948  self.assertTrue(hasattr(p, 'ct3'))
3949  self.assertTrue(not hasattr(p, 'ct4'))
3950  self.assertTrue(not hasattr(p, 's'))
3951  self.assertTrue(hasattr(p, 's2'))
3952  self.assertTrue(not hasattr(p, 's3'))
3953  self.assertTrue(hasattr(p, 'path1'))
3954  self.assertTrue(hasattr(p, 'path2'))
3955  self.assertTrue(hasattr(p, 'path3'))
3956  self.assertTrue(not hasattr(p, 'path4'))
3957  #test SequencePlaceholder
3958  p = Process("test")
3959  p.a = EDAnalyzer("MyAnalyzer")
3960  p.b = EDAnalyzer("YourAnalyzer")
3961  p.s = Sequence(SequencePlaceholder("a")+p.b)
3962  p.pth = Path(p.s)
3963  p.prune()
3964  self.assertTrue(hasattr(p, 'a'))
3965  self.assertTrue(hasattr(p, 'b'))
3966  self.assertTrue(hasattr(p, 's'))
3967  self.assertTrue(hasattr(p, 'pth'))
3968  #test unresolved SequencePlaceholder
3969  p = Process("test")
3970  p.b = EDAnalyzer("YourAnalyzer")
3971  p.s = Sequence(SequencePlaceholder("a")+p.b)
3972  p.pth = Path(p.s)
3973  p.prune(keepUnresolvedSequencePlaceholders=True)
3974  self.assertTrue(hasattr(p, 'b'))
3975  self.assertTrue(hasattr(p, 's'))
3976  self.assertTrue(hasattr(p, 'pth'))
3977  self.assertEqual(p.s.dumpPython(),'cms.Sequence(cms.SequencePlaceholder("a")+process.b)\n')
3978  #test TaskPlaceholder
3979  p = Process("test")
3980  p.a = EDProducer("MyProducer")
3981  p.b = EDProducer("YourProducer")
3982  p.s = Task(TaskPlaceholder("a"),p.b)
3983  p.pth = Path(p.s)
3984  p.prune()
3985  self.assertTrue(hasattr(p, 'a'))
3986  self.assertTrue(hasattr(p, 'b'))
3987  self.assertTrue(hasattr(p, 's'))
3988  self.assertTrue(hasattr(p, 'pth'))
3989  #test ConditionalTaskPlaceholder
3990  p = Process("test")
3991  p.a = EDProducer("MyProducer")
3992  p.b = EDProducer("YourProducer")
3993  p.s = ConditionalTask(ConditionalTaskPlaceholder("a"),p.b)
3994  p.pth = Path(p.s)
3995  p.prune()
3996  self.assertTrue(hasattr(p, 'a'))
3997  self.assertTrue(hasattr(p, 'b'))
3998  self.assertTrue(hasattr(p, 's'))
3999  self.assertTrue(hasattr(p, 'pth'))
4000  #test unresolved SequencePlaceholder
4001  p = Process("test")
4002  p.b = EDProducer("YourAnalyzer")
4003  p.s = Task(TaskPlaceholder("a"),p.b)
4004  p.pth = Path(p.s)
4005  p.prune(keepUnresolvedSequencePlaceholders=True)
4006  self.assertTrue(hasattr(p, 'b'))
4007  self.assertTrue(hasattr(p, 's'))
4008  self.assertTrue(hasattr(p, 'pth'))
4009  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
PSet
Definition: PSet.py:1
HistogramManager_cfi.VPSet
def VPSet(args)
Definition: HistogramManager_cfi.py:408

◆ testRefToPSet()

def Config.TestModuleCommand.testRefToPSet (   self)

Definition at line 3723 of file Config.py.

3723  def testRefToPSet(self):
3724  proc = Process("test")
3725  proc.top = PSet(a = int32(1))
3726  proc.ref = PSet(refToPSet_ = string("top"))
3727  proc.ref2 = PSet( a = int32(1), b = PSet( refToPSet_ = string("top")))
3728  proc.ref3 = PSet(refToPSet_ = string("ref"))
3729  proc.ref4 = VPSet(PSet(refToPSet_ = string("top")),
3730  PSet(refToPSet_ = string("ref2")))
3731  p = TestMakePSet()
3732  proc.fillProcessDesc(p)
3733  self.assertEqual((True,1),p.values["ref"][1].values["a"])
3734  self.assertEqual((True,1),p.values["ref3"][1].values["a"])
3735  self.assertEqual((True,1),p.values["ref2"][1].values["a"])
3736  self.assertEqual((True,1),p.values["ref2"][1].values["b"][1].values["a"])
3737  self.assertEqual((True,1),p.values["ref4"][1][0].values["a"])
3738  self.assertEqual((True,1),p.values["ref4"][1][1].values["a"])
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
PSet
Definition: PSet.py:1
HistogramManager_cfi.VPSet
def VPSet(args)
Definition: HistogramManager_cfi.py:408

◆ testSchedule()

def Config.TestModuleCommand.testSchedule (   self)

Definition at line 3436 of file Config.py.

3436  def testSchedule(self):
3437  p = Process("test")
3438  p.a = EDAnalyzer("MyAnalyzer")
3439  p.b = EDAnalyzer("YourAnalyzer")
3440  p.c = EDAnalyzer("OurAnalyzer")
3441  p.d = EDAnalyzer("OurAnalyzer")
3442  p.path1 = Path(p.a)
3443  p.path2 = Path(p.b)
3444  p.path3 = Path(p.d)
3445 
3446  s = Schedule(p.path1,p.path2)
3447  self.assertEqual(s[0],p.path1)
3448  self.assertEqual(s[1],p.path2)
3449  p.schedule = s
3450  self.assertTrue('b' in p.schedule.moduleNames())
3451  self.assertTrue(hasattr(p, 'b'))
3452  self.assertTrue(hasattr(p, 'c'))
3453  self.assertTrue(hasattr(p, 'd'))
3454  self.assertTrue(hasattr(p, 'path1'))
3455  self.assertTrue(hasattr(p, 'path2'))
3456  self.assertTrue(hasattr(p, 'path3'))
3457  p.prune()
3458  self.assertTrue('b' in p.schedule.moduleNames())
3459  self.assertTrue(hasattr(p, 'b'))
3460  self.assertTrue(not hasattr(p, 'c'))
3461  self.assertTrue(not hasattr(p, 'd'))
3462  self.assertTrue(hasattr(p, 'path1'))
3463  self.assertTrue(hasattr(p, 'path2'))
3464  self.assertTrue(not hasattr(p, 'path3'))
3465 
3466  self.assertTrue(len(p.schedule._tasks) == 0)
3467 
3468  p = Process("test")
3469  p.a = EDAnalyzer("MyAnalyzer")
3470  p.b = EDAnalyzer("YourAnalyzer")
3471  p.c = EDAnalyzer("OurAnalyzer")
3472  p.d = EDAnalyzer("dAnalyzer")
3473  p.e = EDProducer("eProducer")
3474  p.f = EDProducer("fProducer")
3475  p.Tracer = Service("Tracer")
3476  p.path1 = Path(p.a)
3477  p.path2 = Path(p.b)
3478  p.path3 = Path(p.d)
3479  p.task1 = Task(p.e)
3480  p.task2 = Task(p.f, p.Tracer)
3481  s = Schedule(p.path1,p.path2,tasks=[p.task1,p.task2,p.task1])
3482  self.assertEqual(s[0],p.path1)
3483  self.assertEqual(s[1],p.path2)
3484  self.assertTrue(len(s._tasks) == 2)
3485  self.assertTrue(p.task1 in s._tasks)
3486  self.assertTrue(p.task2 in s._tasks)
3487  listOfTasks = list(s._tasks)
3488  self.assertTrue(len(listOfTasks) == 2)
3489  self.assertTrue(p.task1 == listOfTasks[0])
3490  self.assertTrue(p.task2 == listOfTasks[1])
3491  p.schedule = s
3492  self.assertTrue('b' in p.schedule.moduleNames())
3493 
3494  process2 = Process("test")
3495  process2.a = EDAnalyzer("MyAnalyzer")
3496  process2.e = EDProducer("eProducer")
3497  process2.path1 = Path(process2.a)
3498  process2.task1 = Task(process2.e)
3499  process2.schedule = Schedule(process2.path1,tasks=process2.task1)
3500  listOfTasks = list(process2.schedule._tasks)
3501  self.assertTrue(listOfTasks[0] == process2.task1)
3502 
3503  # test Schedule copy
3504  s2 = s.copy()
3505  self.assertEqual(s2[0],p.path1)
3506  self.assertEqual(s2[1],p.path2)
3507  self.assertTrue(len(s2._tasks) == 2)
3508  self.assertTrue(p.task1 in s2._tasks)
3509  self.assertTrue(p.task2 in s2._tasks)
3510  listOfTasks = list(s2._tasks)
3511  self.assertTrue(len(listOfTasks) == 2)
3512  self.assertTrue(p.task1 == listOfTasks[0])
3513  self.assertTrue(p.task2 == listOfTasks[1])
3514 
3515  names = s.moduleNames()
3516  self.assertTrue(names == set(['a', 'b', 'e', 'Tracer', 'f']))
3517  #adding a path not attached to the Process should cause an exception
3518  p = Process("test")
3519  p.a = EDAnalyzer("MyAnalyzer")
3520  path1 = Path(p.a)
3521  s = Schedule(path1)
3522  self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
3523 
3524  #make sure anonymous sequences work
3525  p = Process("test")
3526  p.a = EDAnalyzer("MyAnalyzer")
3527  p.b = EDAnalyzer("MyOtherAnalyzer")
3528  p.c = EDProducer("MyProd")
3529  path1 = Path(p.c*Sequence(p.a+p.b))
3530  s = Schedule(path1)
3531  self.assertTrue('a' in s.moduleNames())
3532  self.assertTrue('b' in s.moduleNames())
3533  self.assertTrue('c' in s.moduleNames())
3534  p.path1 = path1
3535  p.schedule = s
3536  p.prune()
3537  self.assertTrue('a' in s.moduleNames())
3538  self.assertTrue('b' in s.moduleNames())
3539  self.assertTrue('c' in s.moduleNames())
3540 
mps_fire.Path
Path
Definition: mps_fire.py:298

◆ testSecSource()

def Config.TestModuleCommand.testSecSource (   self)

Definition at line 2763 of file Config.py.

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

2763  def testSecSource(self):
2764  p = Process('test')
2765  p.a = SecSource("MySecSource")
2766  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),'process.a = cms.SecSource("MySecSource")')
2767 
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2095
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:96

◆ testSequence()

def Config.TestModuleCommand.testSequence (   self)

Definition at line 2839 of file Config.py.

References str.

2839  def testSequence(self):
2840  p = Process('test')
2841  p.a = EDAnalyzer("MyAnalyzer")
2842  p.b = EDAnalyzer("YourAnalyzer")
2843  p.c = EDAnalyzer("OurAnalyzer")
2844  p.s = Sequence(p.a*p.b)
2845  self.assertEqual(str(p.s),'a+b')
2846  self.assertEqual(p.s.label_(),'s')
2847  path = Path(p.c+p.s)
2848  self.assertEqual(str(path),'c+a+b')
2849  p._validateSequence(path, 'p1')
2850  notInProcess = EDAnalyzer('NotInProcess')
2851  p2 = Path(p.c+p.s*notInProcess)
2852  self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
2853 
mps_fire.Path
Path
Definition: mps_fire.py:298
str
#define str(s)
Definition: TestProcessor.cc:56

◆ testSequence2()

def Config.TestModuleCommand.testSequence2 (   self)

Definition at line 2854 of file Config.py.

2854  def testSequence2(self):
2855  p = Process('test')
2856  p.a = EDAnalyzer("MyAnalyzer")
2857  p.b = EDAnalyzer("YourAnalyzer")
2858  p.c = EDAnalyzer("OurAnalyzer")
2859  testseq = Sequence(p.a*p.b)
2860  p.s = testseq
2861  #p.y = testseq
2862  self.assertRaises(ValueError, p.__setattr__, "y", testseq)
2863 

◆ testServiceInProcess()

def Config.TestModuleCommand.testServiceInProcess (   self)

Definition at line 2864 of file Config.py.

2864  def testServiceInProcess(self):
2865  service = Service("d")
2866  self.assertFalse(service._inProcess)
2867  process = Process("test")
2868  process.d = service
2869  self.assertTrue(service._inProcess)
2870  service2 = Service("d")
2871  process.d = service2
2872  self.assertFalse(service._inProcess)
2873  self.assertTrue(service2._inProcess)
2874  del process.d
2875  self.assertFalse(service2._inProcess)
2876 

◆ testSubProcess()

def Config.TestModuleCommand.testSubProcess (   self)

Definition at line 3688 of file Config.py.

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

3688  def testSubProcess(self):
3689  process = Process("Parent")
3690  subProcess = Process("Child")
3691  subProcess.a = EDProducer("A")
3692  subProcess.p = Path(subProcess.a)
3693  subProcess.add_(Service("Foo"))
3694  process.addSubProcess(SubProcess(subProcess))
3695  d = process.dumpPython()
3696  equalD ="""parentProcess = process
3697 process.a = cms.EDProducer("A")
3698 process.Foo = cms.Service("Foo")
3699 process.p = cms.Path(process.a)
3700 childProcess = process
3701 process = parentProcess
3702 process.addSubProcess(cms.SubProcess(process = childProcess, SelectEvents = cms.untracked.PSet(
3703 ), outputCommands = cms.untracked.vstring()))"""
3704  equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcesses_()[0])))
3705  # SubProcesses are dumped before Services, so in order to
3706  # craft the dump of the Parent and Child manually the dump
3707  # of the Parent needs to be split at the MessageLogger
3708  # boundary (now when it is part of Process by default),
3709  # and insert the dump of the Child between the top part of
3710  # the Parent (before MessageLogger) and the bottom part of
3711  # the Parent (after and including MessageLogger)
3712  messageLoggerSplit = 'process.MessageLogger = cms.Service'
3713  parentDumpSplit = Process('Parent').dumpPython().split(messageLoggerSplit)
3714  childProcess = Process('Child')
3715  del childProcess.MessageLogger
3716  combinedDump = parentDumpSplit[0] + childProcess.dumpPython() + messageLoggerSplit + parentDumpSplit[1]
3717  self.assertEqual(_lineDiff(d, combinedDump), equalD)
3718  p = TestMakePSet()
3719  process.fillProcessDesc(p)
3720  self.assertEqual((True,['a']),p.values["subProcesses"][1][0].values["process"][1].values['@all_modules'])
3721  self.assertEqual((True,['p']),p.values["subProcesses"][1][0].values["process"][1].values['@paths'])
3722  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:2095
mps_fire.Path
Path
Definition: mps_fire.py:298
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:96
str
#define str(s)
Definition: TestProcessor.cc:56

◆ testSwitchProducer()

def Config.TestModuleCommand.testSwitchProducer (   self)

Definition at line 3739 of file Config.py.

References jetUpdater_cfi.sort.

3739  def testSwitchProducer(self):
3740  proc = Process("test")
3741  proc.sp = SwitchProducerTest(test2 = EDProducer("Foo",
3742  a = int32(1),
3743  b = PSet(c = int32(2))),
3744  test1 = EDProducer("Bar",
3745  aa = int32(11),
3746  bb = PSet(cc = int32(12))))
3747  self.assertEqual(proc.sp.label_(), "sp")
3748  self.assertEqual(proc.sp.test1.label_(), "sp@test1")
3749  self.assertEqual(proc.sp.test2.label_(), "sp@test2")
3750 
3751  proc.a = EDProducer("A")
3752  proc.s = Sequence(proc.a + proc.sp)
3753  proc.t = Task(proc.a, proc.sp)
3754  proc.p = Path()
3755  proc.p.associate(proc.t)
3756  p = TestMakePSet()
3757  proc.fillProcessDesc(p)
3758  self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
3759  self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
3760  self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
3761  all_cases = copy.deepcopy(p.values["sp"][1].values["@all_cases"])
3762  all_cases[1].sort() # names of all cases come via dict, i.e. their order is undefined
3763  self.assertEqual((True, ["sp@test1", "sp@test2"]), all_cases)
3764  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
3765  self.assertEqual(["a", "sp", "sp@test1", "sp@test2"], p.values["@all_modules"][1])
3766  self.assertEqual((True,"EDProducer"), p.values["sp@test1"][1].values["@module_edm_type"])
3767  self.assertEqual((True,"Bar"), p.values["sp@test1"][1].values["@module_type"])
3768  self.assertEqual((True,"EDProducer"), p.values["sp@test2"][1].values["@module_edm_type"])
3769  self.assertEqual((True,"Foo"), p.values["sp@test2"][1].values["@module_type"])
3770  dump = proc.dumpPython()
3771  self.assertEqual(dump.find('@'), -1)
3772  self.assertEqual(specialImportRegistry.getSpecialImports(), ["from test import SwitchProducerTest"])
3773  self.assertTrue(dump.find("\nfrom test import SwitchProducerTest\n") != -1)
3774 
3775  # EDAlias as non-chosen case
3776  proc = Process("test")
3777  proc.sp = SwitchProducerTest(test2 = EDProducer("Foo",
3778  a = int32(1),
3779  b = PSet(c = int32(2))),
3780  test1 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
3781  proc.a = EDProducer("A")
3782  proc.s = Sequence(proc.a + proc.sp)
3783  proc.t = Task(proc.a, proc.sp)
3784  proc.p = Path()
3785  proc.p.associate(proc.t)
3786  p = TestMakePSet()
3787  proc.fillProcessDesc(p)
3788  self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
3789  self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
3790  self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
3791  all_cases = copy.deepcopy(p.values["sp"][1].values["@all_cases"])
3792  all_cases[1].sort()
3793  self.assertEqual((True, ["sp@test1", "sp@test2"]), all_cases)
3794  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
3795  self.assertEqual(["a", "sp", "sp@test2"], p.values["@all_modules"][1])
3796  self.assertEqual(["sp@test1"], p.values["@all_aliases"][1])
3797  self.assertEqual((True,"EDProducer"), p.values["sp@test2"][1].values["@module_edm_type"])
3798  self.assertEqual((True,"Foo"), p.values["sp@test2"][1].values["@module_type"])
3799  self.assertEqual((True,"EDAlias"), p.values["sp@test1"][1].values["@module_edm_type"])
3800  self.assertEqual((True,"Bar"), p.values["sp@test1"][1].values["a"][1][0].values["type"])
3801 
3802  # EDAlias as chosen case
3803  proc = Process("test")
3804  proc.sp = SwitchProducerTest(test1 = EDProducer("Foo",
3805  a = int32(1),
3806  b = PSet(c = int32(2))),
3807  test2 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
3808  proc.a = EDProducer("A")
3809  proc.s = Sequence(proc.a + proc.sp)
3810  proc.t = Task(proc.a, proc.sp)
3811  proc.p = Path()
3812  proc.p.associate(proc.t)
3813  p = TestMakePSet()
3814  proc.fillProcessDesc(p)
3815  self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
3816  self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
3817  self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
3818  self.assertEqual((True, ["sp@test1", "sp@test2"]), p.values["sp"][1].values["@all_cases"])
3819  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
3820  self.assertEqual(["a", "sp", "sp@test1"], p.values["@all_modules"][1])
3821  self.assertEqual(["sp@test2"], p.values["@all_aliases"][1])
3822  self.assertEqual((True,"EDProducer"), p.values["sp@test1"][1].values["@module_edm_type"])
3823  self.assertEqual((True,"Foo"), p.values["sp@test1"][1].values["@module_type"])
3824  self.assertEqual((True,"EDAlias"), p.values["sp@test2"][1].values["@module_edm_type"])
3825  self.assertEqual((True,"Bar"), p.values["sp@test2"][1].values["a"][1][0].values["type"])
3826 
3827  # ConditionalTask
3828  proc = Process("test")
3829  proc.spct = SwitchProducerTest(test2 = EDProducer("Foo",
3830  a = int32(1),
3831  b = PSet(c = int32(2))),
3832  test1 = EDProducer("Bar",
3833  aa = int32(11),
3834  bb = PSet(cc = int32(12))),
3835  test3 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
3836  proc.spp = proc.spct.clone()
3837  proc.a = EDProducer("A")
3838  proc.ct = ConditionalTask(proc.spct)
3839  proc.p = Path(proc.a, proc.ct)
3840  proc.pp = Path(proc.a + proc.spp)
3841  p = TestMakePSet()
3842  proc.fillProcessDesc(p)
3843  self.assertEqual(["a", "spct", "spct@test1", "spct@test2", "spp", "spp@test1", "spp@test2"], p.values["@all_modules"][1])
3844  self.assertEqual(["a", "#", "spct", "spct@test1", "spct@test2", "@"], p.values["p"][1])
3845  self.assertEqual(["a", "spp", "#", "spp@test1", "spp@test2", "@"], p.values["pp"][1])
3846 
jetUpdater_cfi.sort
sort
Definition: jetUpdater_cfi.py:30
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
mps_fire.Path
Path
Definition: mps_fire.py:298
PSet
Definition: PSet.py:1
HistogramManager_cfi.VPSet
def VPSet(args)
Definition: HistogramManager_cfi.py:408

◆ testTask()

def Config.TestModuleCommand.testTask (   self)

Definition at line 2877 of file Config.py.

2877  def testTask(self):
2878 
2879  # create some objects to use in tests
2880  edanalyzer = EDAnalyzer("a")
2881  edproducer = EDProducer("b")
2882  edproducer2 = EDProducer("b2")
2883  edproducer3 = EDProducer("b3")
2884  edproducer4 = EDProducer("b4")
2885  edproducer8 = EDProducer("b8")
2886  edproducer9 = EDProducer("b9")
2887  edfilter = EDFilter("c")
2888  service = Service("d")
2889  service3 = Service("d", v = untracked.uint32(3))
2890  essource = ESSource("e")
2891  esproducer = ESProducer("f")
2892  testTask2 = Task()
2893 
2894  # test adding things to Tasks
2895  testTask1 = Task(edproducer, edfilter)
2896  self.assertRaises(RuntimeError, testTask1.add, edanalyzer)
2897  testTask1.add(essource, service)
2898  testTask1.add(essource, esproducer)
2899  testTask1.add(testTask2)
2900  coll = testTask1._collection
2901  self.assertTrue(edproducer in coll)
2902  self.assertTrue(edfilter in coll)
2903  self.assertTrue(service in coll)
2904  self.assertTrue(essource in coll)
2905  self.assertTrue(esproducer in coll)
2906  self.assertTrue(testTask2 in coll)
2907  self.assertTrue(len(coll) == 6)
2908  self.assertTrue(len(testTask2._collection) == 0)
2909 
2910  taskContents = []
2911  for i in testTask1:
2912  taskContents.append(i)
2913  self.assertTrue(taskContents == [edproducer, edfilter, essource, service, esproducer, testTask2])
2914 
2915  # test attaching Task to Process
2916  process = Process("test")
2917 
2918  process.mproducer = edproducer
2919  process.mproducer2 = edproducer2
2920  process.mfilter = edfilter
2921  process.messource = essource
2922  process.mesproducer = esproducer
2923  process.d = service
2924 
2925  testTask3 = Task(edproducer, edproducer2)
2926  testTask1.add(testTask3)
2927  process.myTask1 = testTask1
2928 
2929  # test the validation that occurs when attaching a Task to a Process
2930  # first a case that passes, then one the fails on an EDProducer
2931  # then one that fails on a service
2932  l = set()
2933  visitor = NodeNameVisitor(l)
2934  testTask1.visit(visitor)
2935  self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
2936  l2 = testTask1.moduleNames
2937  self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
2938 
2939  testTask4 = Task(edproducer3)
2940  l.clear()
2941  self.assertRaises(RuntimeError, testTask4.visit, visitor)
2942  try:
2943  process.myTask4 = testTask4
2944  self.assertTrue(False)
2945  except RuntimeError:
2946  pass
2947 
2948  testTask5 = Task(service3)
2949  l.clear()
2950  self.assertRaises(RuntimeError, testTask5.visit, visitor)
2951  try:
2952  process.myTask5 = testTask5
2953  self.assertTrue(False)
2954  except RuntimeError:
2955  pass
2956 
2957  process.d = service3
2958  process.myTask5 = testTask5
2959 
2960  # test placement into the Process and the tasks property
2961  expectedDict = { 'myTask1' : testTask1, 'myTask5' : testTask5 }
2962  expectedFixedDict = DictTypes.FixedKeysDict(expectedDict);
2963  self.assertTrue(process.tasks == expectedFixedDict)
2964  self.assertTrue(process.tasks['myTask1'] == testTask1)
2965  self.assertTrue(process.myTask1 == testTask1)
2966 
2967  # test replacing an EDProducer in a Task when calling __settattr__
2968  # for the EDProducer on the Process.
2969  process.mproducer2 = edproducer4
2970  process.d = service
2971  l = list()
2972  visitor1 = ModuleNodeVisitor(l)
2973  testTask1.visit(visitor1)
2974  l.sort(key=lambda mod: mod.__str__())
2975  expectedList = sorted([edproducer,essource,esproducer,service,edfilter,edproducer,edproducer4],key=lambda mod: mod.__str__())
2976  self.assertTrue(expectedList == l)
2977  process.myTask6 = Task()
2978  process.myTask7 = Task()
2979  process.mproducer8 = edproducer8
2980  process.myTask8 = Task(process.mproducer8)
2981  process.myTask6.add(process.myTask7)
2982  process.myTask7.add(process.myTask8)
2983  process.myTask1.add(process.myTask6)
2984  process.myTask8.add(process.myTask5)
2985 
2986  testDict = process._itemsInDependencyOrder(process.tasks)
2987  expectedLabels = ["myTask5", "myTask8", "myTask7", "myTask6", "myTask1"]
2988  expectedTasks = [process.myTask5, process.myTask8, process.myTask7, process.myTask6, process.myTask1]
2989  index = 0
2990  for testLabel, testTask in testDict.items():
2991  self.assertTrue(testLabel == expectedLabels[index])
2992  self.assertTrue(testTask == expectedTasks[index])
2993  index += 1
2994 
2995  pythonDump = testTask1.dumpPython(PrintOptions())
2996 
2997 
2998  expectedPythonDump = 'cms.Task(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer, process.mproducer2, process.myTask6)\n'
2999  self.assertTrue(pythonDump == expectedPythonDump)
3000 
3001  process.myTask5 = Task()
3002  process.myTask100 = Task()
3003  process.mproducer9 = edproducer9
3004  sequence1 = Sequence(process.mproducer8, process.myTask1, process.myTask5, testTask2, testTask3)
3005  sequence2 = Sequence(process.mproducer8 + process.mproducer9)
3006  process.sequence3 = Sequence((process.mproducer8 + process.mfilter))
3007  sequence4 = Sequence()
3008  process.path1 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+sequence4)
3009  process.path1.associate(process.myTask1, process.myTask5, testTask2, testTask3)
3010  process.path11 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+ sequence4,process.myTask1, process.myTask5, testTask2, testTask3, process.myTask100)
3011  process.path2 = Path(process.mproducer)
3012  process.path3 = Path(process.mproducer9+process.mproducer8,testTask2)
3013 
3014  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')
3015 
3016  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')
3017 
3018  # test NodeNameVisitor and moduleNames
3019  l = set()
3020  nameVisitor = NodeNameVisitor(l)
3021  process.path1.visit(nameVisitor)
3022  self.assertTrue(l == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
3023  self.assertTrue(process.path1.moduleNames() == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
3024 
3025  # test copy
3026  process.mproducer10 = EDProducer("b10")
3027  process.path21 = process.path11.copy()
3028  process.path21.replace(process.mproducer, process.mproducer10)
3029 
3030  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')
3031 
3032  # Some peculiarities of the way things work show up here. dumpPython sorts tasks and
3033  # removes duplication at the level of strings. The Task and Sequence objects themselves
3034  # remove duplicate tasks in their contents if the instances are the same (exact same python
3035  # object id which is not the same as the string representation being the same).
3036  # Also note that the mutating visitor replaces sequences and tasks that have
3037  # modified contents with their modified contents, it does not modify the sequence
3038  # or task itself.
3039  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')
3040 
3041  process.path22 = process.path21.copyAndExclude([process.d, process.mesproducer, process.mfilter])
3042  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')
3043 
3044  process.path23 = process.path22.copyAndExclude([process.messource, process.mproducer10])
3045  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')
3046 
3047  process.a = EDAnalyzer("MyAnalyzer")
3048  process.b = OutputModule("MyOutputModule")
3049  process.c = EDFilter("MyFilter")
3050  process.d = EDProducer("MyProducer")
3051  process.e = ESProducer("MyESProducer")
3052  process.f = ESSource("MyESSource")
3053  process.g = ESProducer("g")
3054  process.path24 = Path(process.a+process.b+process.c+process.d)
3055  process.path25 = process.path24.copyAndExclude([process.a,process.b,process.c])
3056  self.assertTrue(process.path25.dumpPython() == 'cms.Path(process.d)\n')
3057  #print process.path3
3058  #print process.dumpPython()
3059 
3060  process.path200 = EndPath(Sequence(process.c,Task(process.e)))
3061  process.path200.replace(process.c,process.b)
3062  process.path200.replace(process.e,process.f)
3063  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.b, cms.Task(process.f))\n")
3064  process.path200.replace(process.b,process.c)
3065  process.path200.replace(process.f,process.e)
3066  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.c, cms.Task(process.e))\n")
3067  process.path200.replace(process.c,process.a)
3068  process.path200.replace(process.e,process.g)
3069  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.a, cms.Task(process.g))\n")
3070  process.path200.replace(process.a,process.c)
3071  process.path200.replace(process.g,process.e)
3072  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.c, cms.Task(process.e))\n")
3073 
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 4010 of file Config.py.

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

4010  def testTaskPlaceholder(self):
4011  p = Process("test")
4012  p.a = EDProducer("ma")
4013  p.b = EDAnalyzer("mb")
4014  p.t1 = Task(TaskPlaceholder("c"))
4015  p.t2 = Task(p.a, TaskPlaceholder("d"), p.t1)
4016  p.t3 = Task(TaskPlaceholder("e"))
4017  p.path1 = Path(p.b, p.t2, p.t3)
4018  p.t5 = Task(p.a, TaskPlaceholder("g"), TaskPlaceholder("t4"))
4019  p.t4 = Task(TaskPlaceholder("f"))
4020  p.endpath1 = EndPath(p.b, p.t5)
4021  p.t6 = Task(TaskPlaceholder("h"))
4022  p.t7 = Task(p.a, TaskPlaceholder("i"), p.t6)
4023  p.t8 = Task(TaskPlaceholder("j"))
4024  p.schedule = Schedule(p.path1, p.endpath1,tasks=[p.t7,p.t8])
4025  p.c = EDProducer("mc")
4026  p.d = EDProducer("md")
4027  p.e = EDProducer("me")
4028  p.f = EDProducer("mf")
4029  p.g = EDProducer("mg")
4030  p.h = EDProducer("mh")
4031  p.i = EDProducer("mi")
4032  p.j = EDProducer("mj")
4033  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
4034 """process.a = cms.EDProducer("ma")
4035 process.c = cms.EDProducer("mc")
4036 process.d = cms.EDProducer("md")
4037 process.e = cms.EDProducer("me")
4038 process.f = cms.EDProducer("mf")
4039 process.g = cms.EDProducer("mg")
4040 process.h = cms.EDProducer("mh")
4041 process.i = cms.EDProducer("mi")
4042 process.j = cms.EDProducer("mj")
4043 process.b = cms.EDAnalyzer("mb")
4044 process.t1 = cms.Task(cms.TaskPlaceholder("c"))
4045 process.t2 = cms.Task(cms.TaskPlaceholder("d"), process.a, process.t1)
4046 process.t3 = cms.Task(cms.TaskPlaceholder("e"))
4047 process.t5 = cms.Task(cms.TaskPlaceholder("g"), cms.TaskPlaceholder("t4"), process.a)
4048 process.t4 = cms.Task(cms.TaskPlaceholder("f"))
4049 process.t6 = cms.Task(cms.TaskPlaceholder("h"))
4050 process.t7 = cms.Task(cms.TaskPlaceholder("i"), process.a, process.t6)
4051 process.t8 = cms.Task(cms.TaskPlaceholder("j"))
4052 process.path1 = cms.Path(process.b, process.t2, process.t3)
4053 process.endpath1 = cms.EndPath(process.b, process.t5)
4054 process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])""")
4055  p.resolve()
4056  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
4057 """process.a = cms.EDProducer("ma")
4058 process.c = cms.EDProducer("mc")
4059 process.d = cms.EDProducer("md")
4060 process.e = cms.EDProducer("me")
4061 process.f = cms.EDProducer("mf")
4062 process.g = cms.EDProducer("mg")
4063 process.h = cms.EDProducer("mh")
4064 process.i = cms.EDProducer("mi")
4065 process.j = cms.EDProducer("mj")
4066 process.b = cms.EDAnalyzer("mb")
4067 process.t1 = cms.Task(process.c)
4068 process.t2 = cms.Task(process.a, process.d, process.t1)
4069 process.t3 = cms.Task(process.e)
4070 process.t4 = cms.Task(process.f)
4071 process.t6 = cms.Task(process.h)
4072 process.t7 = cms.Task(process.a, process.i, process.t6)
4073 process.t8 = cms.Task(process.j)
4074 process.t5 = cms.Task(process.a, process.g, process.t4)
4075 process.path1 = cms.Path(process.b, process.t2, process.t3)
4076 process.endpath1 = cms.EndPath(process.b, process.t5)
4077 process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])""")
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:2095
mps_fire.Path
Path
Definition: mps_fire.py:298
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:96

◆ testTypedParameterizable()

def Config.TestModuleCommand.testTypedParameterizable (   self)

Definition at line 2322 of file Config.py.

2322  def testTypedParameterizable(self):
2323  p = _TypedParameterizable("blah", b=int32(1))
2324  #see if copy works deeply
2325  other = p.copy()
2326  other.b = 2
2327  self.assertNotEqual(p.b,other.b)
2328 

◆ testUsing()

def Config.TestModuleCommand.testUsing (   self)

Definition at line 3574 of file Config.py.

3574  def testUsing(self):
3575  p = Process('test')
3576  p.block = PSet(a = int32(1))
3577  p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
3578  self.assertEqual(p.modu.a.value(),1)
3579  self.assertEqual(p.modu.b.value(),2)
3580 
PSet
Definition: PSet.py:1

Member Data Documentation

◆ a

Config.TestModuleCommand.a
static

Definition at line 2627 of file Config.py.

◆ b

Config.TestModuleCommand.b
static

Definition at line 2644 of file Config.py.

◆ c

Config.TestModuleCommand.c
static

Definition at line 2645 of file Config.py.

◆ d

Config.TestModuleCommand.d
static

Definition at line 2633 of file Config.py.

◆ e

Config.TestModuleCommand.e
static

Definition at line 2647 of file Config.py.

◆ f

Config.TestModuleCommand.f
static

Definition at line 2648 of file Config.py.

◆ g

Config.TestModuleCommand.g
static

Definition at line 2649 of file Config.py.

◆ maxDiff

Config.TestModuleCommand.maxDiff

Definition at line 4641 of file Config.py.

◆ p

Config.TestModuleCommand.p
static

Definition at line 2626 of file Config.py.

Referenced by Electron.Electron.ptErr().

◆ p2

Config.TestModuleCommand.p2
static

Definition at line 2631 of file Config.py.

◆ proc_mod_

Config.TestModuleCommand.proc_mod_

Definition at line 4304 of file Config.py.

◆ process

Config.TestModuleCommand.process
static

Definition at line 2742 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 2630 of file Config.py.

◆ s

Config.TestModuleCommand.s
static

Definition at line 2629 of file Config.py.

◆ s1

Config.TestModuleCommand.s1
static

Definition at line 2750 of file Config.py.

◆ s2

Config.TestModuleCommand.s2
static

Definition at line 2740 of file Config.py.

◆ s3

Config.TestModuleCommand.s3
static

Definition at line 2752 of file Config.py.

◆ schedule

Config.TestModuleCommand.schedule
static

Definition at line 2632 of file Config.py.

◆ task1

Config.TestModuleCommand.task1
static

Definition at line 2654 of file Config.py.

◆ task2

Config.TestModuleCommand.task2
static

Definition at line 2652 of file Config.py.

◆ task3

Config.TestModuleCommand.task3
static

Definition at line 2651 of file Config.py.

◆ task4

Config.TestModuleCommand.task4
static

Definition at line 2653 of file Config.py.

◆ task5

Config.TestModuleCommand.task5
static

Definition at line 2650 of file Config.py.

◆ tasks

Config.TestModuleCommand.tasks
static

Definition at line 2660 of file Config.py.

Generated for CMSSW Reference Manual by doxygen 1.8.14