CMS 3D CMS Logo
List of all members | Public Member Functions | Public Attributes
Config.TestModuleCommand Class Reference
Inheritance diagram for Config.TestModuleCommand:

Public Member Functions

def setUp (self)
 
def testCloneSequence (self)
 
def testDelete (self)
 
def testExamples (self)
 
def testFreeze (self)
 
def testGlobalReplace (self)
 
def testImplicitSchedule (self)
 
def testModifier (self)
 
def testOverride (self)
 
def testParameterizable (self)
 
def testPath (self)
 
def testPrefers (self)
 
def testProcessDumpPython (self)
 
def testProcessExtend (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 testTask (self)
 
def testTaskPlaceholder (self)
 
def testTypedParameterizable (self)
 
def testUsing (self)
 

Public Attributes

 a
 
 proc_mod_
 

Detailed Description

Definition at line 1553 of file Config.py.

Member Function Documentation

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

Definition at line 1554 of file Config.py.

1554  def setUp(self):
1555  """Nothing to do """
1556  None
def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 2275 of file Config.py.

References triggerObjects_cff.id, and harvestTrackValidationPlots.str.

2275  def testCloneSequence(self):
2276  p = Process("test")
2277  a = EDAnalyzer("MyAnalyzer")
2278  p.a = a
2279  a.setLabel("a")
2280  b = EDAnalyzer("YOurAnalyzer")
2281  p.b = b
2282  b.setLabel("b")
2283  path = Path(a * b)
2284  p.path = Path(p.a*p.b)
2285  lookuptable = {id(a): p.a, id(b): p.b}
2286  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
2287  #lookuptable = p._cloneToObjectDict
2288  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
2289  self.assertEqual(str(path),str(p.path))
2290 
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:28
Config.TestModuleCommand.testCloneSequence
def testCloneSequence(self)
Definition: Config.py:2275
def Config.TestModuleCommand.testDelete (   self)

Definition at line 2841 of file Config.py.

References ConfigBuilder.dumpPython().

2841  def testDelete(self):
2842  p = Process("test")
2843  p.a = EDAnalyzer("MyAnalyzer")
2844  p.b = EDAnalyzer("YourAnalyzer")
2845  p.c = EDAnalyzer("OurAnalyzer")
2846  p.d = EDAnalyzer("OurAnalyzer")
2847  p.e = EDAnalyzer("OurAnalyzer")
2848  p.f = EDAnalyzer("OurAnalyzer")
2849  p.g = EDProducer("OurProducer")
2850  p.h = EDProducer("YourProducer")
2851  p.t1 = Task(p.g, p.h)
2852  t2 = Task(p.g, p.h)
2853  t3 = Task(p.g, p.h)
2854  p.s = Sequence(p.d+p.e)
2855  p.path1 = Path(p.a+p.f+p.s,t2)
2856  p.endpath1 = EndPath(p.b+p.f)
2857  p.schedule = Schedule(tasks=[t3])
2858  self.assertTrue(hasattr(p, 'f'))
2859  self.assertTrue(hasattr(p, 'g'))
2860  del p.e
2861  del p.f
2862  del p.g
2863  self.assertFalse(hasattr(p, 'f'))
2864  self.assertFalse(hasattr(p, 'g'))
2865  self.assertTrue(p.t1.dumpPython(None) == 'cms.Task(process.h)\n')
2866  self.assertTrue(p.s.dumpPython(None) == 'cms.Sequence(process.d)\n')
2867  self.assertTrue(p.path1.dumpPython(None) == 'cms.Path(process.a+process.s, cms.Task(process.h))\n')
2868  self.assertTrue(p.endpath1.dumpPython(None) == 'cms.EndPath(process.b)\n')
2869  del p.s
2870  self.assertTrue(p.path1.dumpPython(None) == 'cms.Path(process.a+(process.d), cms.Task(process.h))\n')
2871  self.assertTrue(p.schedule_().dumpPython(None) == 'cms.Schedule(tasks=[cms.Task(process.h)])\n')
ConfigBuilder.dumpPython
def dumpPython(process, name)
Definition: ConfigBuilder.py:88
def Config.TestModuleCommand.testExamples (   self)

Definition at line 2459 of file Config.py.

2459  def testExamples(self):
2460  p = Process("Test")
2461  p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
2462  p.foos = EDProducer("FooProducer")
2463  p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
2464  p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
2465  p.bars.foos = 'Foosball'
2466  self.assertEqual(p.bars.foos, InputTag('Foosball'))
2467  p.p = Path(p.foos*p.bars)
2468  p.e = EndPath(p.out)
2469  p.add_(Service("MessageLogger"))
2470 
Config.TestModuleCommand.testExamples
def testExamples(self)
Definition: Config.py:2459
def Config.TestModuleCommand.testFreeze (   self)

Definition at line 2525 of file Config.py.

2525  def testFreeze(self):
2526  process = Process("Freeze")
2527  m = EDProducer("M", p=PSet(i = int32(1)))
2528  m.p.i = 2
2529  process.m = m
2530  # should be frozen
2531  #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
2532  #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
2533  #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
2534  #self.assertRaises(ValueError, setattr, m, 'j', 1)
2535  # But OK to change through the process
2536  process.m.p.i = 4
2537  self.assertEqual(process.m.p.i.value(), 4)
2538  process.m.p = PSet(j=int32(1))
2539  # should work to clone it, though
2540  m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
2541  m2.p.i = 6
2542  m2.j = 8
def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 1952 of file Config.py.

References list(), and cmsPerfHarvest.visit().

1952  def testGlobalReplace(self):
1953  p = Process('test')
1954  p.a = EDAnalyzer("MyAnalyzer")
1955  old = p.a
1956  p.b = EDAnalyzer("YourAnalyzer")
1957  p.c = EDAnalyzer("OurAnalyzer")
1958  p.d = EDProducer("MyProducer")
1959  old2 = p.d
1960  p.t1 = Task(p.d)
1961  t2 = Task(p.d)
1962  t3 = Task(p.d)
1963  t4 = Task(p.d)
1964  t5 = Task(p.d)
1965  t6 = Task(p.d)
1966  s = Sequence(p.a*p.b)
1967  p.s4 = Sequence(p.a*p.b)
1968  s.associate(t2)
1969  p.s4.associate(t2)
1970  p.p = Path(p.c+s+p.a)
1971  p.e3 = EndPath(p.c+s+p.a)
1972  new = EDAnalyzer("NewAnalyzer")
1973  new2 = EDProducer("NewProducer")
1974  visitor1 = NodeVisitor()
1975  p.p.visit(visitor1)
1976  self.assertTrue(visitor1.modules == set([old,old2,p.b,p.c]))
1977  p.schedule = Schedule(tasks=[t6])
1978  p.globalReplace("a",new)
1979  p.globalReplace("d",new2)
1980  visitor2 = NodeVisitor()
1981  p.p.visit(visitor2)
1982  self.assertTrue(visitor2.modules == set([new,new2,p.b,p.c]))
1983  visitor3 = NodeVisitor()
1984  p.e3.visit(visitor3)
1985  self.assertTrue(visitor3.modules == set([new,new2,p.b,p.c]))
1986  visitor4 = NodeVisitor()
1987  p.s4.visit(visitor4)
1988  self.assertTrue(visitor4.modules == set([new,new2,p.b]))
1989  visitor5 = NodeVisitor()
1990  p.t1.visit(visitor5)
1991  self.assertTrue(visitor5.modules == set([new2]))
1992  visitor6 = NodeVisitor()
1993  listOfTasks = list(p.schedule._tasks)
1994  listOfTasks[0].visit(visitor6)
1995  self.assertTrue(visitor6.modules == set([new2]))
1996 
cmsPerfHarvest.visit
def visit(visitdir)
Retrieve data from a perf suite output (sub) directory, only examines TimeSize at the moment...
Definition: cmsPerfHarvest.py:67
Config.TestModuleCommand.testGlobalReplace
def testGlobalReplace(self)
Definition: Config.py:1952
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
def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 2396 of file Config.py.

2396  def testImplicitSchedule(self):
2397  p = Process("test")
2398  p.a = EDAnalyzer("MyAnalyzer")
2399  p.b = EDAnalyzer("YourAnalyzer")
2400  p.c = EDAnalyzer("OurAnalyzer")
2401  p.path1 = Path(p.a)
2402  p.path2 = Path(p.b)
2403  self.assert_(p.schedule is None)
2404  pths = p.paths
2405  keys = pths.keys()
2406  self.assertEqual(pths[keys[0]],p.path1)
2407  self.assertEqual(pths[keys[1]],p.path2)
2408  p.prune()
2409  self.assert_(hasattr(p, 'a'))
2410  self.assert_(hasattr(p, 'b'))
2411  self.assert_(not hasattr(p, 'c'))
2412  self.assert_(hasattr(p, 'path1'))
2413  self.assert_(hasattr(p, 'path2'))
2414 
2415 
2416  p = Process("test")
2417  p.a = EDAnalyzer("MyAnalyzer")
2418  p.b = EDAnalyzer("YourAnalyzer")
2419  p.c = EDAnalyzer("OurAnalyzer")
2420  p.path2 = Path(p.b)
2421  p.path1 = Path(p.a)
2422  self.assert_(p.schedule is None)
2423  pths = p.paths
2424  keys = pths.keys()
2425  self.assertEqual(pths[keys[1]],p.path1)
2426  self.assertEqual(pths[keys[0]],p.path2)
2427 
2428 
Config.TestModuleCommand.testImplicitSchedule
def testImplicitSchedule(self)
Definition: Config.py:2396
def Config.TestModuleCommand.testModifier (   self)

Definition at line 2872 of file Config.py.

References cmsPerfStripChart.dict, and resolutioncreator_cfi.object.

2872  def testModifier(self):
2873  m1 = Modifier()
2874  p = Process("test",m1)
2875  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
2876  def _mod_fred(obj):
2877  obj.fred = 2
2878  m1.toModify(p.a,_mod_fred)
2879  self.assertEqual(p.a.fred.value(),2)
2880  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
2881  m1.toModify(p.b, wilma = 2)
2882  self.assertEqual(p.b.wilma.value(),2)
2883  self.assert_(p.isUsingModifier(m1))
2884  #check that Modifier not attached to a process doesn't run
2885  m1 = Modifier()
2886  p = Process("test")
2887  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
2888  m1.toModify(p.a,_mod_fred)
2889  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
2890  m1.toModify(p.b, wilma = 2)
2891  self.assertEqual(p.a.fred.value(),1)
2892  self.assertEqual(p.b.wilma.value(),1)
2893  self.assertEqual(p.isUsingModifier(m1),False)
2894  #make sure clones get the changes
2895  m1 = Modifier()
2896  p = Process("test",m1)
2897  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2898  m1.toModify(p.a, fred = int32(2))
2899  p.b = p.a.clone(wilma = int32(3))
2900  self.assertEqual(p.a.fred.value(),2)
2901  self.assertEqual(p.a.wilma.value(),1)
2902  self.assertEqual(p.b.fred.value(),2)
2903  self.assertEqual(p.b.wilma.value(),3)
2904  #test removal of parameter
2905  m1 = Modifier()
2906  p = Process("test",m1)
2907  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1), fintstones = PSet(fred = int32(1)))
2908  m1.toModify(p.a, fred = None, fintstones = dict(fred = None))
2909  self.assertEqual(hasattr(p.a, "fred"), False)
2910  self.assertEqual(hasattr(p.a.fintstones, "fred"), False)
2911  self.assertEqual(p.a.wilma.value(),1)
2912  #test adding a parameter
2913  m1 = Modifier()
2914  p = Process("test",m1)
2915  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
2916  m1.toModify(p.a, wilma = int32(2))
2917  self.assertEqual(p.a.fred.value(), 1)
2918  self.assertEqual(p.a.wilma.value(),2)
2919  #test setting of value in PSet
2920  m1 = Modifier()
2921  p = Process("test",m1)
2922  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = int32(1), wilma = int32(1)))
2923  m1.toModify(p.a, flintstones = dict(fred = int32(2)))
2924  self.assertEqual(p.a.flintstones.fred.value(),2)
2925  self.assertEqual(p.a.flintstones.wilma.value(),1)
2926  #test proper exception from nonexisting parameter name
2927  m1 = Modifier()
2928  p = Process("test",m1)
2929  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = PSet(wilma = int32(1))))
2930  self.assertRaises(KeyError, lambda: m1.toModify(p.a, flintstones = dict(imnothere = dict(wilma=2))))
2931  self.assertRaises(KeyError, lambda: m1.toModify(p.a, foo = 1))
2932  #test setting a value in a VPSet
2933  m1 = Modifier()
2934  p = Process("test",m1)
2935  p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
2936  m1.toModify(p.a, flintstones = {1:dict(wilma = int32(2))})
2937  self.assertEqual(p.a.flintstones[0].fred.value(),1)
2938  self.assertEqual(p.a.flintstones[1].wilma.value(),2)
2939  #test setting a value in a list of values
2940  m1 = Modifier()
2941  p = Process("test",m1)
2942  p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
2943  m1.toModify(p.a, fred = {1:7})
2944  self.assertEqual(p.a.fred[0],1)
2945  self.assertEqual(p.a.fred[1],7)
2946  self.assertEqual(p.a.fred[2],3)
2947  #test IndexError setting a value in a list to an item key not in the list
2948  m1 = Modifier()
2949  p = Process("test",m1)
2950  p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
2951  raised = False
2952  try: m1.toModify(p.a, fred = {5:7})
2953  except IndexError as e: raised = True
2954  self.assertEqual(raised, True)
2955  #test TypeError setting a value in a list using a key that is not an int
2956  m1 = Modifier()
2957  p = Process("test",m1)
2958  p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
2959  raised = False
2960  try: m1.toModify(p.a, flintstones = dict(bogus = int32(37)))
2961  except TypeError as e: raised = True
2962  self.assertEqual(raised, True)
2963  #test that load causes process wide methods to run
2964  def _rem_a(proc):
2965  del proc.a
2966  class ProcModifierMod(object):
2967  def __init__(self,modifier,func):
2968  self.proc_mod_ = modifier.makeProcessModifier(func)
2969  class DummyMod(object):
2970  def __init__(self):
2971  self.a = EDAnalyzer("Dummy")
2972  testMod = DummyMod()
2973  p.extend(testMod)
2974  self.assert_(hasattr(p,"a"))
2975  m1 = Modifier()
2976  p = Process("test",m1)
2977  testProcMod = ProcModifierMod(m1,_rem_a)
2978  p.extend(testMod)
2979  p.extend(testProcMod)
2980  self.assert_(not hasattr(p,"a"))
2981  #test ModifierChain
2982  m1 = Modifier()
2983  mc = ModifierChain(m1)
2984  p = Process("test",mc)
2985  self.assert_(p.isUsingModifier(m1))
2986  self.assert_(p.isUsingModifier(mc))
2987  testMod = DummyMod()
2988  p.b = EDAnalyzer("Dummy2", fred = int32(1))
2989  m1.toModify(p.b, fred = int32(3))
2990  p.extend(testMod)
2991  testProcMod = ProcModifierMod(m1,_rem_a)
2992  p.extend(testProcMod)
2993  self.assert_(not hasattr(p,"a"))
2994  self.assertEqual(p.b.fred.value(),3)
2995  #check cloneAndExclude
2996  m1 = Modifier()
2997  m2 = Modifier()
2998  mc = ModifierChain(m1,m2)
2999  mclone = mc.copyAndExclude([m2])
3000  self.assert_(not mclone._isOrContains(m2))
3001  self.assert_(mclone._isOrContains(m1))
3002  m3 = Modifier()
3003  mc2 = ModifierChain(mc,m3)
3004  mclone = mc2.copyAndExclude([m2])
3005  self.assert_(not mclone._isOrContains(m2))
3006  self.assert_(mclone._isOrContains(m1))
3007  self.assert_(mclone._isOrContains(m3))
3008  #check combining
3009  m1 = Modifier()
3010  m2 = Modifier()
3011  p = Process("test",m1)
3012  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3013  (m1 & m2).toModify(p.a, fred = int32(2))
3014  self.assertRaises(TypeError, lambda: (m1 & m2).toModify(p.a, 1, wilma=2))
3015  self.assertEqual(p.a.fred, 1)
3016  m1 = Modifier()
3017  m2 = Modifier()
3018  p = Process("test",m1,m2)
3019  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3020  (m1 & m2).toModify(p.a, fred = int32(2))
3021  self.assertEqual(p.a.fred, 2)
3022  m1 = Modifier()
3023  m2 = Modifier()
3024  m3 = Modifier()
3025  p = Process("test",m1,m2,m3)
3026  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3027  (m1 & m2 & m3).toModify(p.a, fred = int32(2))
3028  self.assertEqual(p.a.fred, 2)
3029  (m1 & (m2 & m3)).toModify(p.a, fred = int32(3))
3030  self.assertEqual(p.a.fred, 3)
3031  ((m1 & m2) & m3).toModify(p.a, fred = int32(4))
3032  self.assertEqual(p.a.fred, 4)
3033  #check inverse
3034  m1 = Modifier()
3035  m2 = Modifier()
3036  p = Process("test", m1)
3037  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3038  (~m1).toModify(p.a, fred=2)
3039  self.assertEqual(p.a.fred, 1)
3040  (~m2).toModify(p.a, wilma=2)
3041  self.assertEqual(p.a.wilma, 2)
3042  self.assertRaises(TypeError, lambda: (~m1).toModify(p.a, 1, wilma=2))
3043  self.assertRaises(TypeError, lambda: (~m2).toModify(p.a, 1, wilma=2))
3044  # check or
3045  m1 = Modifier()
3046  m2 = Modifier()
3047  m3 = Modifier()
3048  p = Process("test", m1)
3049  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3050  (m1 | m2).toModify(p.a, fred=2)
3051  self.assertEqual(p.a.fred, 2)
3052  (m1 | m2 | m3).toModify(p.a, fred=3)
3053  self.assertEqual(p.a.fred, 3)
3054  (m3 | m2 | m1).toModify(p.a, fred=4)
3055  self.assertEqual(p.a.fred, 4)
3056  ((m1 | m2) | m3).toModify(p.a, fred=5)
3057  self.assertEqual(p.a.fred, 5)
3058  (m1 | (m2 | m3)).toModify(p.a, fred=6)
3059  self.assertEqual(p.a.fred, 6)
3060  (m2 | m3).toModify(p.a, fred=7)
3061  self.assertEqual(p.a.fred, 6)
3062  self.assertRaises(TypeError, lambda: (m1 | m2).toModify(p.a, 1, wilma=2))
3063  self.assertRaises(TypeError, lambda: (m2 | m3).toModify(p.a, 1, wilma=2))
3064  # check combinations
3065  m1 = Modifier()
3066  m2 = Modifier()
3067  m3 = Modifier()
3068  m4 = Modifier()
3069  p = Process("test", m1, m2)
3070  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3071  (m1 & ~m2).toModify(p.a, fred=2)
3072  self.assertEqual(p.a.fred, 1)
3073  (m1 & ~m3).toModify(p.a, fred=2)
3074  self.assertEqual(p.a.fred, 2)
3075  (m1 | ~m2).toModify(p.a, fred=3)
3076  self.assertEqual(p.a.fred, 3)
3077  (~m1 | ~m2).toModify(p.a, fred=4)
3078  self.assertEqual(p.a.fred, 3)
3079  (~m3 & ~m4).toModify(p.a, fred=4)
3080  self.assertEqual(p.a.fred, 4)
3081  ((m1 & m3) | ~m4).toModify(p.a, fred=5)
3082  self.assertEqual(p.a.fred, 5)
3083  #check toReplaceWith
3084  m1 = Modifier()
3085  p = Process("test",m1)
3086  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
3087  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
3088  self.assertRaises(TypeError, lambda: m1.toReplaceWith(p.a, EDProducer("YourProducer")))
3089  p.b =EDAnalyzer("BAn")
3090  p.c =EDProducer("c")
3091  p.d =EDProducer("d")
3092  p.tc = Task(p.c)
3093  p.td = Task(p.d)
3094  p.s = Sequence(p.a, p.tc)
3095  m1.toReplaceWith(p.s, Sequence(p.a+p.b, p.td))
3096  self.assertEqual(p.a.wilma.value(),3)
3097  self.assertEqual(p.a.type_(),"YourAnalyzer")
3098  self.assertEqual(hasattr(p,"fred"),False)
3099  self.assertTrue(p.s.dumpPython("") == "cms.Sequence(process.a+process.b, process.td)\n")
3100  p.e =EDProducer("e")
3101  m1.toReplaceWith(p.td, Task(p.e))
3102  self.assertTrue(p.td._collection == OrderedSet([p.e]))
3103  #check toReplaceWith doesn't activate not chosen
3104  m1 = Modifier()
3105  p = Process("test")
3106  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
3107  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
3108  self.assertEqual(p.a.type_(),"MyAnalyzer")
3109  #check toReplaceWith and and/not/or combinations
3110  m1 = Modifier()
3111  m2 = Modifier()
3112  m3 = Modifier()
3113  m4 = Modifier()
3114  p = Process("test", m1, m2)
3115  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
3116  self.assertRaises(TypeError, lambda: (m1 & m2).toReplaceWith(p.a, EDProducer("YourProducer")))
3117  self.assertRaises(TypeError, lambda: (m3 & m4).toReplaceWith(p.a, EDProducer("YourProducer")))
3118  self.assertRaises(TypeError, lambda: (~m3).toReplaceWith(p.a, EDProducer("YourProducer")))
3119  self.assertRaises(TypeError, lambda: (~m1).toReplaceWith(p.a, EDProducer("YourProducer")))
3120  self.assertRaises(TypeError, lambda: (m1 | m3).toReplaceWith(p.a, EDProducer("YourProducer")))
3121  self.assertRaises(TypeError, lambda: (m3 | m4).toReplaceWith(p.a, EDProducer("YourProducer")))
3122  (m1 & m2).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer1"))
3123  self.assertEqual(p.a.type_(), "YourAnalyzer1")
3124  (m1 & m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
3125  self.assertEqual(p.a.type_(), "YourAnalyzer1")
3126  (~m1).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
3127  self.assertEqual(p.a.type_(), "YourAnalyzer1")
3128  (~m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer2"))
3129  self.assertEqual(p.a.type_(), "YourAnalyzer2")
3130  (m1 | m3).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer3"))
3131  self.assertEqual(p.a.type_(), "YourAnalyzer3")
3132  (m3 | m4).toReplaceWith(p.a, EDAnalyzer("YourAnalyzer4"))
3133  self.assertEqual(p.a.type_(), "YourAnalyzer3")
3134  unittest.main()
Config.TestModuleCommand.testModifier
def testModifier(self)
Definition: Config.py:2872
resolutioncreator_cfi.object
object
Definition: resolutioncreator_cfi.py:4
def Config.TestModuleCommand.testOverride (   self)

Definition at line 2436 of file Config.py.

2436  def testOverride(self):
2437  p = Process('test')
2438  a = EDProducer("A", a1=int32(0))
2439  self.assert_(not a.isModified())
2440  a.a1 = 1
2441  self.assert_(a.isModified())
2442  p.a = a
2443  self.assertEqual(p.a.a1.value(), 1)
2444  # try adding an unmodified module.
2445  # should accept it
2446  p.a = EDProducer("A", a1=int32(2))
2447  self.assertEqual(p.a.a1.value(), 2)
2448  # try adding a modified module. Should throw
2449  # no longer, since the same (modified) say, geometry
2450  # could come from more than one cff
2451  b = EDProducer("A", a1=int32(3))
2452  b.a1 = 4
2453  #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
2454  ps1 = PSet(a = int32(1))
2455  ps2 = PSet(a = int32(2))
2456  self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
2457  self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
2458 
Config.TestModuleCommand.testOverride
def testOverride(self)
Definition: Config.py:2436
def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 1557 of file Config.py.

1557  def testParameterizable(self):
1558  p = _Parameterizable()
1559  self.assertEqual(len(p.parameterNames_()),0)
1560  p.a = int32(1)
1561  self.assert_('a' in p.parameterNames_())
1562  self.assertEqual(p.a.value(), 1)
1563  p.a = 10
1564  self.assertEqual(p.a.value(), 10)
1565  p.a = untracked(int32(1))
1566  self.assertEqual(p.a.value(), 1)
1567  self.failIf(p.a.isTracked())
1568  p.a = untracked.int32(1)
1569  self.assertEqual(p.a.value(), 1)
1570  self.failIf(p.a.isTracked())
1571  p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
1572  self.assertEqual(p.foo.value(), 10)
1573  self.assertEqual(p.bar.value(),1.0)
1574  self.failIf(p.bar.isTracked())
1575  self.assertRaises(TypeError,setattr,(p,'c',1))
1576  p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
1577  self.assertEqual(p.a.foo.value(),10)
1578  self.assertEqual(p.a.bar.value(),1.0)
1579  p.b = untracked(PSet(fii = int32(1)))
1580  self.assertEqual(p.b.fii.value(),1)
1581  self.failIf(p.b.isTracked())
1582  #test the fact that values can be shared
1583  v = int32(10)
1584  p=_Parameterizable(a=v)
1585  v.setValue(11)
1586  self.assertEqual(p.a.value(),11)
1587  p.a = 12
1588  self.assertEqual(p.a.value(),12)
1589  self.assertEqual(v.value(),12)
Mixins._Parameterizable
Definition: Mixins.py:125
Config.TestModuleCommand.testParameterizable
def testParameterizable(self)
Definition: Config.py:1557
def Config.TestModuleCommand.testPath (   self)

Definition at line 2235 of file Config.py.

References SequenceTypes.ignore(), and harvestTrackValidationPlots.str.

2235  def testPath(self):
2236  p = Process("test")
2237  p.a = EDAnalyzer("MyAnalyzer")
2238  p.b = EDAnalyzer("YourAnalyzer")
2239  p.c = EDAnalyzer("OurAnalyzer")
2240  path = Path(p.a)
2241  path *= p.b
2242  path += p.c
2243  self.assertEqual(str(path),'a+b+c')
2244  path = Path(p.a*p.b+p.c)
2245  self.assertEqual(str(path),'a+b+c')
2246 # path = Path(p.a)*p.b+p.c #This leads to problems with sequences
2247 # self.assertEqual(str(path),'((a*b)+c)')
2248  path = Path(p.a+ p.b*p.c)
2249  self.assertEqual(str(path),'a+b+c')
2250  path = Path(p.a*(p.b+p.c))
2251  self.assertEqual(str(path),'a+b+c')
2252  path = Path(p.a*(p.b+~p.c))
2253  pathx = Path(p.a*(p.b+ignore(p.c)))
2254  self.assertEqual(str(path),'a+b+~c')
2255  p.es = ESProducer("AnESProducer")
2256  self.assertRaises(TypeError,Path,p.es)
2257 
2258  t = Path()
2259  self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path()\n')
2260 
2261  t = Path(p.a)
2262  self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(process.a)\n')
2263 
2264  t = Path(Task())
2265  self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(cms.Task())\n')
2266 
2267  t = Path(p.a, Task())
2268  self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(process.a, cms.Task())\n')
2269 
2270  p.prod = EDProducer("prodName")
2271  p.t1 = Task(p.prod)
2272  t = Path(p.a, p.t1, Task(), p.t1)
2273  self.assertTrue(t.dumpPython(PrintOptions()) == 'cms.Path(process.a, cms.Task(), process.t1)\n')
2274 
SequenceTypes.ignore
def ignore(seq)
Definition: SequenceTypes.py:494
def Config.TestModuleCommand.testPrefers (   self)

Definition at line 2471 of file Config.py.

2471  def testPrefers(self):
2472  p = Process("Test")
2473  p.add_(ESSource("ForceSource"))
2474  p.juicer = ESProducer("JuicerProducer")
2475  p.prefer("ForceSource")
2476  p.prefer("juicer")
2477  self.assertEqual(p.dumpConfig(),
2478 """process Test = {
2479  es_module juicer = JuicerProducer {
2480  }
2481  es_source = ForceSource {
2482  }
2483  es_prefer = ForceSource {
2484  }
2485  es_prefer juicer = JuicerProducer {
2486  }
2487 }
2488 """)
2489  p.prefer("juicer",fooRcd=vstring("Foo"))
2490  self.assertEqual(p.dumpConfig(),
2491 """process Test = {
2492  es_module juicer = JuicerProducer {
2493  }
2494  es_source = ForceSource {
2495  }
2496  es_prefer = ForceSource {
2497  }
2498  es_prefer juicer = JuicerProducer {
2499  vstring fooRcd = {
2500  'Foo'
2501  }
2502 
2503  }
2504 }
2505 """)
2506  self.assertEqual(p.dumpPython(),
2507 """import FWCore.ParameterSet.Config as cms
2508 
2509 process = cms.Process("Test")
2510 
2511 process.juicer = cms.ESProducer("JuicerProducer")
2512 
2513 
2514 process.ForceSource = cms.ESSource("ForceSource")
2515 
2516 
2517 process.prefer("ForceSource")
2518 
2519 process.prefer("juicer",
2520  fooRcd = cms.vstring('Foo')
2521 )
2522 
2523 """)
2524 
def Config.TestModuleCommand.testProcessDumpPython (   self)

Definition at line 1692 of file Config.py.

1692  def testProcessDumpPython(self):
1693  p = Process("test")
1694  p.a = EDAnalyzer("MyAnalyzer")
1695  p.p = Path(p.a)
1696  p.s = Sequence(p.a)
1697  p.r = Sequence(p.s)
1698  p.p2 = Path(p.s)
1699  p.schedule = Schedule(p.p2,p.p)
1700  d=p.dumpPython()
1701  self.assertEqual(d,
1702 """import FWCore.ParameterSet.Config as cms
1703 
1704 process = cms.Process("test")
1705 
1706 process.a = cms.EDAnalyzer("MyAnalyzer")
1707 
1708 
1709 process.s = cms.Sequence(process.a)
1710 
1711 
1712 process.r = cms.Sequence(process.s)
1713 
1714 
1715 process.p = cms.Path(process.a)
1716 
1717 
1718 process.p2 = cms.Path(process.s)
1719 
1720 
1721 process.schedule = cms.Schedule(*[ process.p2, process.p ])
1722 """)
1723  #Reverse order of 'r' and 's'
1724  p = Process("test")
1725  p.a = EDAnalyzer("MyAnalyzer")
1726  p.p = Path(p.a)
1727  p.r = Sequence(p.a)
1728  p.s = Sequence(p.r)
1729  p.p2 = Path(p.r)
1730  p.schedule = Schedule(p.p2,p.p)
1731  p.b = EDAnalyzer("YourAnalyzer")
1732  d=p.dumpPython()
1733  self.assertEqual(d,
1734 """import FWCore.ParameterSet.Config as cms
1735 
1736 process = cms.Process("test")
1737 
1738 process.a = cms.EDAnalyzer("MyAnalyzer")
1739 
1740 
1741 process.b = cms.EDAnalyzer("YourAnalyzer")
1742 
1743 
1744 process.r = cms.Sequence(process.a)
1745 
1746 
1747 process.s = cms.Sequence(process.r)
1748 
1749 
1750 process.p = cms.Path(process.a)
1751 
1752 
1753 process.p2 = cms.Path(process.r)
1754 
1755 
1756 process.schedule = cms.Schedule(*[ process.p2, process.p ])
1757 """)
Config.TestModuleCommand.testProcessDumpPython
def testProcessDumpPython(self)
Definition: Config.py:1692
def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 1622 of file Config.py.

References resolutioncreator_cfi.object, and harvestTrackValidationPlots.str.

1622  def testProcessExtend(self):
1623  class FromArg(object):
1624  def __init__(self,*arg,**args):
1625  for name in args.iterkeys():
1626  self.__dict__[name]=args[name]
1627 
1628  a=EDAnalyzer("MyAnalyzer")
1629  t=EDAnalyzer("MyAnalyzer")
1630  t.setLabel("foo")
1631  s1 = Sequence(a)
1632  s2 = Sequence(s1)
1633  s3 = Sequence(s2)
1634  d = FromArg(
1635  a=a,
1636  b=Service("Full"),
1637  c=Path(a),
1638  d=s2,
1639  e=s1,
1640  f=s3,
1641  g=Sequence(s1+s2+s3)
1642  )
1643  p = Process("Test")
1644  p.extend(d)
1645  self.assertEqual(p.a.type_(),"MyAnalyzer")
1646  self.assertEqual(p.a.label_(),"a")
1647  self.assertRaises(AttributeError,getattr,p,'b')
1648  self.assertEqual(p.Full.type_(),"Full")
1649  self.assertEqual(str(p.c),'a')
1650  self.assertEqual(str(p.d),'a')
1651 
1652  z1 = FromArg(
1653  a=a,
1654  b=Service("Full"),
1655  c=Path(a),
1656  d=s2,
1657  e=s1,
1658  f=s3,
1659  s4=s3,
1660  g=Sequence(s1+s2+s3)
1661  )
1662 
1663  p1 = Process("Test")
1664  #p1.extend(z1)
1665  self.assertRaises(ValueError, p1.extend, z1)
1666 
1667  z2 = FromArg(
1668  a=a,
1669  b=Service("Full"),
1670  c=Path(a),
1671  d=s2,
1672  e=s1,
1673  f=s3,
1674  aaa=copy.deepcopy(a),
1675  s4=copy.deepcopy(s3),
1676  g=Sequence(s1+s2+s3),
1677  t=t
1678  )
1679  p2 = Process("Test")
1680  p2.extend(z2)
1681  #self.assertRaises(ValueError, p2.extend, z2)
1682  self.assertEqual(p2.s4.label_(),"s4")
1683  #p2.s4.setLabel("foo")
1684  self.assertRaises(ValueError, p2.s4.setLabel, "foo")
1685  p2.s4.setLabel("s4")
1686  p2.s4.setLabel(None)
1687  p2.s4.setLabel("foo")
1688  p2._Process__setObjectLabel(p2.s4, "foo")
1689  p2._Process__setObjectLabel(p2.s4, None)
1690  p2._Process__setObjectLabel(p2.s4, "bar")
1691 
Config.TestModuleCommand.testProcessExtend
def testProcessExtend(self)
Definition: Config.py:1622
resolutioncreator_cfi.object
object
Definition: resolutioncreator_cfi.py:4
def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 1597 of file Config.py.

1597  def testProcessInsertion(self):
1598  p = Process("test")
1599  p.a = EDAnalyzer("MyAnalyzer")
1600  self.assert_( 'a' in p.analyzers_() )
1601  self.assert_( 'a' in p.analyzers)
1602  p.add_(Service("MessageLogger"))
1603  self.assert_('MessageLogger' in p.services_())
1604  self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
1605  p.Tracer = Service("Tracer")
1606  self.assert_('Tracer' in p.services_())
1607  self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
1608  self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
1609  self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
1610  p.out = OutputModule("Outer")
1611  self.assertEqual(p.out.type_(), 'Outer')
1612  self.assert_( 'out' in p.outputModules_() )
1613 
1614  p.geom = ESSource("GeomProd")
1615  self.assert_('geom' in p.es_sources_())
1616  p.add_(ESSource("ConfigDB"))
1617  self.assert_('ConfigDB' in p.es_sources_())
1618 
1619  p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
1620  self.assert_('aliasfoo1' in p.aliases_())
1621 
Config.TestModuleCommand.testProcessInsertion
def testProcessInsertion(self)
Definition: Config.py:1597
def Config.TestModuleCommand.testPrune (   self)

Definition at line 2599 of file Config.py.

2599  def testPrune(self):
2600  p = Process("test")
2601  p.a = EDAnalyzer("MyAnalyzer")
2602  p.b = EDAnalyzer("YourAnalyzer")
2603  p.c = EDAnalyzer("OurAnalyzer")
2604  p.d = EDAnalyzer("OurAnalyzer")
2605  p.s = Sequence(p.d)
2606  p.path1 = Path(p.a)
2607  p.path2 = Path(p.b)
2608  self.assert_(p.schedule is None)
2609  pths = p.paths
2610  keys = pths.keys()
2611  self.assertEqual(pths[keys[0]],p.path1)
2612  self.assertEqual(pths[keys[1]],p.path2)
2613  p.pset1 = PSet(parA = string("pset1"))
2614  p.pset2 = untracked.PSet(parA = string("pset2"))
2615  p.vpset1 = VPSet()
2616  p.vpset2 = untracked.VPSet()
2617  p.prune()
2618  self.assert_(hasattr(p, 'a'))
2619  self.assert_(hasattr(p, 'b'))
2620  self.assert_(not hasattr(p, 'c'))
2621  self.assert_(not hasattr(p, 'd'))
2622  self.assert_(not hasattr(p, 's'))
2623  self.assert_(hasattr(p, 'path1'))
2624  self.assert_(hasattr(p, 'path2'))
2625 # self.assert_(not hasattr(p, 'pset1'))
2626 # self.assert_(hasattr(p, 'pset2'))
2627 # self.assert_(not hasattr(p, 'vpset1'))
2628 # self.assert_(not hasattr(p, 'vpset2'))
2629 
2630  p = Process("test")
2631  p.a = EDAnalyzer("MyAnalyzer")
2632  p.b = EDAnalyzer("YourAnalyzer")
2633  p.c = EDAnalyzer("OurAnalyzer")
2634  p.d = EDAnalyzer("OurAnalyzer")
2635  p.e = EDAnalyzer("OurAnalyzer")
2636  p.s = Sequence(p.d)
2637  p.s2 = Sequence(p.b)
2638  p.s3 = Sequence(p.e)
2639  p.path1 = Path(p.a)
2640  p.path2 = Path(p.b)
2641  p.path3 = Path(p.b+p.s2)
2642  p.path4 = Path(p.b+p.s3)
2643  p.schedule = Schedule(p.path1,p.path2,p.path3)
2644  pths = p.paths
2645  keys = pths.keys()
2646  self.assertEqual(pths[keys[0]],p.path1)
2647  self.assertEqual(pths[keys[1]],p.path2)
2648  p.prune()
2649  self.assert_(hasattr(p, 'a'))
2650  self.assert_(hasattr(p, 'b'))
2651  self.assert_(not hasattr(p, 'c'))
2652  self.assert_(not hasattr(p, 'd'))
2653  self.assert_(not hasattr(p, 'e'))
2654  self.assert_(not hasattr(p, 's'))
2655  self.assert_(hasattr(p, 's2'))
2656  self.assert_(not hasattr(p, 's3'))
2657  self.assert_(hasattr(p, 'path1'))
2658  self.assert_(hasattr(p, 'path2'))
2659  self.assert_(hasattr(p, 'path3'))
2660  self.assert_(not hasattr(p, 'path4'))
2661  #test SequencePlaceholder
2662  p = Process("test")
2663  p.a = EDAnalyzer("MyAnalyzer")
2664  p.b = EDAnalyzer("YourAnalyzer")
2665  p.s = Sequence(SequencePlaceholder("a")+p.b)
2666  p.pth = Path(p.s)
2667  p.prune()
2668  self.assert_(hasattr(p, 'a'))
2669  self.assert_(hasattr(p, 'b'))
2670  self.assert_(hasattr(p, 's'))
2671  self.assert_(hasattr(p, 'pth'))
2672  #test unresolved SequencePlaceholder
2673  p = Process("test")
2674  p.b = EDAnalyzer("YourAnalyzer")
2675  p.s = Sequence(SequencePlaceholder("a")+p.b)
2676  p.pth = Path(p.s)
2677  p.prune(keepUnresolvedSequencePlaceholders=True)
2678  self.assert_(hasattr(p, 'b'))
2679  self.assert_(hasattr(p, 's'))
2680  self.assert_(hasattr(p, 'pth'))
2681  self.assertEqual(p.s.dumpPython(''),'cms.Sequence(cms.SequencePlaceholder("a")+process.b)\n')
def Config.TestModuleCommand.testRefToPSet (   self)

Definition at line 2583 of file Config.py.

2583  def testRefToPSet(self):
2584  proc = Process("test")
2585  proc.top = PSet(a = int32(1))
2586  proc.ref = PSet(refToPSet_ = string("top"))
2587  proc.ref2 = PSet( a = int32(1), b = PSet( refToPSet_ = string("top")))
2588  proc.ref3 = PSet(refToPSet_ = string("ref"))
2589  proc.ref4 = VPSet(PSet(refToPSet_ = string("top")),
2590  PSet(refToPSet_ = string("ref2")))
2591  p = TestMakePSet()
2592  proc.fillProcessDesc(p)
2593  self.assertEqual((True,1),p.values["ref"][1].values["a"])
2594  self.assertEqual((True,1),p.values["ref3"][1].values["a"])
2595  self.assertEqual((True,1),p.values["ref2"][1].values["a"])
2596  self.assertEqual((True,1),p.values["ref2"][1].values["b"][1].values["a"])
2597  self.assertEqual((True,1),p.values["ref4"][1][0].values["a"])
2598  self.assertEqual((True,1),p.values["ref4"][1][1].values["a"])
Config.TestModuleCommand.testRefToPSet
def testRefToPSet(self)
Definition: Config.py:2583
def Config.TestModuleCommand.testSchedule (   self)

Definition at line 2291 of file Config.py.

References list().

2291  def testSchedule(self):
2292  p = Process("test")
2293  p.a = EDAnalyzer("MyAnalyzer")
2294  p.b = EDAnalyzer("YourAnalyzer")
2295  p.c = EDAnalyzer("OurAnalyzer")
2296  p.d = EDAnalyzer("OurAnalyzer")
2297  p.path1 = Path(p.a)
2298  p.path2 = Path(p.b)
2299  p.path3 = Path(p.d)
2300 
2301  s = Schedule(p.path1,p.path2)
2302  self.assertEqual(s[0],p.path1)
2303  self.assertEqual(s[1],p.path2)
2304  p.schedule = s
2305  self.assert_('b' in p.schedule.moduleNames())
2306  self.assert_(hasattr(p, 'b'))
2307  self.assert_(hasattr(p, 'c'))
2308  self.assert_(hasattr(p, 'd'))
2309  self.assert_(hasattr(p, 'path1'))
2310  self.assert_(hasattr(p, 'path2'))
2311  self.assert_(hasattr(p, 'path3'))
2312  p.prune()
2313  self.assert_('b' in p.schedule.moduleNames())
2314  self.assert_(hasattr(p, 'b'))
2315  self.assert_(not hasattr(p, 'c'))
2316  self.assert_(not hasattr(p, 'd'))
2317  self.assert_(hasattr(p, 'path1'))
2318  self.assert_(hasattr(p, 'path2'))
2319  self.assert_(not hasattr(p, 'path3'))
2320 
2321  self.assertTrue(len(p.schedule._tasks) == 0)
2322 
2323  p = Process("test")
2324  p.a = EDAnalyzer("MyAnalyzer")
2325  p.b = EDAnalyzer("YourAnalyzer")
2326  p.c = EDAnalyzer("OurAnalyzer")
2327  p.d = EDAnalyzer("dAnalyzer")
2328  p.e = EDProducer("eProducer")
2329  p.f = EDProducer("fProducer")
2330  p.Tracer = Service("Tracer")
2331  p.path1 = Path(p.a)
2332  p.path2 = Path(p.b)
2333  p.path3 = Path(p.d)
2334  p.task1 = Task(p.e)
2335  p.task2 = Task(p.f, p.Tracer)
2336  s = Schedule(p.path1,p.path2,tasks=[p.task1,p.task2,p.task1])
2337  self.assertEqual(s[0],p.path1)
2338  self.assertEqual(s[1],p.path2)
2339  self.assertTrue(len(s._tasks) == 2)
2340  self.assertTrue(p.task1 in s._tasks)
2341  self.assertTrue(p.task2 in s._tasks)
2342  listOfTasks = list(s._tasks)
2343  self.assertTrue(len(listOfTasks) == 2)
2344  self.assertTrue(p.task1 == listOfTasks[0])
2345  self.assertTrue(p.task2 == listOfTasks[1])
2346  p.schedule = s
2347  self.assert_('b' in p.schedule.moduleNames())
2348 
2349  process2 = Process("test")
2350  process2.a = EDAnalyzer("MyAnalyzer")
2351  process2.e = EDProducer("eProducer")
2352  process2.path1 = Path(process2.a)
2353  process2.task1 = Task(process2.e)
2354  process2.schedule = Schedule(process2.path1,tasks=process2.task1)
2355  listOfTasks = list(process2.schedule._tasks)
2356  self.assertTrue(listOfTasks[0] == process2.task1)
2357 
2358  # test Schedule copy
2359  s2 = s.copy()
2360  self.assertEqual(s2[0],p.path1)
2361  self.assertEqual(s2[1],p.path2)
2362  self.assertTrue(len(s2._tasks) == 2)
2363  self.assertTrue(p.task1 in s2._tasks)
2364  self.assertTrue(p.task2 in s2._tasks)
2365  listOfTasks = list(s2._tasks)
2366  self.assertTrue(len(listOfTasks) == 2)
2367  self.assertTrue(p.task1 == listOfTasks[0])
2368  self.assertTrue(p.task2 == listOfTasks[1])
2369 
2370  names = s.moduleNames()
2371  self.assertTrue(names == set(['a', 'b', 'e', 'Tracer', 'f']))
2372  #adding a path not attached to the Process should cause an exception
2373  p = Process("test")
2374  p.a = EDAnalyzer("MyAnalyzer")
2375  path1 = Path(p.a)
2376  s = Schedule(path1)
2377  self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
2378 
2379  #make sure anonymous sequences work
2380  p = Process("test")
2381  p.a = EDAnalyzer("MyAnalyzer")
2382  p.b = EDAnalyzer("MyOtherAnalyzer")
2383  p.c = EDProducer("MyProd")
2384  path1 = Path(p.c*Sequence(p.a+p.b))
2385  s = Schedule(path1)
2386  self.assert_('a' in s.moduleNames())
2387  self.assert_('b' in s.moduleNames())
2388  self.assert_('c' in s.moduleNames())
2389  p.path1 = path1
2390  p.schedule = s
2391  p.prune()
2392  self.assert_('a' in s.moduleNames())
2393  self.assert_('b' in s.moduleNames())
2394  self.assert_('c' in s.moduleNames())
2395 
Config.TestModuleCommand.testSchedule
def testSchedule(self)
Definition: Config.py:2291
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
def Config.TestModuleCommand.testSecSource (   self)

Definition at line 1947 of file Config.py.

References python.rootplot.root2matplotlib.replace().

1947  def testSecSource(self):
1948  p = Process('test')
1949  p.a = SecSource("MySecSource")
1950  self.assertEqual(p.dumpPython().replace('\n',''),'import FWCore.ParameterSet.Config as cmsprocess = cms.Process("test")process.a = cms.SecSource("MySecSource")')
1951 
python.rootplot.root2matplotlib.replace
def replace(string, replacements)
Definition: root2matplotlib.py:443
Config.TestModuleCommand.testSecSource
def testSecSource(self)
Definition: Config.py:1947
def Config.TestModuleCommand.testSequence (   self)

Definition at line 1997 of file Config.py.

References harvestTrackValidationPlots.str.

1997  def testSequence(self):
1998  p = Process('test')
1999  p.a = EDAnalyzer("MyAnalyzer")
2000  p.b = EDAnalyzer("YourAnalyzer")
2001  p.c = EDAnalyzer("OurAnalyzer")
2002  p.s = Sequence(p.a*p.b)
2003  self.assertEqual(str(p.s),'a+b')
2004  self.assertEqual(p.s.label_(),'s')
2005  path = Path(p.c+p.s)
2006  self.assertEqual(str(path),'c+a+b')
2007  p._validateSequence(path, 'p1')
2008  notInProcess = EDAnalyzer('NotInProcess')
2009  p2 = Path(p.c+p.s*notInProcess)
2010  self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
2011 
Config.TestModuleCommand.testSequence
def testSequence(self)
Definition: Config.py:1997
def Config.TestModuleCommand.testSequence2 (   self)

Definition at line 2012 of file Config.py.

2012  def testSequence2(self):
2013  p = Process('test')
2014  p.a = EDAnalyzer("MyAnalyzer")
2015  p.b = EDAnalyzer("YourAnalyzer")
2016  p.c = EDAnalyzer("OurAnalyzer")
2017  testseq = Sequence(p.a*p.b)
2018  p.s = testseq
2019  #p.y = testseq
2020  self.assertRaises(ValueError, p.__setattr__, "y", testseq)
2021 
Config.TestModuleCommand.testSequence2
def testSequence2(self)
Definition: Config.py:2012
def Config.TestModuleCommand.testServiceInProcess (   self)

Definition at line 2022 of file Config.py.

2022  def testServiceInProcess(self):
2023  service = Service("d")
2024  self.assertFalse(service._inProcess)
2025  process = Process("test")
2026  process.d = service
2027  self.assertTrue(service._inProcess)
2028  service2 = Service("d")
2029  process.d = service2
2030  self.assertFalse(service._inProcess)
2031  self.assertTrue(service2._inProcess)
2032  del process.d
2033  self.assertFalse(service2._inProcess)
2034 
Config.TestModuleCommand.testServiceInProcess
def testServiceInProcess(self)
Definition: Config.py:2022
def Config.TestModuleCommand.testSubProcess (   self)

Definition at line 2543 of file Config.py.

References cond.hash, and harvestTrackValidationPlots.str.

2543  def testSubProcess(self):
2544  process = Process("Parent")
2545  subProcess = Process("Child")
2546  subProcess.a = EDProducer("A")
2547  subProcess.p = Path(subProcess.a)
2548  subProcess.add_(Service("Foo"))
2549  process.addSubProcess(SubProcess(subProcess))
2550  d = process.dumpPython()
2551  equalD ="""import FWCore.ParameterSet.Config as cms
2552 
2553 process = cms.Process("Parent")
2554 
2555 parentProcess = process
2556 import FWCore.ParameterSet.Config as cms
2557 
2558 process = cms.Process("Child")
2559 
2560 process.a = cms.EDProducer("A")
2561 
2562 
2563 process.Foo = cms.Service("Foo")
2564 
2565 
2566 process.p = cms.Path(process.a)
2567 
2568 
2569 childProcess = process
2570 process = parentProcess
2571 process.addSubProcess(cms.SubProcess(process = childProcess, SelectEvents = cms.untracked.PSet(
2572 
2573 ), outputCommands = cms.untracked.vstring()))
2574 
2575 """
2576  equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcesses_()[0])))
2577  self.assertEqual(d,equalD)
2578  p = TestMakePSet()
2579  process.fillProcessDesc(p)
2580  self.assertEqual((True,['a']),p.values["subProcesses"][1][0].values["process"][1].values['@all_modules'])
2581  self.assertEqual((True,['p']),p.values["subProcesses"][1][0].values["process"][1].values['@paths'])
2582  self.assertEqual({'@service_type':(True,'Foo')}, p.values["subProcesses"][1][0].values["process"][1].values["services"][1][0].values)
Config.TestModuleCommand.testSubProcess
def testSubProcess(self)
Definition: Config.py:2543
def Config.TestModuleCommand.testTask (   self)

Definition at line 2035 of file Config.py.

References list().

2035  def testTask(self):
2036 
2037  # create some objects to use in tests
2038  edanalyzer = EDAnalyzer("a")
2039  edproducer = EDProducer("b")
2040  edproducer2 = EDProducer("b2")
2041  edproducer3 = EDProducer("b3")
2042  edproducer4 = EDProducer("b4")
2043  edproducer8 = EDProducer("b8")
2044  edproducer9 = EDProducer("b9")
2045  edfilter = EDFilter("c")
2046  service = Service("d")
2047  service3 = Service("d")
2048  essource = ESSource("e")
2049  esproducer = ESProducer("f")
2050  testTask2 = Task()
2051 
2052  # test adding things to Tasks
2053  testTask1 = Task(edproducer, edfilter)
2054  self.assertRaises(RuntimeError, testTask1.add, edanalyzer)
2055  testTask1.add(essource, service)
2056  testTask1.add(essource, esproducer)
2057  testTask1.add(testTask2)
2058  coll = testTask1._collection
2059  self.assertTrue(edproducer in coll)
2060  self.assertTrue(edfilter in coll)
2061  self.assertTrue(service in coll)
2062  self.assertTrue(essource in coll)
2063  self.assertTrue(esproducer in coll)
2064  self.assertTrue(testTask2 in coll)
2065  self.assertTrue(len(coll) == 6)
2066  self.assertTrue(len(testTask2._collection) == 0)
2067 
2068  taskContents = []
2069  for i in testTask1:
2070  taskContents.append(i)
2071  self.assertTrue(taskContents == [edproducer, edfilter, essource, service, esproducer, testTask2])
2072 
2073  # test attaching Task to Process
2074  process = Process("test")
2075 
2076  process.mproducer = edproducer
2077  process.mproducer2 = edproducer2
2078  process.mfilter = edfilter
2079  process.messource = essource
2080  process.mesproducer = esproducer
2081  process.d = service
2082 
2083  testTask3 = Task(edproducer, edproducer2)
2084  testTask1.add(testTask3)
2085  process.myTask1 = testTask1
2086 
2087  # test the validation that occurs when attaching a Task to a Process
2088  # first a case that passes, then one the fails on an EDProducer
2089  # then one that fails on a service
2090  l = set()
2091  visitor = NodeNameVisitor(l)
2092  testTask1.visit(visitor)
2093  self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
2094  l2 = testTask1.moduleNames
2095  self.assertTrue(l == set(['mesproducer', 'mproducer', 'mproducer2', 'mfilter', 'd', 'messource']))
2096 
2097  testTask4 = Task(edproducer3)
2098  l.clear()
2099  self.assertRaises(RuntimeError, testTask4.visit, visitor)
2100  try:
2101  process.myTask4 = testTask4
2102  self.assertTrue(False)
2103  except RuntimeError:
2104  pass
2105 
2106  testTask5 = Task(service3)
2107  l.clear()
2108  self.assertRaises(RuntimeError, testTask5.visit, visitor)
2109  try:
2110  process.myTask5 = testTask5
2111  self.assertTrue(False)
2112  except RuntimeError:
2113  pass
2114 
2115  process.d = service3
2116  process.myTask5 = testTask5
2117 
2118  # test placement into the Process and the tasks property
2119  expectedDict = { 'myTask1' : testTask1, 'myTask5' : testTask5 }
2120  expectedFixedDict = DictTypes.FixedKeysDict(expectedDict);
2121  self.assertTrue(process.tasks == expectedFixedDict)
2122  self.assertTrue(process.tasks['myTask1'] == testTask1)
2123  self.assertTrue(process.myTask1 == testTask1)
2124 
2125  # test replacing an EDProducer in a Task when calling __settattr__
2126  # for the EDProducer on the Process.
2127  process.mproducer2 = edproducer4
2128  process.d = service
2129  l = list()
2130  visitor1 = ModuleNodeVisitor(l)
2131  testTask1.visit(visitor1)
2132  l.sort()
2133  expectedList = [edproducer,essource,esproducer,service,edfilter,edproducer,edproducer4]
2134  expectedList.sort()
2135  self.assertTrue(expectedList == l)
2136 
2137  process.myTask6 = Task()
2138  process.myTask7 = Task()
2139  process.mproducer8 = edproducer8
2140  process.myTask8 = Task(process.mproducer8)
2141  process.myTask6.add(process.myTask7)
2142  process.myTask7.add(process.myTask8)
2143  process.myTask1.add(process.myTask6)
2144  process.myTask8.add(process.myTask5)
2145 
2146  testDict = process._itemsInDependencyOrder(process.tasks)
2147  expectedLabels = ["myTask5", "myTask8", "myTask7", "myTask6", "myTask1"]
2148  expectedTasks = [process.myTask5, process.myTask8, process.myTask7, process.myTask6, process.myTask1]
2149  index = 0
2150  for testLabel, testTask in testDict.items():
2151  self.assertTrue(testLabel == expectedLabels[index])
2152  self.assertTrue(testTask == expectedTasks[index])
2153  index += 1
2154 
2155  pythonDump = testTask1.dumpPython(PrintOptions())
2156 
2157 
2158  expectedPythonDump = 'cms.Task(process.d, process.mesproducer, process.messource, process.mfilter, process.mproducer, process.mproducer2, process.myTask6)\n'
2159  self.assertTrue(pythonDump == expectedPythonDump)
2160 
2161  process.myTask5 = Task()
2162  process.myTask100 = Task()
2163  process.mproducer9 = edproducer9
2164  sequence1 = Sequence(process.mproducer8, process.myTask1, process.myTask5, testTask2, testTask3)
2165  sequence2 = Sequence(process.mproducer8 + process.mproducer9)
2166  process.sequence3 = Sequence((process.mproducer8 + process.mfilter))
2167  sequence4 = Sequence()
2168  process.path1 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+sequence4)
2169  process.path1.associate(process.myTask1, process.myTask5, testTask2, testTask3)
2170  process.path11 = Path(process.mproducer+process.mproducer8+sequence1+sequence2+process.sequence3+ sequence4,process.myTask1, process.myTask5, testTask2, testTask3, process.myTask100)
2171  process.path2 = Path(process.mproducer)
2172  process.path3 = Path(process.mproducer9+process.mproducer8,testTask2)
2173 
2174  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')
2175 
2176  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')
2177 
2178  # test NodeNameVisitor and moduleNames
2179  l = set()
2180  nameVisitor = NodeNameVisitor(l)
2181  process.path1.visit(nameVisitor)
2182  self.assertTrue(l == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
2183  self.assertTrue(process.path1.moduleNames() == set(['mproducer', 'd', 'mesproducer', None, 'mproducer9', 'mproducer8', 'messource', 'mproducer2', 'mfilter']))
2184 
2185  # test copy
2186  process.mproducer10 = EDProducer("b10")
2187  process.path21 = process.path11.copy()
2188  process.path21.replace(process.mproducer, process.mproducer10)
2189 
2190  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')
2191 
2192  # Some peculiarities of the way things work show up here. dumpPython sorts tasks and
2193  # removes duplication at the level of strings. The Task and Sequence objects themselves
2194  # remove duplicate tasks in their contents if the instances are the same (exact same python
2195  # object id which is not the same as the string representation being the same).
2196  # Also note that the mutating visitor replaces sequences and tasks that have
2197  # modified contents with their modified contents, it does not modify the sequence
2198  # or task itself.
2199  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')
2200 
2201  process.path22 = process.path21.copyAndExclude([process.d, process.mesproducer, process.mfilter])
2202  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')
2203 
2204  process.path23 = process.path22.copyAndExclude([process.messource, process.mproducer10])
2205  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')
2206 
2207  process.a = EDAnalyzer("MyAnalyzer")
2208  process.b = OutputModule("MyOutputModule")
2209  process.c = EDFilter("MyFilter")
2210  process.d = EDProducer("MyProducer")
2211  process.e = ESProducer("MyESProducer")
2212  process.f = ESSource("MyESSource")
2213  process.g = ESProducer("g")
2214  process.path24 = Path(process.a+process.b+process.c+process.d)
2215  process.path25 = process.path24.copyAndExclude([process.a,process.b,process.c])
2216  self.assertTrue(process.path25.dumpPython(None) == 'cms.Path(process.d)\n')
2217  #print process.path3
2218  #print process.dumpPython()
2219 
2220  process.path200 = EndPath(Sequence(process.c,Task(process.e)))
2221  process.path200.replace(process.c,process.b)
2222  process.path200.replace(process.e,process.f)
2223  self.assertEqual(process.path200.dumpPython(None), "cms.EndPath(process.b, cms.Task(process.f))\n")
2224  process.path200.replace(process.b,process.c)
2225  process.path200.replace(process.f,process.e)
2226  self.assertEqual(process.path200.dumpPython(None), "cms.EndPath(process.c, cms.Task(process.e))\n")
2227  process.path200.replace(process.c,process.a)
2228  process.path200.replace(process.e,process.g)
2229  self.assertEqual(process.path200.dumpPython(None), "cms.EndPath(process.a, cms.Task(process.g))\n")
2230  process.path200.replace(process.a,process.c)
2231  process.path200.replace(process.g,process.e)
2232  self.assertEqual(process.path200.dumpPython(None), "cms.EndPath(process.c, cms.Task(process.e))\n")
2233 
2234 
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
def Config.TestModuleCommand.testTaskPlaceholder (   self)

Definition at line 2682 of file Config.py.

2682  def testTaskPlaceholder(self):
2683  p = Process("test")
2684  p.a = EDProducer("ma")
2685  p.b = EDAnalyzer("mb")
2686  p.t1 = Task(TaskPlaceholder("c"))
2687  p.t2 = Task(p.a, TaskPlaceholder("d"), p.t1)
2688  p.t3 = Task(TaskPlaceholder("e"))
2689  p.path1 = Path(p.b, p.t2, p.t3)
2690  p.t5 = Task(p.a, TaskPlaceholder("g"), TaskPlaceholder("t4"))
2691  p.t4 = Task(TaskPlaceholder("f"))
2692  p.endpath1 = EndPath(p.b, p.t5)
2693  p.t6 = Task(TaskPlaceholder("h"))
2694  p.t7 = Task(p.a, TaskPlaceholder("i"), p.t6)
2695  p.t8 = Task(TaskPlaceholder("j"))
2696  p.schedule = Schedule(p.path1, p.endpath1,tasks=[p.t7,p.t8])
2697  p.c = EDProducer("mc")
2698  p.d = EDProducer("md")
2699  p.e = EDProducer("me")
2700  p.f = EDProducer("mf")
2701  p.g = EDProducer("mg")
2702  p.h = EDProducer("mh")
2703  p.i = EDProducer("mi")
2704  p.j = EDProducer("mj")
2705  self.assertEqual(p.dumpPython(),
2706 """import FWCore.ParameterSet.Config as cms
2707 
2708 process = cms.Process("test")
2709 
2710 process.a = cms.EDProducer("ma")
2711 
2712 
2713 process.c = cms.EDProducer("mc")
2714 
2715 
2716 process.d = cms.EDProducer("md")
2717 
2718 
2719 process.e = cms.EDProducer("me")
2720 
2721 
2722 process.f = cms.EDProducer("mf")
2723 
2724 
2725 process.g = cms.EDProducer("mg")
2726 
2727 
2728 process.h = cms.EDProducer("mh")
2729 
2730 
2731 process.i = cms.EDProducer("mi")
2732 
2733 
2734 process.j = cms.EDProducer("mj")
2735 
2736 
2737 process.b = cms.EDAnalyzer("mb")
2738 
2739 
2740 process.t8 = cms.Task(cms.TaskPlaceholder("j"))
2741 
2742 
2743 process.t6 = cms.Task(cms.TaskPlaceholder("h"))
2744 
2745 
2746 process.t7 = cms.Task(cms.TaskPlaceholder("i"), process.a, process.t6)
2747 
2748 
2749 process.t4 = cms.Task(cms.TaskPlaceholder("f"))
2750 
2751 
2752 process.t5 = cms.Task(cms.TaskPlaceholder("g"), cms.TaskPlaceholder("t4"), process.a)
2753 
2754 
2755 process.t3 = cms.Task(cms.TaskPlaceholder("e"))
2756 
2757 
2758 process.t1 = cms.Task(cms.TaskPlaceholder("c"))
2759 
2760 
2761 process.t2 = cms.Task(cms.TaskPlaceholder("d"), process.a, process.t1)
2762 
2763 
2764 process.path1 = cms.Path(process.b, process.t2, process.t3)
2765 
2766 
2767 process.endpath1 = cms.EndPath(process.b, process.t5)
2768 
2769 
2770 process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])
2771 """)
2772  p.resolve()
2773  self.assertEqual(p.dumpPython(),
2774 """import FWCore.ParameterSet.Config as cms
2775 
2776 process = cms.Process("test")
2777 
2778 process.a = cms.EDProducer("ma")
2779 
2780 
2781 process.c = cms.EDProducer("mc")
2782 
2783 
2784 process.d = cms.EDProducer("md")
2785 
2786 
2787 process.e = cms.EDProducer("me")
2788 
2789 
2790 process.f = cms.EDProducer("mf")
2791 
2792 
2793 process.g = cms.EDProducer("mg")
2794 
2795 
2796 process.h = cms.EDProducer("mh")
2797 
2798 
2799 process.i = cms.EDProducer("mi")
2800 
2801 
2802 process.j = cms.EDProducer("mj")
2803 
2804 
2805 process.b = cms.EDAnalyzer("mb")
2806 
2807 
2808 process.t8 = cms.Task(process.j)
2809 
2810 
2811 process.t6 = cms.Task(process.h)
2812 
2813 
2814 process.t7 = cms.Task(process.a, process.i, process.t6)
2815 
2816 
2817 process.t4 = cms.Task(process.f)
2818 
2819 
2820 process.t5 = cms.Task(process.a, process.g, process.t4)
2821 
2822 
2823 process.t3 = cms.Task(process.e)
2824 
2825 
2826 process.t1 = cms.Task(process.c)
2827 
2828 
2829 process.t2 = cms.Task(process.a, process.d, process.t1)
2830 
2831 
2832 process.path1 = cms.Path(process.b, process.t2, process.t3)
2833 
2834 
2835 process.endpath1 = cms.EndPath(process.b, process.t5)
2836 
2837 
2838 process.schedule = cms.Schedule(*[ process.path1, process.endpath1 ], tasks=[process.t7, process.t8])
2839 """)
2840 
Config.TestModuleCommand.testTaskPlaceholder
def testTaskPlaceholder(self)
Definition: Config.py:2682
def Config.TestModuleCommand.testTypedParameterizable (   self)

Definition at line 1590 of file Config.py.

1590  def testTypedParameterizable(self):
1591  p = _TypedParameterizable("blah", b=int32(1))
1592  #see if copy works deeply
1593  other = p.copy()
1594  other.b = 2
1595  self.assertNotEqual(p.b,other.b)
1596 
Config.TestModuleCommand.testTypedParameterizable
def testTypedParameterizable(self)
Definition: Config.py:1590
Mixins._TypedParameterizable
Definition: Mixins.py:323
def Config.TestModuleCommand.testUsing (   self)

Definition at line 2429 of file Config.py.

2429  def testUsing(self):
2430  p = Process('test')
2431  p.block = PSet(a = int32(1))
2432  p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
2433  self.assertEqual(p.modu.a.value(),1)
2434  self.assertEqual(p.modu.b.value(),2)
2435 

Member Data Documentation

Config.TestModuleCommand.a

Definition at line 2971 of file Config.py.

Config.TestModuleCommand.proc_mod_

Definition at line 2968 of file Config.py.

Generated for CMSSW Reference Manual by doxygen 1.8.11