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 testContains (self)
 
def testDelete (self)
 
def testExamples (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 testProcessDumpPython (self)
 
def testProcessExtend (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

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

Member Function Documentation

◆ setUp()

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

Definition at line 1836 of file Config.py.

1836  def setUp(self):
1837  """Nothing to do """
1838  None

◆ testCloneSequence()

def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 2501 of file Config.py.

2501  def testCloneSequence(self):
2502  p = Process("test")
2503  a = EDAnalyzer("MyAnalyzer")
2504  p.a = a
2505  a.setLabel("a")
2506  b = EDAnalyzer("YOurAnalyzer")
2507  p.b = b
2508  b.setLabel("b")
2509  path = Path(a * b)
2510  p.path = Path(p.a*p.b)
2511  lookuptable = {id(a): p.a, id(b): p.b}
2512  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
2513  #lookuptable = p._cloneToObjectDict
2514  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
2515  self.assertEqual(str(path),str(p.path))
2516 

References triggerObjects_cff.id, and str.

◆ testContains()

def Config.TestModuleCommand.testContains (   self)

Definition at line 2517 of file Config.py.

2517  def testContains(self):
2518 
2519  a = EDProducer("a")
2520  b = EDProducer("b")
2521  c = EDProducer("c")
2522  d = EDProducer("d")
2523  e = EDProducer("e")
2524  f = EDProducer("f")
2525  g = EDProducer("g")
2526  h = EDProducer("h")
2527  i = EDProducer("i")
2528  j = EDProducer("j")
2529  k = EDProducer("k")
2530  l = EDProducer("l")
2531  m = EDProducer("m")
2532  n = EDProducer("n")
2533 
2534  seq1 = Sequence(e)
2535  task1 = Task(g)
2536  path = Path(a * c * seq1, task1)
2537 
2538  self.assertTrue(path.contains(a))
2539  self.assertFalse(path.contains(b))
2540  self.assertTrue(path.contains(c))
2541  self.assertFalse(path.contains(d))
2542  self.assertTrue(path.contains(e))
2543  self.assertFalse(path.contains(f))
2544  self.assertTrue(path.contains(g))
2545 
2546  endpath = EndPath(h * i)
2547  self.assertFalse(endpath.contains(b))
2548  self.assertTrue(endpath.contains(i))
2549 
2550  seq = Sequence(a * c)
2551  self.assertFalse(seq.contains(b))
2552  self.assertTrue(seq.contains(c))
2553 
2554  task2 = Task(l)
2555  task = Task(j, k, task2)
2556  self.assertFalse(task.contains(b))
2557  self.assertTrue(task.contains(j))
2558  self.assertTrue(task.contains(k))
2559  self.assertTrue(task.contains(l))
2560 
2561  task3 = Task(m)
2562  path2 = Path(n)
2563  sch = Schedule(path, path2, tasks=[task,task3])
2564  self.assertFalse(sch.contains(b))
2565  self.assertTrue(sch.contains(a))
2566  self.assertTrue(sch.contains(c))
2567  self.assertTrue(sch.contains(e))
2568  self.assertTrue(sch.contains(g))
2569  self.assertTrue(sch.contains(n))
2570  self.assertTrue(sch.contains(j))
2571  self.assertTrue(sch.contains(k))
2572  self.assertTrue(sch.contains(l))
2573  self.assertTrue(sch.contains(m))
2574 

◆ testDelete()

def Config.TestModuleCommand.testDelete (   self)

Definition at line 3145 of file Config.py.

3145  def testDelete(self):
3146  p = Process("test")
3147  p.a = EDAnalyzer("MyAnalyzer")
3148  p.b = EDAnalyzer("YourAnalyzer")
3149  p.c = EDAnalyzer("OurAnalyzer")
3150  p.d = EDAnalyzer("OurAnalyzer")
3151  p.e = EDAnalyzer("OurAnalyzer")
3152  p.f = EDAnalyzer("OurAnalyzer")
3153  p.g = EDProducer("OurProducer")
3154  p.h = EDProducer("YourProducer")
3155  p.t1 = Task(p.g, p.h)
3156  t2 = Task(p.g, p.h)
3157  t3 = Task(p.g, p.h)
3158  p.s = Sequence(p.d+p.e)
3159  p.path1 = Path(p.a+p.f+p.s,t2)
3160  p.endpath1 = EndPath(p.b+p.f)
3161  p.schedule = Schedule(tasks=[t3])
3162  self.assertTrue(hasattr(p, 'f'))
3163  self.assertTrue(hasattr(p, 'g'))
3164  del p.e
3165  del p.f
3166  del p.g
3167  self.assertFalse(hasattr(p, 'f'))
3168  self.assertFalse(hasattr(p, 'g'))
3169  self.assertTrue(p.t1.dumpPython() == 'cms.Task(process.h)\n')
3170  self.assertTrue(p.s.dumpPython() == 'cms.Sequence(process.d)\n')
3171  self.assertTrue(p.path1.dumpPython() == 'cms.Path(process.a+process.s, cms.Task(process.h))\n')
3172  self.assertTrue(p.endpath1.dumpPython() == 'cms.EndPath(process.b)\n')
3173  del p.s
3174  self.assertTrue(p.path1.dumpPython() == 'cms.Path(process.a+(process.d), cms.Task(process.h))\n')
3175  self.assertTrue(p.schedule_().dumpPython() == 'cms.Schedule(tasks=[cms.Task(process.h)])\n')

References ConfigBuilder.dumpPython().

◆ testExamples()

def Config.TestModuleCommand.testExamples (   self)

Definition at line 2770 of file Config.py.

2770  def testExamples(self):
2771  p = Process("Test")
2772  p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
2773  p.foos = EDProducer("FooProducer")
2774  p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
2775  p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
2776  p.bars.foos = 'Foosball'
2777  self.assertEqual(p.bars.foos, InputTag('Foosball'))
2778  p.p = Path(p.foos*p.bars)
2779  p.e = EndPath(p.out)
2780  p.add_(Service("MessageLogger"))
2781 

References Types.untracked.

◆ testFreeze()

def Config.TestModuleCommand.testFreeze (   self)

Definition at line 2802 of file Config.py.

2802  def testFreeze(self):
2803  process = Process("Freeze")
2804  m = EDProducer("M", p=PSet(i = int32(1)))
2805  m.p.i = 2
2806  process.m = m
2807  # should be frozen
2808  #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
2809  #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
2810  #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
2811  #self.assertRaises(ValueError, setattr, m, 'j', 1)
2812  # But OK to change through the process
2813  process.m.p.i = 4
2814  self.assertEqual(process.m.p.i.value(), 4)
2815  process.m.p = PSet(j=int32(1))
2816  # should work to clone it, though
2817  m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
2818  m2.p.i = 6
2819  m2.j = 8

◆ testGlobalReplace()

def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 2173 of file Config.py.

2173  def testGlobalReplace(self):
2174  p = Process('test')
2175  p.a = EDAnalyzer("MyAnalyzer")
2176  old = p.a
2177  p.b = EDAnalyzer("YourAnalyzer")
2178  p.c = EDAnalyzer("OurAnalyzer")
2179  p.d = EDProducer("MyProducer")
2180  old2 = p.d
2181  p.t1 = Task(p.d)
2182  t2 = Task(p.d)
2183  t3 = Task(p.d)
2184  t4 = Task(p.d)
2185  t5 = Task(p.d)
2186  t6 = Task(p.d)
2187  s = Sequence(p.a*p.b)
2188  p.s4 = Sequence(p.a*p.b)
2189  s.associate(t2)
2190  p.s4.associate(t2)
2191  p.p = Path(p.c+s+p.a)
2192  p.p2 = Path(p.c+p.s4+p.a)
2193  p.e3 = EndPath(p.c+s+p.a)
2194  new = EDAnalyzer("NewAnalyzer")
2195  new2 = EDProducer("NewProducer")
2196  visitor1 = NodeVisitor()
2197  p.p.visit(visitor1)
2198  self.assertTrue(visitor1.modules == set([old,old2,p.b,p.c]))
2199  p.schedule = Schedule(tasks=[t6])
2200  p.globalReplace("a",new)
2201  p.globalReplace("d",new2)
2202  visitor2 = NodeVisitor()
2203  p.p.visit(visitor2)
2204  self.assertTrue(visitor2.modules == set([new,new2,p.b,p.c]))
2205  self.assertEqual(p.p.dumpPython()[:-1], "cms.Path(process.c+process.a+process.b+process.a, cms.Task(process.d))")
2206  visitor_p2 = NodeVisitor()
2207  p.p2.visit(visitor_p2)
2208  self.assertTrue(visitor_p2.modules == set([new,new2,p.b,p.c]))
2209  self.assertEqual(p.p2.dumpPython()[:-1], "cms.Path(process.c+process.s4+process.a)")
2210  visitor3 = NodeVisitor()
2211  p.e3.visit(visitor3)
2212  self.assertTrue(visitor3.modules == set([new,new2,p.b,p.c]))
2213  visitor4 = NodeVisitor()
2214  p.s4.visit(visitor4)
2215  self.assertTrue(visitor4.modules == set([new,new2,p.b]))
2216  self.assertEqual(p.s4.dumpPython()[:-1],"cms.Sequence(process.a+process.b, cms.Task(process.d))")
2217  visitor5 = NodeVisitor()
2218  p.t1.visit(visitor5)
2219  self.assertTrue(visitor5.modules == set([new2]))
2220  visitor6 = NodeVisitor()
2221  listOfTasks = list(p.schedule._tasks)
2222  listOfTasks[0].visit(visitor6)
2223  self.assertTrue(visitor6.modules == set([new2]))
2224 

References list().

◆ testImplicitSchedule()

def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 2680 of file Config.py.

2680  def testImplicitSchedule(self):
2681  p = Process("test")
2682  p.a = EDAnalyzer("MyAnalyzer")
2683  p.b = EDAnalyzer("YourAnalyzer")
2684  p.c = EDAnalyzer("OurAnalyzer")
2685  p.path1 = Path(p.a)
2686  p.path2 = Path(p.b)
2687  self.assertTrue(p.schedule is None)
2688  pths = p.paths
2689  keys = pths.keys()
2690  self.assertEqual(pths[keys[0]],p.path1)
2691  self.assertEqual(pths[keys[1]],p.path2)
2692  p.prune()
2693  self.assertTrue(hasattr(p, 'a'))
2694  self.assertTrue(hasattr(p, 'b'))
2695  self.assertTrue(not hasattr(p, 'c'))
2696  self.assertTrue(hasattr(p, 'path1'))
2697  self.assertTrue(hasattr(p, 'path2'))
2698 
2699 
2700  p = Process("test")
2701  p.a = EDAnalyzer("MyAnalyzer")
2702  p.b = EDAnalyzer("YourAnalyzer")
2703  p.c = EDAnalyzer("OurAnalyzer")
2704  p.path2 = Path(p.b)
2705  p.path1 = Path(p.a)
2706  self.assertTrue(p.schedule is None)
2707  pths = p.paths
2708  keys = pths.keys()
2709  self.assertEqual(pths[keys[1]],p.path1)
2710  self.assertEqual(pths[keys[0]],p.path2)
2711 
2712 

◆ testMaxEvents()

def Config.TestModuleCommand.testMaxEvents (   self)

Definition at line 2755 of file Config.py.

2755  def testMaxEvents(self):
2756  p = Process("Test")
2757  p.maxEvents.input = 10
2758  self.assertEqual(p.maxEvents.input.value(),10)
2759  p = Process("Test")
2760  p.maxEvents.output = 10
2761  self.assertEqual(p.maxEvents.output.value(),10)
2762  p = Process("Test")
2763  p.maxEvents.output = PSet(out=untracked.int32(10))
2764  self.assertEqual(p.maxEvents.output.out.value(), 10)
2765  p = Process("Test")
2766  p.maxEvents = untracked.PSet(input = untracked.int32(5))
2767  self.assertEqual(p.maxEvents.input.value(), 5)
2768 
2769 

◆ testModifier()

def Config.TestModuleCommand.testModifier (   self)

Definition at line 3176 of file Config.py.

3176  def testModifier(self):
3177  m1 = Modifier()
3178  p = Process("test",m1)
3179  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
3180  def _mod_fred(obj):
3181  obj.fred = 2
3182  m1.toModify(p.a,_mod_fred)
3183  self.assertEqual(p.a.fred.value(),2)
3184  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
3185  m1.toModify(p.b, wilma = 2)
3186  self.assertEqual(p.b.wilma.value(),2)
3187  self.assertTrue(p.isUsingModifier(m1))
3188  #check that Modifier not attached to a process doesn't run
3189  m1 = Modifier()
3190  p = Process("test")
3191  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
3192  m1.toModify(p.a,_mod_fred)
3193  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
3194  m1.toModify(p.b, wilma = 2)
3195  self.assertEqual(p.a.fred.value(),1)
3196  self.assertEqual(p.b.wilma.value(),1)
3197  self.assertEqual(p.isUsingModifier(m1),False)
3198  #make sure clones get the changes
3199  m1 = Modifier()
3200  p = Process("test",m1)
3201  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3202  m1.toModify(p.a, fred = int32(2))
3203  p.b = p.a.clone(wilma = int32(3))
3204  self.assertEqual(p.a.fred.value(),2)
3205  self.assertEqual(p.a.wilma.value(),1)
3206  self.assertEqual(p.b.fred.value(),2)
3207  self.assertEqual(p.b.wilma.value(),3)
3208  #test removal of parameter
3209  m1 = Modifier()
3210  p = Process("test",m1)
3211  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1), fintstones = PSet(fred = int32(1)))
3212  m1.toModify(p.a, fred = None, fintstones = dict(fred = None))
3213  self.assertEqual(hasattr(p.a, "fred"), False)
3214  self.assertEqual(hasattr(p.a.fintstones, "fred"), False)
3215  self.assertEqual(p.a.wilma.value(),1)
3216  #test adding a parameter
3217  m1 = Modifier()
3218  p = Process("test",m1)
3219  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
3220  m1.toModify(p.a, wilma = int32(2))
3221  self.assertEqual(p.a.fred.value(), 1)
3222  self.assertEqual(p.a.wilma.value(),2)
3223  #test setting of value in PSet
3224  m1 = Modifier()
3225  p = Process("test",m1)
3226  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = int32(1), wilma = int32(1)))
3227  m1.toModify(p.a, flintstones = dict(fred = int32(2)))
3228  self.assertEqual(p.a.flintstones.fred.value(),2)
3229  self.assertEqual(p.a.flintstones.wilma.value(),1)
3230  #test proper exception from nonexisting parameter name
3231  m1 = Modifier()
3232  p = Process("test",m1)
3233  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = PSet(wilma = int32(1))))
3234  self.assertRaises(KeyError, lambda: m1.toModify(p.a, flintstones = dict(imnothere = dict(wilma=2))))
3235  self.assertRaises(KeyError, lambda: m1.toModify(p.a, foo = 1))
3236  #test setting a value in a VPSet
3237  m1 = Modifier()
3238  p = Process("test",m1)
3239  p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
3240  m1.toModify(p.a, flintstones = {1:dict(wilma = int32(2))})
3241  self.assertEqual(p.a.flintstones[0].fred.value(),1)
3242  self.assertEqual(p.a.flintstones[1].wilma.value(),2)
3243  #test setting a value in a list of values
3244  m1 = Modifier()
3245  p = Process("test",m1)
3246  p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
3247  m1.toModify(p.a, fred = {1:7})
3248  self.assertEqual(p.a.fred[0],1)
3249  self.assertEqual(p.a.fred[1],7)
3250  self.assertEqual(p.a.fred[2],3)
3251  #test IndexError setting a value in a list to an item key not in the list
3252  m1 = Modifier()
3253  p = Process("test",m1)
3254  p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
3255  raised = False
3256  try: m1.toModify(p.a, fred = {5:7})
3257  except IndexError as e: raised = True
3258  self.assertEqual(raised, True)
3259  #test TypeError setting a value in a list using a key that is not an int
3260  m1 = Modifier()
3261  p = Process("test",m1)
3262  p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
3263  raised = False
3264  try: m1.toModify(p.a, flintstones = dict(bogus = int32(37)))
3265  except TypeError as e: raised = True
3266  self.assertEqual(raised, True)
3267  #test that load causes process wide methods to run
3268  def _rem_a(proc):
3269  del proc.a
3270  class ProcModifierMod(object):
3271  def __init__(self,modifier,func):
3272  self.proc_mod_ = modifier.makeProcessModifier(func)
3273  class DummyMod(object):
3274  def __init__(self):
3275  self.a = EDAnalyzer("Dummy")
3276  testMod = DummyMod()
3277  p.extend(testMod)
3278  self.assertTrue(hasattr(p,"a"))
3279  m1 = Modifier()
3280  p = Process("test",m1)
3281  testProcMod = ProcModifierMod(m1,_rem_a)
3282  p.extend(testMod)
3283  p.extend(testProcMod)
3284  self.assertTrue(not hasattr(p,"a"))
3285  #test ModifierChain
3286  m1 = Modifier()
3287  mc = ModifierChain(m1)
3288  p = Process("test",mc)
3289  self.assertTrue(p.isUsingModifier(m1))
3290  self.assertTrue(p.isUsingModifier(mc))
3291  testMod = DummyMod()
3292  p.b = EDAnalyzer("Dummy2", fred = int32(1))
3293  m1.toModify(p.b, fred = int32(3))
3294  p.extend(testMod)
3295  testProcMod = ProcModifierMod(m1,_rem_a)
3296  p.extend(testProcMod)
3297  self.assertTrue(not hasattr(p,"a"))
3298  self.assertEqual(p.b.fred.value(),3)
3299  #check cloneAndExclude
3300  m1 = Modifier()
3301  m2 = Modifier()
3302  mc = ModifierChain(m1,m2)
3303  mclone = mc.copyAndExclude([m2])
3304  self.assertTrue(not mclone._isOrContains(m2))
3305  self.assertTrue(mclone._isOrContains(m1))
3306  m3 = Modifier()
3307  mc2 = ModifierChain(mc,m3)
3308  mclone = mc2.copyAndExclude([m2])
3309  self.assertTrue(not mclone._isOrContains(m2))
3310  self.assertTrue(mclone._isOrContains(m1))
3311  self.assertTrue(mclone._isOrContains(m3))
3312  #check combining
3313  m1 = Modifier()
3314  m2 = Modifier()
3315  p = Process("test",m1)
3316  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3317  (m1 & m2).toModify(p.a, fred = int32(2))
3318  self.assertRaises(TypeError, lambda: (m1 & m2).toModify(p.a, 1, wilma=2))
3319  self.assertEqual(p.a.fred, 1)
3320  m1 = Modifier()
3321  m2 = Modifier()
3322  p = Process("test",m1,m2)
3323  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3324  (m1 & m2).toModify(p.a, fred = int32(2))
3325  self.assertEqual(p.a.fred, 2)
3326  m1 = Modifier()
3327  m2 = Modifier()
3328  m3 = Modifier()
3329  p = Process("test",m1,m2,m3)
3330  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3331  (m1 & m2 & m3).toModify(p.a, fred = int32(2))
3332  self.assertEqual(p.a.fred, 2)
3333  (m1 & (m2 & m3)).toModify(p.a, fred = int32(3))
3334  self.assertEqual(p.a.fred, 3)
3335  ((m1 & m2) & m3).toModify(p.a, fred = int32(4))
3336  self.assertEqual(p.a.fred, 4)
3337  #check inverse
3338  m1 = Modifier()
3339  m2 = Modifier()
3340  p = Process("test", m1)
3341  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3342  (~m1).toModify(p.a, fred=2)
3343  self.assertEqual(p.a.fred, 1)
3344  (~m2).toModify(p.a, wilma=2)
3345  self.assertEqual(p.a.wilma, 2)
3346  self.assertRaises(TypeError, lambda: (~m1).toModify(p.a, 1, wilma=2))
3347  self.assertRaises(TypeError, lambda: (~m2).toModify(p.a, 1, wilma=2))
3348  # check or
3349  m1 = Modifier()
3350  m2 = Modifier()
3351  m3 = Modifier()
3352  p = Process("test", m1)
3353  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3354  (m1 | m2).toModify(p.a, fred=2)
3355  self.assertEqual(p.a.fred, 2)
3356  (m1 | m2 | m3).toModify(p.a, fred=3)
3357  self.assertEqual(p.a.fred, 3)
3358  (m3 | m2 | m1).toModify(p.a, fred=4)
3359  self.assertEqual(p.a.fred, 4)
3360  ((m1 | m2) | m3).toModify(p.a, fred=5)
3361  self.assertEqual(p.a.fred, 5)
3362  (m1 | (m2 | m3)).toModify(p.a, fred=6)
3363  self.assertEqual(p.a.fred, 6)
3364  (m2 | m3).toModify(p.a, fred=7)
3365  self.assertEqual(p.a.fred, 6)
3366  self.assertRaises(TypeError, lambda: (m1 | m2).toModify(p.a, 1, wilma=2))
3367  self.assertRaises(TypeError, lambda: (m2 | m3).toModify(p.a, 1, wilma=2))
3368  # check combinations
3369  m1 = Modifier()
3370  m2 = Modifier()
3371  m3 = Modifier()
3372  m4 = Modifier()
3373  p = Process("test", m1, m2)
3374  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3375  (m1 & ~m2).toModify(p.a, fred=2)
3376  self.assertEqual(p.a.fred, 1)
3377  (m1 & ~m3).toModify(p.a, fred=2)
3378  self.assertEqual(p.a.fred, 2)
3379  (m1 | ~m2).toModify(p.a, fred=3)
3380  self.assertEqual(p.a.fred, 3)
3381  (~m1 | ~m2).toModify(p.a, fred=4)
3382  self.assertEqual(p.a.fred, 3)
3383  (~m3 & ~m4).toModify(p.a, fred=4)
3384  self.assertEqual(p.a.fred, 4)
3385  ((m1 & m3) | ~m4).toModify(p.a, fred=5)
3386  self.assertEqual(p.a.fred, 5)
3387  #check toReplaceWith
3388  m1 = Modifier()
3389  p = Process("test",m1)
3390  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
3391  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
3392  self.assertRaises(TypeError, lambda: m1.toReplaceWith(p.a, EDProducer("YourProducer")))
3393  p.b =EDAnalyzer("BAn")
3394  p.c =EDProducer("c")
3395  p.d =EDProducer("d")
3396  p.tc = Task(p.c)
3397  p.td = Task(p.d)
3398  p.s = Sequence(p.a, p.tc)
3399  m1.toReplaceWith(p.s, Sequence(p.a+p.b, p.td))
3400  self.assertEqual(p.a.wilma.value(),3)
3401  self.assertEqual(p.a.type_(),"YourAnalyzer")
3402  self.assertEqual(hasattr(p,"fred"),False)
3403  self.assertTrue(p.s.dumpPython() == "cms.Sequence(process.a+process.b, process.td)\n")
3404  p.e =EDProducer("e")
3405  m1.toReplaceWith(p.td, Task(p.e))
3406  self.assertTrue(p.td._collection == OrderedSet([p.e]))
3407  #check toReplaceWith doesn't activate not chosen
3408  m1 = Modifier()
3409  p = Process("test")
3410  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
3411  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
3412  self.assertEqual(p.a.type_(),"MyAnalyzer")
3413  #check toReplaceWith and and/not/or combinations
3414  m1 = Modifier()
3415  m2 = Modifier()
3416  m3 = Modifier()
3417  m4 = Modifier()
3418  p = Process("test", m1, m2)
3419  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3420  self.assertRaises(TypeError, lambda: (m1 & m2).toReplaceWith(p.a, EDProducer("YourProducer")))
3421  self.assertRaises(TypeError, lambda: (m3 & m4).toReplaceWith(p.a, EDProducer("YourProducer")))
3422  self.assertRaises(TypeError, lambda: (~m3).toReplaceWith(p.a, EDProducer("YourProducer")))
3423  self.assertRaises(TypeError, lambda: (~m1).toReplaceWith(p.a, EDProducer("YourProducer")))
3424  self.assertRaises(TypeError, lambda: (m1 | m3).toReplaceWith(p.a, EDProducer("YourProducer")))
3425  self.assertRaises(TypeError, lambda: (m3 | m4).toReplaceWith(p.a, EDProducer("YourProducer")))
3426  (m1 & m2).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer1"))
3427  self.assertEqual(p.a.type_(), "YourAnalyzer1")
3428  (m1 & m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
3429  self.assertEqual(p.a.type_(), "YourAnalyzer1")
3430  (~m1).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
3431  self.assertEqual(p.a.type_(), "YourAnalyzer1")
3432  (~m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
3433  self.assertEqual(p.a.type_(), "YourAnalyzer2")
3434  (m1 | m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer3"))
3435  self.assertEqual(p.a.type_(), "YourAnalyzer3")
3436  (m3 | m4).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer4"))
3437  self.assertEqual(p.a.type_(), "YourAnalyzer3")
3438 
3439  # EDAlias
3440  a = EDAlias(foo2 = VPSet(PSet(type = string("Foo2"))))
3441  m = Modifier()
3442  m._setChosen()
3443  # Modify parameters
3444  m.toModify(a, foo2 = {0: dict(type = "Foo3")})
3445  self.assertEqual(a.foo2[0].type, "Foo3")
3446  # Add an alias
3447  m.toModify(a, foo4 = VPSet(PSet(type = string("Foo4"))))
3448  self.assertEqual(a.foo2[0].type, "Foo3")
3449  self.assertEqual(a.foo4[0].type, "Foo4")
3450  # Remove an alias
3451  m.toModify(a, foo2 = None)
3452  self.assertFalse(hasattr(a, "foo2"))
3453  self.assertEqual(a.foo4[0].type, "Foo4")
3454  # Replace (doesn't work out of the box because EDAlias is not _Parameterizable
3455  m.toReplaceWith(a, EDAlias(bar = VPSet(PSet(type = string("Bar")))))
3456  self.assertFalse(hasattr(a, "foo2"))
3457  self.assertFalse(hasattr(a, "foo4"))
3458  self.assertTrue(hasattr(a, "bar"))
3459  self.assertEqual(a.bar[0].type, "Bar")
3460 
3461  # SwitchProducer
3462  sp = SwitchProducerTest(test1 = EDProducer("Foo",
3463  a = int32(1),
3464  b = PSet(c = int32(2))),
3465  test2 = EDProducer("Bar",
3466  aa = int32(11),
3467  bb = PSet(cc = int32(12))))
3468  m = Modifier()
3469  m._setChosen()
3470  # Modify parameters
3471  m.toModify(sp,
3472  test1 = dict(a = 4, b = dict(c = None)),
3473  test2 = dict(aa = 15, bb = dict(cc = 45, dd = string("foo"))))
3474  self.assertEqual(sp.test1.a.value(), 4)
3475  self.assertEqual(sp.test1.b.hasParameter("c"), False)
3476  self.assertEqual(sp.test2.aa.value(), 15)
3477  self.assertEqual(sp.test2.bb.cc.value(), 45)
3478  self.assertEqual(sp.test2.bb.dd.value(), "foo")
3479  # Replace a producer
3480  m.toReplaceWith(sp.test1, EDProducer("Fred", x = int32(42)))
3481  self.assertEqual(sp.test1.type_(), "Fred")
3482  self.assertEqual(sp.test1.x.value(), 42)
3483  self.assertRaises(TypeError, lambda: m.toReplaceWith(sp.test1, EDAnalyzer("Foo")))
3484  # Alternative way (only to be allow same syntax to be used as for adding)
3485  m.toModify(sp, test2 = EDProducer("Xyzzy", x = int32(24)))
3486  self.assertEqual(sp.test2.type_(), "Xyzzy")
3487  self.assertEqual(sp.test2.x.value(), 24)
3488  self.assertRaises(TypeError, lambda: m.toModify(sp, test2 = EDAnalyzer("Foo")))
3489  # Add a producer
3490  m.toModify(sp, test3 = EDProducer("Wilma", y = int32(24)))
3491  self.assertEqual(sp.test3.type_(), "Wilma")
3492  self.assertEqual(sp.test3.y.value(), 24)
3493  self.assertRaises(TypeError, lambda: m.toModify(sp, test4 = EDAnalyzer("Foo")))
3494  # Remove a producer
3495  m.toModify(sp, test2 = None)
3496  self.assertEqual(hasattr(sp, "test2"), False)
3497  # Add an alias
3498  m.toModify(sp, test2 = EDAlias(foo = VPSet(PSet(type = string("int")))))
3499  self.assertTrue(hasattr(sp.test2, "foo"))
3500  # Replace an alias
3501  m.toReplaceWith(sp.test2, EDAlias(bar = VPSet(PSet(type = string("int")))))
3502  self.assertTrue(hasattr(sp.test2, "bar"))
3503  # Alternative way
3504  m.toModify(sp, test2 = EDAlias(xyzzy = VPSet(PSet(type = string("int")))))
3505  self.assertTrue(hasattr(sp.test2, "xyzzy"))
3506  # Replace an alias with EDProducer
3507  self.assertRaises(TypeError, lambda: m.toReplaceWith(sp.test2, EDProducer("Foo")))
3508  m.toModify(sp, test2 = EDProducer("Foo"))

References resolutioncreator_cfi.object.

◆ testOptions()

def Config.TestModuleCommand.testOptions (   self)

Definition at line 2743 of file Config.py.

2743  def testOptions(self):
2744  p = Process('test')
2745  self.assertEqual(p.options.numberOfThreads.value(),1)
2746  p.options.numberOfThreads = 8
2747  self.assertEqual(p.options.numberOfThreads.value(),8)
2748  p.options = PSet()
2749  self.assertEqual(p.options.numberOfThreads.value(),1)
2750  p.options = dict(numberOfStreams =2,
2751  numberOfThreads =2)
2752  self.assertEqual(p.options.numberOfThreads.value(),2)
2753  self.assertEqual(p.options.numberOfStreams.value(),2)
2754 

◆ testOverride()

def Config.TestModuleCommand.testOverride (   self)

Definition at line 2720 of file Config.py.

2720  def testOverride(self):
2721  p = Process('test')
2722  a = EDProducer("A", a1=int32(0))
2723  self.assertTrue(not a.isModified())
2724  a.a1 = 1
2725  self.assertTrue(a.isModified())
2726  p.a = a
2727  self.assertEqual(p.a.a1.value(), 1)
2728  # try adding an unmodified module.
2729  # should accept it
2730  p.a = EDProducer("A", a1=int32(2))
2731  self.assertEqual(p.a.a1.value(), 2)
2732  # try adding a modified module. Should throw
2733  # no longer, since the same (modified) say, geometry
2734  # could come from more than one cff
2735  b = EDProducer("A", a1=int32(3))
2736  b.a1 = 4
2737  #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
2738  ps1 = PSet(a = int32(1))
2739  ps2 = PSet(a = int32(2))
2740  self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
2741  self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
2742 

◆ testParameterizable()

def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 1839 of file Config.py.

1839  def testParameterizable(self):
1840  p = _Parameterizable()
1841  self.assertEqual(len(p.parameterNames_()),0)
1842  p.a = int32(1)
1843  self.assertTrue('a' in p.parameterNames_())
1844  self.assertEqual(p.a.value(), 1)
1845  p.a = 10
1846  self.assertEqual(p.a.value(), 10)
1847  p.a = untracked(int32(1))
1848  self.assertEqual(p.a.value(), 1)
1849  self.assertFalse(p.a.isTracked())
1850  p.a = untracked.int32(1)
1851  self.assertEqual(p.a.value(), 1)
1852  self.assertFalse(p.a.isTracked())
1853  p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
1854  self.assertEqual(p.foo.value(), 10)
1855  self.assertEqual(p.bar.value(),1.0)
1856  self.assertFalse(p.bar.isTracked())
1857  self.assertRaises(TypeError,setattr,(p,'c',1))
1858  p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
1859  self.assertEqual(p.a.foo.value(),10)
1860  self.assertEqual(p.a.bar.value(),1.0)
1861  p.b = untracked(PSet(fii = int32(1)))
1862  self.assertEqual(p.b.fii.value(),1)
1863  self.assertFalse(p.b.isTracked())
1864  #test the fact that values can be shared
1865  v = int32(10)
1866  p=_Parameterizable(a=v)
1867  v.setValue(11)
1868  self.assertEqual(p.a.value(),11)
1869  p.a = 12
1870  self.assertEqual(p.a.value(),12)
1871  self.assertEqual(v.value(),12)

◆ testPath()

def Config.TestModuleCommand.testPath (   self)

Definition at line 2461 of file Config.py.

2461  def testPath(self):
2462  p = Process("test")
2463  p.a = EDAnalyzer("MyAnalyzer")
2464  p.b = EDAnalyzer("YourAnalyzer")
2465  p.c = EDAnalyzer("OurAnalyzer")
2466  path = Path(p.a)
2467  path *= p.b
2468  path += p.c
2469  self.assertEqual(str(path),'a+b+c')
2470  path = Path(p.a*p.b+p.c)
2471  self.assertEqual(str(path),'a+b+c')
2472 # path = Path(p.a)*p.b+p.c #This leads to problems with sequences
2473 # self.assertEqual(str(path),'((a*b)+c)')
2474  path = Path(p.a+ p.b*p.c)
2475  self.assertEqual(str(path),'a+b+c')
2476  path = Path(p.a*(p.b+p.c))
2477  self.assertEqual(str(path),'a+b+c')
2478  path = Path(p.a*(p.b+~p.c))
2479  pathx = Path(p.a*(p.b+ignore(p.c)))
2480  self.assertEqual(str(path),'a+b+~c')
2481  p.es = ESProducer("AnESProducer")
2482  self.assertRaises(TypeError,Path,p.es)
2483 
2484  t = Path()
2485  self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path()\n')
2486 
2487  t = Path(p.a)
2488  self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(process.a)\n')
2489 
2490  t = Path(Task())
2491  self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(cms.Task())\n')
2492 
2493  t = Path(p.a, Task())
2494  self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(process.a, cms.Task())\n')
2495 
2496  p.prod = EDProducer("prodName")
2497  p.t1 = Task(p.prod)
2498  t = Path(p.a, p.t1, Task(), p.t1)
2499  self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(process.a, cms.Task(), process.t1)\n')
2500 

References SequenceTypes.ignore(), and str.

◆ testPrefers()

def Config.TestModuleCommand.testPrefers (   self)

Definition at line 2782 of file Config.py.

2782  def testPrefers(self):
2783  p = Process("Test")
2784  p.add_(ESSource("ForceSource"))
2785  p.juicer = ESProducer("JuicerProducer")
2786  p.prefer("ForceSource")
2787  p.prefer("juicer")
2788  self.assertEqual(_lineDiff(p.dumpPython(), Process('Test').dumpPython()),
2789 """process.juicer = cms.ESProducer("JuicerProducer")
2790 process.ForceSource = cms.ESSource("ForceSource")
2791 process.prefer("ForceSource")
2792 process.prefer("juicer")""")
2793  p.prefer("juicer",fooRcd=vstring("Foo"))
2794  self.assertEqual(_lineDiff(p.dumpPython(), Process('Test').dumpPython()),
2795 """process.juicer = cms.ESProducer("JuicerProducer")
2796 process.ForceSource = cms.ESSource("ForceSource")
2797 process.prefer("ForceSource")
2798 process.prefer("juicer",
2799  fooRcd = cms.vstring('Foo')
2800 )""")
2801 

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

◆ testProcessDumpPython()

def Config.TestModuleCommand.testProcessDumpPython (   self)

Definition at line 1991 of file Config.py.

1991  def testProcessDumpPython(self):
1992  self.assertEqual(Process("test").dumpPython(),
1993 """import FWCore.ParameterSet.Config as cms\n\nprocess = cms.Process("test")
1994 
1995 process.maxEvents = cms.untracked.PSet(
1996  input = cms.optional.untracked.int32,
1997  output = cms.optional.untracked.allowed(cms.int32,cms.PSet)
1998 )
1999 
2000 process.maxLuminosityBlocks = cms.untracked.PSet(
2001  input = cms.untracked.int32(-1)
2002 )
2003 
2004 process.options = cms.untracked.PSet(
2005  FailPath = cms.untracked.vstring(),
2006  IgnoreCompletely = cms.untracked.vstring(),
2007  Rethrow = cms.untracked.vstring(),
2008  SkipEvent = cms.untracked.vstring(),
2009  allowUnscheduled = cms.obsolete.untracked.bool,
2010  canDeleteEarly = cms.untracked.vstring(),
2011  emptyRunLumiMode = cms.obsolete.untracked.string,
2012  eventSetup = cms.untracked.PSet(
2013  forceNumberOfConcurrentIOVs = cms.untracked.PSet(
2014 
2015  ),
2016  numberOfConcurrentIOVs = cms.untracked.uint32(1)
2017  ),
2018  fileMode = cms.untracked.string('FULLMERGE'),
2019  forceEventSetupCacheClearOnNewRun = cms.untracked.bool(False),
2020  makeTriggerResults = cms.obsolete.untracked.bool,
2021  numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(1),
2022  numberOfConcurrentRuns = cms.untracked.uint32(1),
2023  numberOfStreams = cms.untracked.uint32(0),
2024  numberOfThreads = cms.untracked.uint32(1),
2025  printDependencies = cms.untracked.bool(False),
2026  sizeOfStackForThreadsInKB = cms.optional.untracked.uint32,
2027  throwIfIllegalParameter = cms.untracked.bool(True),
2028  wantSummary = cms.untracked.bool(False)
2029 )
2030 
2031 """)
2032  p = Process("test")
2033  p.a = EDAnalyzer("MyAnalyzer")
2034  p.p = Path(p.a)
2035  p.s = Sequence(p.a)
2036  p.r = Sequence(p.s)
2037  p.p2 = Path(p.s)
2038  p.schedule = Schedule(p.p2,p.p)
2039  d=p.dumpPython()
2040  self.assertEqual(_lineDiff(d,Process("test").dumpPython()),
2041 """process.a = cms.EDAnalyzer("MyAnalyzer")
2042 process.s = cms.Sequence(process.a)
2043 process.r = cms.Sequence(process.s)
2044 process.p = cms.Path(process.a)
2045 process.p2 = cms.Path(process.s)
2046 process.schedule = cms.Schedule(*[ process.p2, process.p ])""")
2047  #Reverse order of 'r' and 's'
2048  p = Process("test")
2049  p.a = EDAnalyzer("MyAnalyzer")
2050  p.p = Path(p.a)
2051  p.r = Sequence(p.a)
2052  p.s = Sequence(p.r)
2053  p.p2 = Path(p.r)
2054  p.schedule = Schedule(p.p2,p.p)
2055  p.b = EDAnalyzer("YourAnalyzer")
2056  d=p.dumpPython()
2057  self.assertEqual(_lineDiff(d,Process("test").dumpPython()),
2058 """process.a = cms.EDAnalyzer("MyAnalyzer")
2059 process.b = cms.EDAnalyzer("YourAnalyzer")
2060 process.r = cms.Sequence(process.a)
2061 process.s = cms.Sequence(process.r)
2062 process.p = cms.Path(process.a)
2063 process.p2 = cms.Path(process.r)
2064 process.schedule = cms.Schedule(*[ process.p2, process.p ])""")

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

◆ testProcessExtend()

def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 1904 of file Config.py.

1904  def testProcessExtend(self):
1905  class FromArg(object):
1906  def __init__(self,*arg,**args):
1907  for name in six.iterkeys(args):
1908  self.__dict__[name]=args[name]
1909 
1910  a=EDAnalyzer("MyAnalyzer")
1911  t=EDAnalyzer("MyAnalyzer")
1912  t.setLabel("foo")
1913  s1 = Sequence(a)
1914  s2 = Sequence(s1)
1915  s3 = Sequence(s2)
1916  d = FromArg(
1917  a=a,
1918  b=Service("Full"),
1919  c=Path(a),
1920  d=s2,
1921  e=s1,
1922  f=s3,
1923  g=Sequence(s1+s2+s3)
1924  )
1925  p = Process("Test")
1926  p.extend(d)
1927  self.assertEqual(p.a.type_(),"MyAnalyzer")
1928  self.assertEqual(p.a.label_(),"a")
1929  self.assertRaises(AttributeError,getattr,p,'b')
1930  self.assertEqual(p.Full.type_(),"Full")
1931  self.assertEqual(str(p.c),'a')
1932  self.assertEqual(str(p.d),'a')
1933 
1934  z1 = FromArg(
1935  a=a,
1936  b=Service("Full"),
1937  c=Path(a),
1938  d=s2,
1939  e=s1,
1940  f=s3,
1941  s4=s3,
1942  g=Sequence(s1+s2+s3)
1943  )
1944 
1945  p1 = Process("Test")
1946  #p1.extend(z1)
1947  self.assertRaises(ValueError, p1.extend, z1)
1948 
1949  z2 = FromArg(
1950  a=a,
1951  b=Service("Full"),
1952  c=Path(a),
1953  d=s2,
1954  e=s1,
1955  f=s3,
1956  aaa=copy.deepcopy(a),
1957  s4=copy.deepcopy(s3),
1958  g=Sequence(s1+s2+s3),
1959  t=t
1960  )
1961  p2 = Process("Test")
1962  p2.extend(z2)
1963  #self.assertRaises(ValueError, p2.extend, z2)
1964  self.assertEqual(p2.s4.label_(),"s4")
1965  #p2.s4.setLabel("foo")
1966  self.assertRaises(ValueError, p2.s4.setLabel, "foo")
1967  p2.s4.setLabel("s4")
1968  p2.s4.setLabel(None)
1969  p2.s4.setLabel("foo")
1970  p2._Process__setObjectLabel(p2.s4, "foo")
1971  p2._Process__setObjectLabel(p2.s4, None)
1972  p2._Process__setObjectLabel(p2.s4, "bar")
1973 
1974 
1975  p = Process('test')
1976  p.a = EDProducer("MyProducer")
1977  p.t = Task(p.a)
1978  p.p = Path(p.t)
1979  self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
1980  self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
1981  self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())
1982 
1983  p = Process('test')
1984  p.a = EDProducer("MyProducer")
1985  p.s = Sequence(p.a)
1986  p.p = Path(p.s)
1987  self.assertRaises(ValueError, p.extend, FromArg(a = EDProducer("YourProducer")))
1988  self.assertRaises(ValueError, p.extend, FromArg(a = EDAlias()))
1989  self.assertRaises(ValueError, p.__setattr__, "a", EDAlias())
1990 

References resolutioncreator_cfi.object, and str.

◆ testProcessFragment()

def Config.TestModuleCommand.testProcessFragment (   self)

Definition at line 3509 of file Config.py.

3509  def testProcessFragment(self):
3510  #check defaults are not overwritten
3511  f = ProcessFragment('Fragment')
3512  p = Process('PROCESS')
3513  p.maxEvents.input = 10
3514  p.options.numberOfThreads = 4
3515  p.maxLuminosityBlocks.input = 2
3516  p.extend(f)
3517  self.assertEqual(p.maxEvents.input.value(),10)
3518  self.assertEqual(p.options.numberOfThreads.value(), 4)
3519  self.assertEqual(p.maxLuminosityBlocks.input.value(),2)
3520  #general checks
3521  f = ProcessFragment("Fragment")
3522  f.fltr = EDFilter("Foo")
3523  p = Process('PROCESS')
3524  p.extend(f)
3525  self.assertTrue(hasattr(p,'fltr'))
3526 
3527  unittest.main()

◆ testProcessInsertion()

def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 1879 of file Config.py.

1879  def testProcessInsertion(self):
1880  p = Process("test")
1881  p.a = EDAnalyzer("MyAnalyzer")
1882  self.assertTrue( 'a' in p.analyzers_() )
1883  self.assertTrue( 'a' in p.analyzers)
1884  p.add_(Service("MessageLogger"))
1885  self.assertTrue('MessageLogger' in p.services_())
1886  self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
1887  p.Tracer = Service("Tracer")
1888  self.assertTrue('Tracer' in p.services_())
1889  self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
1890  self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
1891  self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
1892  p.out = OutputModule("Outer")
1893  self.assertEqual(p.out.type_(), 'Outer')
1894  self.assertTrue( 'out' in p.outputModules_() )
1895 
1896  p.geom = ESSource("GeomProd")
1897  self.assertTrue('geom' in p.es_sources_())
1898  p.add_(ESSource("ConfigDB"))
1899  self.assertTrue('ConfigDB' in p.es_sources_())
1900 
1901  p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
1902  self.assertTrue('aliasfoo1' in p.aliases_())
1903 

◆ testPrune()

def Config.TestModuleCommand.testPrune (   self)

Definition at line 2943 of file Config.py.

2943  def testPrune(self):
2944  p = Process("test")
2945  p.a = EDAnalyzer("MyAnalyzer")
2946  p.b = EDAnalyzer("YourAnalyzer")
2947  p.c = EDAnalyzer("OurAnalyzer")
2948  p.d = EDAnalyzer("OurAnalyzer")
2949  p.e = EDProducer("MyProducer")
2950  p.f = EDProducer("YourProducer")
2951  p.g = EDProducer("TheirProducer")
2952  p.s = Sequence(p.d)
2953  p.t1 = Task(p.e)
2954  p.t2 = Task(p.f)
2955  p.t3 = Task(p.g, p.t1)
2956  p.path1 = Path(p.a, p.t3)
2957  p.path2 = Path(p.b)
2958  self.assertTrue(p.schedule is None)
2959  pths = p.paths
2960  keys = pths.keys()
2961  self.assertEqual(pths[keys[0]],p.path1)
2962  self.assertEqual(pths[keys[1]],p.path2)
2963  p.pset1 = PSet(parA = string("pset1"))
2964  p.pset2 = untracked.PSet(parA = string("pset2"))
2965  p.vpset1 = VPSet()
2966  p.vpset2 = untracked.VPSet()
2967  p.prune()
2968  self.assertTrue(hasattr(p, 'a'))
2969  self.assertTrue(hasattr(p, 'b'))
2970  self.assertTrue(not hasattr(p, 'c'))
2971  self.assertTrue(not hasattr(p, 'd'))
2972  self.assertTrue(hasattr(p, 'e'))
2973  self.assertTrue(not hasattr(p, 'f'))
2974  self.assertTrue(hasattr(p, 'g'))
2975  self.assertTrue(not hasattr(p, 's'))
2976  self.assertTrue(hasattr(p, 't1'))
2977  self.assertTrue(not hasattr(p, 't2'))
2978  self.assertTrue(hasattr(p, 't3'))
2979  self.assertTrue(hasattr(p, 'path1'))
2980  self.assertTrue(hasattr(p, 'path2'))
2981 # self.assertTrue(not hasattr(p, 'pset1'))
2982 # self.assertTrue(hasattr(p, 'pset2'))
2983 # self.assertTrue(not hasattr(p, 'vpset1'))
2984 # self.assertTrue(not hasattr(p, 'vpset2'))
2985 
2986  p = Process("test")
2987  p.a = EDAnalyzer("MyAnalyzer")
2988  p.b = EDAnalyzer("YourAnalyzer")
2989  p.c = EDAnalyzer("OurAnalyzer")
2990  p.d = EDAnalyzer("OurAnalyzer")
2991  p.e = EDAnalyzer("OurAnalyzer")
2992  p.f = EDProducer("MyProducer")
2993  p.g = EDProducer("YourProducer")
2994  p.h = EDProducer("TheirProducer")
2995  p.i = EDProducer("OurProducer")
2996  p.t1 = Task(p.f)
2997  p.t2 = Task(p.g)
2998  p.t3 = Task(p.h)
2999  p.t4 = Task(p.i)
3000  p.s = Sequence(p.d, p.t1)
3001  p.s2 = Sequence(p.b, p.t2)
3002  p.s3 = Sequence(p.e)
3003  p.path1 = Path(p.a, p.t3)
3004  p.path2 = Path(p.b)
3005  p.path3 = Path(p.b+p.s2)
3006  p.path4 = Path(p.b+p.s3)
3007  p.schedule = Schedule(p.path1,p.path2,p.path3)
3008  p.schedule.associate(p.t4)
3009  pths = p.paths
3010  keys = pths.keys()
3011  self.assertEqual(pths[keys[0]],p.path1)
3012  self.assertEqual(pths[keys[1]],p.path2)
3013  p.prune()
3014  self.assertTrue(hasattr(p, 'a'))
3015  self.assertTrue(hasattr(p, 'b'))
3016  self.assertTrue(not hasattr(p, 'c'))
3017  self.assertTrue(not hasattr(p, 'd'))
3018  self.assertTrue(not hasattr(p, 'e'))
3019  self.assertTrue(not hasattr(p, 'f'))
3020  self.assertTrue(hasattr(p, 'g'))
3021  self.assertTrue(hasattr(p, 'h'))
3022  self.assertTrue(hasattr(p, 'i'))
3023  self.assertTrue(not hasattr(p, 't1'))
3024  self.assertTrue(hasattr(p, 't2'))
3025  self.assertTrue(hasattr(p, 't3'))
3026  self.assertTrue(hasattr(p, 't4'))
3027  self.assertTrue(not hasattr(p, 's'))
3028  self.assertTrue(hasattr(p, 's2'))
3029  self.assertTrue(not hasattr(p, 's3'))
3030  self.assertTrue(hasattr(p, 'path1'))
3031  self.assertTrue(hasattr(p, 'path2'))
3032  self.assertTrue(hasattr(p, 'path3'))
3033  self.assertTrue(not hasattr(p, 'path4'))
3034  #test SequencePlaceholder
3035  p = Process("test")
3036  p.a = EDAnalyzer("MyAnalyzer")
3037  p.b = EDAnalyzer("YourAnalyzer")
3038  p.s = Sequence(SequencePlaceholder("a")+p.b)
3039  p.pth = Path(p.s)
3040  p.prune()
3041  self.assertTrue(hasattr(p, 'a'))
3042  self.assertTrue(hasattr(p, 'b'))
3043  self.assertTrue(hasattr(p, 's'))
3044  self.assertTrue(hasattr(p, 'pth'))
3045  #test unresolved SequencePlaceholder
3046  p = Process("test")
3047  p.b = EDAnalyzer("YourAnalyzer")
3048  p.s = Sequence(SequencePlaceholder("a")+p.b)
3049  p.pth = Path(p.s)
3050  p.prune(keepUnresolvedSequencePlaceholders=True)
3051  self.assertTrue(hasattr(p, 'b'))
3052  self.assertTrue(hasattr(p, 's'))
3053  self.assertTrue(hasattr(p, 'pth'))
3054  self.assertEqual(p.s.dumpPython(),'cms.Sequence(cms.SequencePlaceholder("a")+process.b)\n')
3055  #test TaskPlaceholder
3056  p = Process("test")
3057  p.a = EDProducer("MyProducer")
3058  p.b = EDProducer("YourProducer")
3059  p.s = Task(TaskPlaceholder("a"),p.b)
3060  p.pth = Path(p.s)
3061  p.prune()
3062  self.assertTrue(hasattr(p, 'a'))
3063  self.assertTrue(hasattr(p, 'b'))
3064  self.assertTrue(hasattr(p, 's'))
3065  self.assertTrue(hasattr(p, 'pth'))
3066  #test unresolved SequencePlaceholder
3067  p = Process("test")
3068  p.b = EDProducer("YourAnalyzer")
3069  p.s = Task(TaskPlaceholder("a"),p.b)
3070  p.pth = Path(p.s)
3071  p.prune(keepUnresolvedSequencePlaceholders=True)
3072  self.assertTrue(hasattr(p, 'b'))
3073  self.assertTrue(hasattr(p, 's'))
3074  self.assertTrue(hasattr(p, 'pth'))
3075  self.assertEqual(p.s.dumpPython(),'cms.Task(cms.TaskPlaceholder("a"), process.b)\n')

◆ testRefToPSet()

def Config.TestModuleCommand.testRefToPSet (   self)

Definition at line 2843 of file Config.py.

2843  def testRefToPSet(self):
2844  proc = Process("test")
2845  proc.top = PSet(a = int32(1))
2846  proc.ref = PSet(refToPSet_ = string("top"))
2847  proc.ref2 = PSet( a = int32(1), b = PSet( refToPSet_ = string("top")))
2848  proc.ref3 = PSet(refToPSet_ = string("ref"))
2849  proc.ref4 = VPSet(PSet(refToPSet_ = string("top")),
2850  PSet(refToPSet_ = string("ref2")))
2851  p = TestMakePSet()
2852  proc.fillProcessDesc(p)
2853  self.assertEqual((True,1),p.values["ref"][1].values["a"])
2854  self.assertEqual((True,1),p.values["ref3"][1].values["a"])
2855  self.assertEqual((True,1),p.values["ref2"][1].values["a"])
2856  self.assertEqual((True,1),p.values["ref2"][1].values["b"][1].values["a"])
2857  self.assertEqual((True,1),p.values["ref4"][1][0].values["a"])
2858  self.assertEqual((True,1),p.values["ref4"][1][1].values["a"])

◆ testSchedule()

def Config.TestModuleCommand.testSchedule (   self)

Definition at line 2575 of file Config.py.

2575  def testSchedule(self):
2576  p = Process("test")
2577  p.a = EDAnalyzer("MyAnalyzer")
2578  p.b = EDAnalyzer("YourAnalyzer")
2579  p.c = EDAnalyzer("OurAnalyzer")
2580  p.d = EDAnalyzer("OurAnalyzer")
2581  p.path1 = Path(p.a)
2582  p.path2 = Path(p.b)
2583  p.path3 = Path(p.d)
2584 
2585  s = Schedule(p.path1,p.path2)
2586  self.assertEqual(s[0],p.path1)
2587  self.assertEqual(s[1],p.path2)
2588  p.schedule = s
2589  self.assertTrue('b' in p.schedule.moduleNames())
2590  self.assertTrue(hasattr(p, 'b'))
2591  self.assertTrue(hasattr(p, 'c'))
2592  self.assertTrue(hasattr(p, 'd'))
2593  self.assertTrue(hasattr(p, 'path1'))
2594  self.assertTrue(hasattr(p, 'path2'))
2595  self.assertTrue(hasattr(p, 'path3'))
2596  p.prune()
2597  self.assertTrue('b' in p.schedule.moduleNames())
2598  self.assertTrue(hasattr(p, 'b'))
2599  self.assertTrue(not hasattr(p, 'c'))
2600  self.assertTrue(not hasattr(p, 'd'))
2601  self.assertTrue(hasattr(p, 'path1'))
2602  self.assertTrue(hasattr(p, 'path2'))
2603  self.assertTrue(not hasattr(p, 'path3'))
2604 
2605  self.assertTrue(len(p.schedule._tasks) == 0)
2606 
2607  p = Process("test")
2608  p.a = EDAnalyzer("MyAnalyzer")
2609  p.b = EDAnalyzer("YourAnalyzer")
2610  p.c = EDAnalyzer("OurAnalyzer")
2611  p.d = EDAnalyzer("dAnalyzer")
2612  p.e = EDProducer("eProducer")
2613  p.f = EDProducer("fProducer")
2614  p.Tracer = Service("Tracer")
2615  p.path1 = Path(p.a)
2616  p.path2 = Path(p.b)
2617  p.path3 = Path(p.d)
2618  p.task1 = Task(p.e)
2619  p.task2 = Task(p.f, p.Tracer)
2620  s = Schedule(p.path1,p.path2,tasks=[p.task1,p.task2,p.task1])
2621  self.assertEqual(s[0],p.path1)
2622  self.assertEqual(s[1],p.path2)
2623  self.assertTrue(len(s._tasks) == 2)
2624  self.assertTrue(p.task1 in s._tasks)
2625  self.assertTrue(p.task2 in s._tasks)
2626  listOfTasks = list(s._tasks)
2627  self.assertTrue(len(listOfTasks) == 2)
2628  self.assertTrue(p.task1 == listOfTasks[0])
2629  self.assertTrue(p.task2 == listOfTasks[1])
2630  p.schedule = s
2631  self.assertTrue('b' in p.schedule.moduleNames())
2632 
2633  process2 = Process("test")
2634  process2.a = EDAnalyzer("MyAnalyzer")
2635  process2.e = EDProducer("eProducer")
2636  process2.path1 = Path(process2.a)
2637  process2.task1 = Task(process2.e)
2638  process2.schedule = Schedule(process2.path1,tasks=process2.task1)
2639  listOfTasks = list(process2.schedule._tasks)
2640  self.assertTrue(listOfTasks[0] == process2.task1)
2641 
2642  # test Schedule copy
2643  s2 = s.copy()
2644  self.assertEqual(s2[0],p.path1)
2645  self.assertEqual(s2[1],p.path2)
2646  self.assertTrue(len(s2._tasks) == 2)
2647  self.assertTrue(p.task1 in s2._tasks)
2648  self.assertTrue(p.task2 in s2._tasks)
2649  listOfTasks = list(s2._tasks)
2650  self.assertTrue(len(listOfTasks) == 2)
2651  self.assertTrue(p.task1 == listOfTasks[0])
2652  self.assertTrue(p.task2 == listOfTasks[1])
2653 
2654  names = s.moduleNames()
2655  self.assertTrue(names == set(['a', 'b', 'e', 'Tracer', 'f']))
2656  #adding a path not attached to the Process should cause an exception
2657  p = Process("test")
2658  p.a = EDAnalyzer("MyAnalyzer")
2659  path1 = Path(p.a)
2660  s = Schedule(path1)
2661  self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
2662 
2663  #make sure anonymous sequences work
2664  p = Process("test")
2665  p.a = EDAnalyzer("MyAnalyzer")
2666  p.b = EDAnalyzer("MyOtherAnalyzer")
2667  p.c = EDProducer("MyProd")
2668  path1 = Path(p.c*Sequence(p.a+p.b))
2669  s = Schedule(path1)
2670  self.assertTrue('a' in s.moduleNames())
2671  self.assertTrue('b' in s.moduleNames())
2672  self.assertTrue('c' in s.moduleNames())
2673  p.path1 = path1
2674  p.schedule = s
2675  p.prune()
2676  self.assertTrue('a' in s.moduleNames())
2677  self.assertTrue('b' in s.moduleNames())
2678  self.assertTrue('c' in s.moduleNames())
2679 

References list().

◆ testSecSource()

def Config.TestModuleCommand.testSecSource (   self)

Definition at line 2168 of file Config.py.

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

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

◆ testSequence()

def Config.TestModuleCommand.testSequence (   self)

Definition at line 2225 of file Config.py.

2225  def testSequence(self):
2226  p = Process('test')
2227  p.a = EDAnalyzer("MyAnalyzer")
2228  p.b = EDAnalyzer("YourAnalyzer")
2229  p.c = EDAnalyzer("OurAnalyzer")
2230  p.s = Sequence(p.a*p.b)
2231  self.assertEqual(str(p.s),'a+b')
2232  self.assertEqual(p.s.label_(),'s')
2233  path = Path(p.c+p.s)
2234  self.assertEqual(str(path),'c+a+b')
2235  p._validateSequence(path, 'p1')
2236  notInProcess = EDAnalyzer('NotInProcess')
2237  p2 = Path(p.c+p.s*notInProcess)
2238  self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
2239 

References str.

◆ testSequence2()

def Config.TestModuleCommand.testSequence2 (   self)

Definition at line 2240 of file Config.py.

2240  def testSequence2(self):
2241  p = Process('test')
2242  p.a = EDAnalyzer("MyAnalyzer")
2243  p.b = EDAnalyzer("YourAnalyzer")
2244  p.c = EDAnalyzer("OurAnalyzer")
2245  testseq = Sequence(p.a*p.b)
2246  p.s = testseq
2247  #p.y = testseq
2248  self.assertRaises(ValueError, p.__setattr__, "y", testseq)
2249 

◆ testServiceInProcess()

def Config.TestModuleCommand.testServiceInProcess (   self)

Definition at line 2250 of file Config.py.

2250  def testServiceInProcess(self):
2251  service = Service("d")
2252  self.assertFalse(service._inProcess)
2253  process = Process("test")
2254  process.d = service
2255  self.assertTrue(service._inProcess)
2256  service2 = Service("d")
2257  process.d = service2
2258  self.assertFalse(service._inProcess)
2259  self.assertTrue(service2._inProcess)
2260  del process.d
2261  self.assertFalse(service2._inProcess)
2262 

◆ testSubProcess()

def Config.TestModuleCommand.testSubProcess (   self)

Definition at line 2820 of file Config.py.

2820  def testSubProcess(self):
2821  process = Process("Parent")
2822  subProcess = Process("Child")
2823  subProcess.a = EDProducer("A")
2824  subProcess.p = Path(subProcess.a)
2825  subProcess.add_(Service("Foo"))
2826  process.addSubProcess(SubProcess(subProcess))
2827  d = process.dumpPython()
2828  equalD ="""parentProcess = process
2829 process.a = cms.EDProducer("A")
2830 process.Foo = cms.Service("Foo")
2831 process.p = cms.Path(process.a)
2832 childProcess = process
2833 process = parentProcess
2834 process.addSubProcess(cms.SubProcess(process = childProcess, SelectEvents = cms.untracked.PSet(
2835 ), outputCommands = cms.untracked.vstring()))"""
2836  equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcesses_()[0])))
2837  self.assertEqual(_lineDiff(d,Process('Parent').dumpPython()+Process('Child').dumpPython()),equalD)
2838  p = TestMakePSet()
2839  process.fillProcessDesc(p)
2840  self.assertEqual((True,['a']),p.values["subProcesses"][1][0].values["process"][1].values['@all_modules'])
2841  self.assertEqual((True,['p']),p.values["subProcesses"][1][0].values["process"][1].values['@paths'])
2842  self.assertEqual({'@service_type':(True,'Foo')}, p.values["subProcesses"][1][0].values["process"][1].values["services"][1][0].values)

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

◆ testSwitchProducer()

def Config.TestModuleCommand.testSwitchProducer (   self)

Definition at line 2859 of file Config.py.

2859  def testSwitchProducer(self):
2860  proc = Process("test")
2861  proc.sp = SwitchProducerTest(test2 = EDProducer("Foo",
2862  a = int32(1),
2863  b = PSet(c = int32(2))),
2864  test1 = EDProducer("Bar",
2865  aa = int32(11),
2866  bb = PSet(cc = int32(12))))
2867  proc.a = EDProducer("A")
2868  proc.s = Sequence(proc.a + proc.sp)
2869  proc.t = Task(proc.a, proc.sp)
2870  proc.p = Path()
2871  proc.p.associate(proc.t)
2872  p = TestMakePSet()
2873  proc.fillProcessDesc(p)
2874  self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
2875  self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
2876  self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
2877  all_cases = copy.deepcopy(p.values["sp"][1].values["@all_cases"])
2878  all_cases[1].sort() # names of all cases come via dict, i.e. their order is undefined
2879  self.assertEqual((True, ["sp@test1", "sp@test2"]), all_cases)
2880  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
2881  self.assertEqual(["a", "sp", "sp@test1", "sp@test2"], p.values["@all_modules"][1])
2882  self.assertEqual((True,"EDProducer"), p.values["sp@test1"][1].values["@module_edm_type"])
2883  self.assertEqual((True,"Bar"), p.values["sp@test1"][1].values["@module_type"])
2884  self.assertEqual((True,"EDProducer"), p.values["sp@test2"][1].values["@module_edm_type"])
2885  self.assertEqual((True,"Foo"), p.values["sp@test2"][1].values["@module_type"])
2886  dump = proc.dumpPython()
2887  self.assertEqual(dump.find('@'), -1)
2888  self.assertEqual(specialImportRegistry.getSpecialImports(), ["from test import SwitchProducerTest"])
2889  self.assertTrue(dump.find("\nfrom test import SwitchProducerTest\n") != -1)
2890 
2891  # EDAlias as non-chosen case
2892  proc = Process("test")
2893  proc.sp = SwitchProducerTest(test2 = EDProducer("Foo",
2894  a = int32(1),
2895  b = PSet(c = int32(2))),
2896  test1 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
2897  proc.a = EDProducer("A")
2898  proc.s = Sequence(proc.a + proc.sp)
2899  proc.t = Task(proc.a, proc.sp)
2900  proc.p = Path()
2901  proc.p.associate(proc.t)
2902  p = TestMakePSet()
2903  proc.fillProcessDesc(p)
2904  self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
2905  self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
2906  self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
2907  all_cases = copy.deepcopy(p.values["sp"][1].values["@all_cases"])
2908  all_cases[1].sort()
2909  self.assertEqual((True, ["sp@test1", "sp@test2"]), all_cases)
2910  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
2911  self.assertEqual(["a", "sp", "sp@test2"], p.values["@all_modules"][1])
2912  self.assertEqual(["sp@test1"], p.values["@all_aliases"][1])
2913  self.assertEqual((True,"EDProducer"), p.values["sp@test2"][1].values["@module_edm_type"])
2914  self.assertEqual((True,"Foo"), p.values["sp@test2"][1].values["@module_type"])
2915  self.assertEqual((True,"EDAlias"), p.values["sp@test1"][1].values["@module_edm_type"])
2916  self.assertEqual((True,"Bar"), p.values["sp@test1"][1].values["a"][1][0].values["type"])
2917 
2918  # EDAlias as chosen case
2919  proc = Process("test")
2920  proc.sp = SwitchProducerTest(test1 = EDProducer("Foo",
2921  a = int32(1),
2922  b = PSet(c = int32(2))),
2923  test2 = EDAlias(a = VPSet(PSet(type = string("Bar")))))
2924  proc.a = EDProducer("A")
2925  proc.s = Sequence(proc.a + proc.sp)
2926  proc.t = Task(proc.a, proc.sp)
2927  proc.p = Path()
2928  proc.p.associate(proc.t)
2929  p = TestMakePSet()
2930  proc.fillProcessDesc(p)
2931  self.assertEqual((True,"EDProducer"), p.values["sp"][1].values["@module_edm_type"])
2932  self.assertEqual((True, "SwitchProducer"), p.values["sp"][1].values["@module_type"])
2933  self.assertEqual((True, "sp"), p.values["sp"][1].values["@module_label"])
2934  self.assertEqual((True, ["sp@test1", "sp@test2"]), p.values["sp"][1].values["@all_cases"])
2935  self.assertEqual((False, "sp@test2"), p.values["sp"][1].values["@chosen_case"])
2936  self.assertEqual(["a", "sp", "sp@test1"], p.values["@all_modules"][1])
2937  self.assertEqual(["sp@test2"], p.values["@all_aliases"][1])
2938  self.assertEqual((True,"EDProducer"), p.values["sp@test1"][1].values["@module_edm_type"])
2939  self.assertEqual((True,"Foo"), p.values["sp@test1"][1].values["@module_type"])
2940  self.assertEqual((True,"EDAlias"), p.values["sp@test2"][1].values["@module_edm_type"])
2941  self.assertEqual((True,"Bar"), p.values["sp@test2"][1].values["a"][1][0].values["type"])
2942 

◆ testTask()

def Config.TestModuleCommand.testTask (   self)

Definition at line 2263 of file Config.py.

2263  def testTask(self):
2264 
2265  # create some objects to use in tests
2266  edanalyzer = EDAnalyzer("a")
2267  edproducer = EDProducer("b")
2268  edproducer2 = EDProducer("b2")
2269  edproducer3 = EDProducer("b3")
2270  edproducer4 = EDProducer("b4")
2271  edproducer8 = EDProducer("b8")
2272  edproducer9 = EDProducer("b9")
2273  edfilter = EDFilter("c")
2274  service = Service("d")
2275  service3 = Service("d")
2276  essource = ESSource("e")
2277  esproducer = ESProducer("f")
2278  testTask2 = Task()
2279 
2280  # test adding things to Tasks
2281  testTask1 = Task(edproducer, edfilter)
2282  self.assertRaises(RuntimeError, testTask1.add, edanalyzer)
2283  testTask1.add(essource, service)
2284  testTask1.add(essource, esproducer)
2285  testTask1.add(testTask2)
2286  coll = testTask1._collection
2287  self.assertTrue(edproducer in coll)
2288  self.assertTrue(edfilter in coll)
2289  self.assertTrue(service in coll)
2290  self.assertTrue(essource in coll)
2291  self.assertTrue(esproducer in coll)
2292  self.assertTrue(testTask2 in coll)
2293  self.assertTrue(len(coll) == 6)
2294  self.assertTrue(len(testTask2._collection) == 0)
2295 
2296  taskContents = []
2297  for i in testTask1:
2298  taskContents.append(i)
2299  self.assertTrue(taskContents == [edproducer, edfilter, essource, service, esproducer, testTask2])
2300 
2301  # test attaching Task to Process
2302  process = Process("test")
2303 
2304  process.mproducer = edproducer
2305  process.mproducer2 = edproducer2
2306  process.mfilter = edfilter
2307  process.messource = essource
2308  process.mesproducer = esproducer
2309  process.d = service
2310 
2311  testTask3 = Task(edproducer, edproducer2)
2312  testTask1.add(testTask3)
2313  process.myTask1 = testTask1
2314 
2315  # test the validation that occurs when attaching a Task to a Process
2316  # first a case that passes, then one the fails on an EDProducer
2317  # then one that fails on a service
2318  l = set()
2319  visitor = NodeNameVisitor(l)
2320  testTask1.visit(visitor)
2321  self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
2322  l2 = testTask1.moduleNames
2323  self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
2324 
2325  testTask4 = Task(edproducer3)
2326  l.clear()
2327  self.assertRaises(RuntimeError, testTask4.visit, visitor)
2328  try:
2329  process.myTask4 = testTask4
2330  self.assertTrue(False)
2331  except RuntimeError:
2332  pass
2333 
2334  testTask5 = Task(service3)
2335  l.clear()
2336  self.assertRaises(RuntimeError, testTask5.visit, visitor)
2337  try:
2338  process.myTask5 = testTask5
2339  self.assertTrue(False)
2340  except RuntimeError:
2341  pass
2342 
2343  process.d = service3
2344  process.myTask5 = testTask5
2345 
2346  # test placement into the Process and the tasks property
2347  expectedDict = { 'myTask1' : testTask1, 'myTask5' : testTask5 }
2348  expectedFixedDict = DictTypes.FixedKeysDict(expectedDict);
2349  self.assertTrue(process.tasks == expectedFixedDict)
2350  self.assertTrue(process.tasks['myTask1'] == testTask1)
2351  self.assertTrue(process.myTask1 == testTask1)
2352 
2353  # test replacing an EDProducer in a Task when calling __settattr__
2354  # for the EDProducer on the Process.
2355  process.mproducer2 = edproducer4
2356  process.d = service
2357  l = list()
2358  visitor1 = ModuleNodeVisitor(l)
2359  testTask1.visit(visitor1)
2360  l.sort(key=lambda mod: mod.__str__())
2361  expectedList = sorted([edproducer,essource,esproducer,service,edfilter,edproducer,edproducer4],key=lambda mod: mod.__str__())
2362  self.assertTrue(expectedList == l)
2363  process.myTask6 = Task()
2364  process.myTask7 = Task()
2365  process.mproducer8 = edproducer8
2366  process.myTask8 = Task(process.mproducer8)
2367  process.myTask6.add(process.myTask7)
2368  process.myTask7.add(process.myTask8)
2369  process.myTask1.add(process.myTask6)
2370  process.myTask8.add(process.myTask5)
2371 
2372  testDict = process._itemsInDependencyOrder(process.tasks)
2373  expectedLabels = ["myTask5", "myTask8", "myTask7", "myTask6", "myTask1"]
2374  expectedTasks = [process.myTask5, process.myTask8, process.myTask7, process.myTask6, process.myTask1]
2375  index = 0
2376  for testLabel, testTask in testDict.items():
2377  self.assertTrue(testLabel == expectedLabels[index])
2378  self.assertTrue(testTask == expectedTasks[index])
2379  index += 1
2380 
2381  pythonDump = testTask1.dumpPython(PrintOptions())
2382 
2383 
2384  expectedPythonDump = 'cms.Task(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer, process.mproducer2, process.myTask6)\n'
2385  self.assertTrue(pythonDump == expectedPythonDump)
2386 
2387  process.myTask5 = Task()
2388  process.myTask100 = Task()
2389  process.mproducer9 = edproducer9
2390  sequence1 = Sequence(process.mproducer8, process.myTask1, process.myTask5, testTask2, testTask3)
2391  sequence2 = Sequence(process.mproducer8 + process.mproducer9)
2392  process.sequence3 = Sequence((process.mproducer8 + process.mfilter))
2393  sequence4 = Sequence()
2394  process.path1 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+sequence4)
2395  process.path1.associate(process.myTask1, process.myTask5, testTask2, testTask3)
2396  process.path11 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+ sequence4,process.myTask1, process.myTask5, testTask2, testTask3, process.myTask100)
2397  process.path2 = Path(process.mproducer)
2398  process.path3 = Path(process.mproducer9+process.mproducer8,testTask2)
2399 
2400  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')
2401 
2402  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')
2403 
2404  # test NodeNameVisitor and moduleNames
2405  l = set()
2406  nameVisitor = NodeNameVisitor(l)
2407  process.path1.visit(nameVisitor)
2408  self.assertTrue(l == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
2409  self.assertTrue(process.path1.moduleNames() == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
2410 
2411  # test copy
2412  process.mproducer10 = EDProducer("b10")
2413  process.path21 = process.path11.copy()
2414  process.path21.replace(process.mproducer, process.mproducer10)
2415 
2416  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')
2417 
2418  # Some peculiarities of the way things work show up here. dumpPython sorts tasks and
2419  # removes duplication at the level of strings. The Task and Sequence objects themselves
2420  # remove duplicate tasks in their contents if the instances are the same (exact same python
2421  # object id which is not the same as the string representation being the same).
2422  # Also note that the mutating visitor replaces sequences and tasks that have
2423  # modified contents with their modified contents, it does not modify the sequence
2424  # or task itself.
2425  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.myTask6), process.myTask100, process.myTask5)\n')
2426 
2427  process.path22 = process.path21.copyAndExclude([process.d, process.mesproducer, process.mfilter])
2428  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.myTask6), process.myTask100, process.myTask5)\n')
2429 
2430  process.path23 = process.path22.copyAndExclude([process.messource, process.mproducer10])
2431  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.myTask6), process.myTask100, process.myTask5)\n')
2432 
2433  process.a = EDAnalyzer("MyAnalyzer")
2434  process.b = OutputModule("MyOutputModule")
2435  process.c = EDFilter("MyFilter")
2436  process.d = EDProducer("MyProducer")
2437  process.e = ESProducer("MyESProducer")
2438  process.f = ESSource("MyESSource")
2439  process.g = ESProducer("g")
2440  process.path24 = Path(process.a+process.b+process.c+process.d)
2441  process.path25 = process.path24.copyAndExclude([process.a,process.b,process.c])
2442  self.assertTrue(process.path25.dumpPython() == 'cms.Path(process.d)\n')
2443  #print process.path3
2444  #print process.dumpPython()
2445 
2446  process.path200 = EndPath(Sequence(process.c,Task(process.e)))
2447  process.path200.replace(process.c,process.b)
2448  process.path200.replace(process.e,process.f)
2449  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.b, cms.Task(process.f))\n")
2450  process.path200.replace(process.b,process.c)
2451  process.path200.replace(process.f,process.e)
2452  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.c, cms.Task(process.e))\n")
2453  process.path200.replace(process.c,process.a)
2454  process.path200.replace(process.e,process.g)
2455  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.a, cms.Task(process.g))\n")
2456  process.path200.replace(process.a,process.c)
2457  process.path200.replace(process.g,process.e)
2458  self.assertEqual(process.path200.dumpPython(), "cms.EndPath(process.c, cms.Task(process.e))\n")
2459 
2460 

References list().

◆ testTaskPlaceholder()

def Config.TestModuleCommand.testTaskPlaceholder (   self)

Definition at line 3076 of file Config.py.

3076  def testTaskPlaceholder(self):
3077  p = Process("test")
3078  p.a = EDProducer("ma")
3079  p.b = EDAnalyzer("mb")
3080  p.t1 = Task(TaskPlaceholder("c"))
3081  p.t2 = Task(p.a, TaskPlaceholder("d"), p.t1)
3082  p.t3 = Task(TaskPlaceholder("e"))
3083  p.path1 = Path(p.b, p.t2, p.t3)
3084  p.t5 = Task(p.a, TaskPlaceholder("g"), TaskPlaceholder("t4"))
3085  p.t4 = Task(TaskPlaceholder("f"))
3086  p.endpath1 = EndPath(p.b, p.t5)
3087  p.t6 = Task(TaskPlaceholder("h"))
3088  p.t7 = Task(p.a, TaskPlaceholder("i"), p.t6)
3089  p.t8 = Task(TaskPlaceholder("j"))
3090  p.schedule = Schedule(p.path1, p.endpath1,tasks=[p.t7,p.t8])
3091  p.c = EDProducer("mc")
3092  p.d = EDProducer("md")
3093  p.e = EDProducer("me")
3094  p.f = EDProducer("mf")
3095  p.g = EDProducer("mg")
3096  p.h = EDProducer("mh")
3097  p.i = EDProducer("mi")
3098  p.j = EDProducer("mj")
3099  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
3100 """process.a = cms.EDProducer("ma")
3101 process.c = cms.EDProducer("mc")
3102 process.d = cms.EDProducer("md")
3103 process.e = cms.EDProducer("me")
3104 process.f = cms.EDProducer("mf")
3105 process.g = cms.EDProducer("mg")
3106 process.h = cms.EDProducer("mh")
3107 process.i = cms.EDProducer("mi")
3108 process.j = cms.EDProducer("mj")
3109 process.b = cms.EDAnalyzer("mb")
3110 process.t8 = cms.Task(cms.TaskPlaceholder("j"))
3111 process.t6 = cms.Task(cms.TaskPlaceholder("h"))
3112 process.t7 = cms.Task(cms.TaskPlaceholder("i"), process.a, process.t6)
3113 process.t4 = cms.Task(cms.TaskPlaceholder("f"))
3114 process.t5 = cms.Task(cms.TaskPlaceholder("g"), cms.TaskPlaceholder("t4"), process.a)
3115 process.t3 = cms.Task(cms.TaskPlaceholder("e"))
3116 process.t1 = cms.Task(cms.TaskPlaceholder("c"))
3117 process.t2 = cms.Task(cms.TaskPlaceholder("d"), process.a, process.t1)
3118 process.path1 = cms.Path(process.b, process.t2, process.t3)
3119 process.endpath1 = cms.EndPath(process.b, process.t5)
3120 process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])""")
3121  p.resolve()
3122  self.assertEqual(_lineDiff(p.dumpPython(),Process('test').dumpPython()),
3123 """process.a = cms.EDProducer("ma")
3124 process.c = cms.EDProducer("mc")
3125 process.d = cms.EDProducer("md")
3126 process.e = cms.EDProducer("me")
3127 process.f = cms.EDProducer("mf")
3128 process.g = cms.EDProducer("mg")
3129 process.h = cms.EDProducer("mh")
3130 process.i = cms.EDProducer("mi")
3131 process.j = cms.EDProducer("mj")
3132 process.b = cms.EDAnalyzer("mb")
3133 process.t8 = cms.Task(process.j)
3134 process.t6 = cms.Task(process.h)
3135 process.t7 = cms.Task(process.a, process.i, process.t6)
3136 process.t4 = cms.Task(process.f)
3137 process.t5 = cms.Task(process.a, process.g, process.t4)
3138 process.t3 = cms.Task(process.e)
3139 process.t1 = cms.Task(process.c)
3140 process.t2 = cms.Task(process.a, process.d, process.t1)
3141 process.path1 = cms.Path(process.b, process.t2, process.t3)
3142 process.endpath1 = cms.EndPath(process.b, process.t5)
3143 process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])""")
3144 

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

◆ testTypedParameterizable()

def Config.TestModuleCommand.testTypedParameterizable (   self)

Definition at line 1872 of file Config.py.

1872  def testTypedParameterizable(self):
1873  p = _TypedParameterizable("blah", b=int32(1))
1874  #see if copy works deeply
1875  other = p.copy()
1876  other.b = 2
1877  self.assertNotEqual(p.b,other.b)
1878 

◆ testUsing()

def Config.TestModuleCommand.testUsing (   self)

Definition at line 2713 of file Config.py.

2713  def testUsing(self):
2714  p = Process('test')
2715  p.block = PSet(a = int32(1))
2716  p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
2717  self.assertEqual(p.modu.a.value(),1)
2718  self.assertEqual(p.modu.b.value(),2)
2719 

Member Data Documentation

◆ a

Config.TestModuleCommand.a
static

Definition at line 2067 of file Config.py.

◆ b

Config.TestModuleCommand.b
static

Definition at line 2084 of file Config.py.

◆ c

Config.TestModuleCommand.c
static

Definition at line 2085 of file Config.py.

◆ d

Config.TestModuleCommand.d
static

Definition at line 2073 of file Config.py.

◆ e

Config.TestModuleCommand.e
static

Definition at line 2087 of file Config.py.

◆ f

Config.TestModuleCommand.f
static

Definition at line 2088 of file Config.py.

◆ g

Config.TestModuleCommand.g
static

Definition at line 2089 of file Config.py.

◆ p

Config.TestModuleCommand.p
static

Definition at line 2066 of file Config.py.

Referenced by Electron.Electron.ptErr().

◆ p2

Config.TestModuleCommand.p2
static

Definition at line 2071 of file Config.py.

◆ proc_mod_

Config.TestModuleCommand.proc_mod_

Definition at line 3272 of file Config.py.

◆ process

Config.TestModuleCommand.process
static

Definition at line 2147 of file Config.py.

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

◆ r

Config.TestModuleCommand.r
static

Definition at line 2070 of file Config.py.

◆ s

Config.TestModuleCommand.s
static

Definition at line 2069 of file Config.py.

◆ s1

Config.TestModuleCommand.s1
static

Definition at line 2155 of file Config.py.

◆ s2

Config.TestModuleCommand.s2
static

Definition at line 2145 of file Config.py.

◆ s3

Config.TestModuleCommand.s3
static

Definition at line 2157 of file Config.py.

◆ schedule

Config.TestModuleCommand.schedule
static

Definition at line 2072 of file Config.py.

◆ task1

Config.TestModuleCommand.task1
static

Definition at line 2094 of file Config.py.

◆ task2

Config.TestModuleCommand.task2
static

Definition at line 2092 of file Config.py.

◆ task3

Config.TestModuleCommand.task3
static

Definition at line 2091 of file Config.py.

◆ task4

Config.TestModuleCommand.task4
static

Definition at line 2093 of file Config.py.

◆ task5

Config.TestModuleCommand.task5
static

Definition at line 2090 of file Config.py.

◆ tasks

Config.TestModuleCommand.tasks
static

Definition at line 2100 of file Config.py.

mixOne_cfi.ESProducer
ESProducer
Definition: mixOne_cfi.py:33
resolutioncreator_cfi.object
object
Definition: resolutioncreator_cfi.py:4
cond::hash
Definition: Time.h:19
helpers.testContains
def testContains(self)
Definition: helpers.py:415
str
#define str(s)
Definition: TestProcessor.cc:48
Service
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
SequenceTypes.ignore
def ignore(seq)
Definition: SequenceTypes.py:630
DictTypes.FixedKeysDict
Definition: DictTypes.py:72
HistogramManager_cfi.VPSet
def VPSet(*args)
Definition: HistogramManager_cfi.py:401
mps_fire.Path
Path
Definition: mps_fire.py:290
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:31
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:92
Types.untracked
untracked
Definition: Types.py:35
Config._lineDiff
def _lineDiff(newString, oldString)
Definition: Config.py:1738
list
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger list("!*", "!HLTx*" if it matches 2 triggers or more) will accept the event if all the matching triggers are FAIL. It will reject the event if any of the triggers are PASS or EXCEPTION(this matches the behavior of "!*" before the partial wildcard feature was incorporated). Triggers which are in the READY state are completely ignored.(READY should never be returned since the trigger paths have been run
OrderedSet
Definition: OrderedSet.py:1
cmsswSequenceInfo.Sequence
Sequence
Definition: cmsswSequenceInfo.py:14
CollectionTags_cfi.Source
Source
Definition: CollectionTags_cfi.py:11
Generated for CMSSW Reference Manual by doxygen 1.8.16