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

Member Function Documentation

◆ setUp()

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

Definition at line 1839 of file Config.py.

1839  def setUp(self):
1840  """Nothing to do """
1841  None

◆ testCloneSequence()

def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 2504 of file Config.py.

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

References triggerObjects_cff.id, and str.

◆ testContains()

def Config.TestModuleCommand.testContains (   self)

Definition at line 2520 of file Config.py.

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

◆ testDelete()

def Config.TestModuleCommand.testDelete (   self)

Definition at line 3148 of file Config.py.

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

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

References Types.untracked.

◆ testFreeze()

def Config.TestModuleCommand.testFreeze (   self)

Definition at line 2805 of file Config.py.

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

◆ testGlobalReplace()

def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 2176 of file Config.py.

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

References list().

◆ testImplicitSchedule()

def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 2683 of file Config.py.

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

◆ testMaxEvents()

def Config.TestModuleCommand.testMaxEvents (   self)

Definition at line 2758 of file Config.py.

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

◆ testModifier()

def Config.TestModuleCommand.testModifier (   self)

Definition at line 3179 of file Config.py.

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

References resolutioncreator_cfi.object.

◆ testOptions()

def Config.TestModuleCommand.testOptions (   self)

Definition at line 2746 of file Config.py.

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

◆ testOverride()

def Config.TestModuleCommand.testOverride (   self)

Definition at line 2723 of file Config.py.

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

◆ testParameterizable()

def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 1842 of file Config.py.

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

◆ testPath()

def Config.TestModuleCommand.testPath (   self)

Definition at line 2464 of file Config.py.

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

References SequenceTypes.ignore(), and str.

◆ testPrefers()

def Config.TestModuleCommand.testPrefers (   self)

Definition at line 2785 of file Config.py.

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

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

◆ testProcessDumpPython()

def Config.TestModuleCommand.testProcessDumpPython (   self)

Definition at line 1994 of file Config.py.

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

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

◆ testProcessExtend()

def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 1907 of file Config.py.

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

References resolutioncreator_cfi.object, and str.

◆ testProcessFragment()

def Config.TestModuleCommand.testProcessFragment (   self)

Definition at line 3512 of file Config.py.

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

◆ testProcessInsertion()

def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 1882 of file Config.py.

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

◆ testPrune()

def Config.TestModuleCommand.testPrune (   self)

Definition at line 2946 of file Config.py.

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

◆ testRefToPSet()

def Config.TestModuleCommand.testRefToPSet (   self)

Definition at line 2846 of file Config.py.

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

◆ testSchedule()

def Config.TestModuleCommand.testSchedule (   self)

Definition at line 2578 of file Config.py.

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

References list().

◆ testSecSource()

def Config.TestModuleCommand.testSecSource (   self)

Definition at line 2171 of file Config.py.

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

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

◆ testSequence()

def Config.TestModuleCommand.testSequence (   self)

Definition at line 2228 of file Config.py.

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

References str.

◆ testSequence2()

def Config.TestModuleCommand.testSequence2 (   self)

Definition at line 2243 of file Config.py.

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

◆ testServiceInProcess()

def Config.TestModuleCommand.testServiceInProcess (   self)

Definition at line 2253 of file Config.py.

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

◆ testSubProcess()

def Config.TestModuleCommand.testSubProcess (   self)

Definition at line 2823 of file Config.py.

2823  def testSubProcess(self):
2824  process = Process("Parent")
2825  subProcess = Process("Child")
2826  subProcess.a = EDProducer("A")
2827  subProcess.p = Path(subProcess.a)
2828  subProcess.add_(Service("Foo"))
2829  process.addSubProcess(SubProcess(subProcess))
2830  d = process.dumpPython()
2831  equalD ="""parentProcess = process
2832 process.a = cms.EDProducer("A")
2833 process.Foo = cms.Service("Foo")
2834 process.p = cms.Path(process.a)
2835 childProcess = process
2836 process = parentProcess
2837 process.addSubProcess(cms.SubProcess(process = childProcess, SelectEvents = cms.untracked.PSet(
2838 ), outputCommands = cms.untracked.vstring()))"""
2839  equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcesses_()[0])))
2840  self.assertEqual(_lineDiff(d,Process('Parent').dumpPython()+Process('Child').dumpPython()),equalD)
2841  p = TestMakePSet()
2842  process.fillProcessDesc(p)
2843  self.assertEqual((True,['a']),p.values["subProcesses"][1][0].values["process"][1].values['@all_modules'])
2844  self.assertEqual((True,['p']),p.values["subProcesses"][1][0].values["process"][1].values['@paths'])
2845  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 2862 of file Config.py.

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

◆ testTask()

def Config.TestModuleCommand.testTask (   self)

Definition at line 2266 of file Config.py.

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

References list().

◆ testTaskPlaceholder()

def Config.TestModuleCommand.testTaskPlaceholder (   self)

Definition at line 3079 of file Config.py.

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

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

◆ testTypedParameterizable()

def Config.TestModuleCommand.testTypedParameterizable (   self)

Definition at line 1875 of file Config.py.

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

◆ testUsing()

def Config.TestModuleCommand.testUsing (   self)

Definition at line 2716 of file Config.py.

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

Member Data Documentation

◆ a

Config.TestModuleCommand.a
static

Definition at line 2070 of file Config.py.

◆ b

Config.TestModuleCommand.b
static

Definition at line 2087 of file Config.py.

◆ c

Config.TestModuleCommand.c
static

Definition at line 2088 of file Config.py.

◆ d

Config.TestModuleCommand.d
static

Definition at line 2076 of file Config.py.

◆ e

Config.TestModuleCommand.e
static

Definition at line 2090 of file Config.py.

◆ f

Config.TestModuleCommand.f
static

Definition at line 2091 of file Config.py.

◆ g

Config.TestModuleCommand.g
static

Definition at line 2092 of file Config.py.

◆ p

Config.TestModuleCommand.p
static

Definition at line 2069 of file Config.py.

Referenced by Electron.Electron.ptErr().

◆ p2

Config.TestModuleCommand.p2
static

Definition at line 2074 of file Config.py.

◆ proc_mod_

Config.TestModuleCommand.proc_mod_

Definition at line 3275 of file Config.py.

◆ process

Config.TestModuleCommand.process
static

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

◆ s

Config.TestModuleCommand.s
static

Definition at line 2072 of file Config.py.

◆ s1

Config.TestModuleCommand.s1
static

Definition at line 2158 of file Config.py.

◆ s2

Config.TestModuleCommand.s2
static

Definition at line 2148 of file Config.py.

◆ s3

Config.TestModuleCommand.s3
static

Definition at line 2160 of file Config.py.

◆ schedule

Config.TestModuleCommand.schedule
static

Definition at line 2075 of file Config.py.

◆ task1

Config.TestModuleCommand.task1
static

Definition at line 2097 of file Config.py.

◆ task2

Config.TestModuleCommand.task2
static

Definition at line 2095 of file Config.py.

◆ task3

Config.TestModuleCommand.task3
static

Definition at line 2094 of file Config.py.

◆ task4

Config.TestModuleCommand.task4
static

Definition at line 2096 of file Config.py.

◆ task5

Config.TestModuleCommand.task5
static

Definition at line 2093 of file Config.py.

◆ tasks

Config.TestModuleCommand.tasks
static

Definition at line 2103 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:1741
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