Config::TestModuleCommand Class Reference

List of all members.

Public Member Functions
def	setUp
def	testCloneSequence
def	testExamples
def	testFreeze
def	testGlobalReplace
def	testImplicitSchedule
def	testOverride
def	testParameterizable
def	testPath
def	testPrefers
def	testProcessDumpPython
def	testProcessExtend
def	testProcessInsertion
def	testPrune
def	testSchedule
def	testSecSource
def	testSequence
def	testSequence2
def	testSubProcess
def	testTypedParameterizable
def	testUsing
Static Public Attributes
tuple	d = p.dumpPython()
tuple	p = Process("test")
tuple	s = Sequence(p.a)

---

Detailed Description

Definition at line 1076 of file Config.py.

---

Member Function Documentation

def Config::TestModuleCommand::setUp

(

self

)

Nothing to do 

Definition at line 1077 of file Config.py.

01078                        :
01079             """Nothing to do """
            None

def Config::TestModuleCommand::testCloneSequence

(

self

)

Definition at line 1372 of file Config.py.

                                   :
            p = Process("test")
            a = EDAnalyzer("MyAnalyzer")
            p.a = a
            a.setLabel("a")
            b = EDAnalyzer("YOurAnalyzer")
            p.b = b
            b.setLabel("b")
            path = Path(a * b)
            p.path = Path(p.a*p.b)
            lookuptable = {id(a): p.a, id(b): p.b}
            #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
            #lookuptable = p._cloneToObjectDict
            #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
            self.assertEqual(str(path),str(p.path))

def Config::TestModuleCommand::testExamples

(

self

)

Definition at line 1505 of file Config.py.

                              :
            p = Process("Test")
            p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
            p.foos = EDProducer("FooProducer")
            p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
            p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
            p.bars.foos = 'Foosball'
            self.assertEqual(p.bars.foos, InputTag('Foosball'))
            p.p = Path(p.foos*p.bars)
            p.e = EndPath(p.out)
            p.add_(Service("MessageLogger"))

def Config::TestModuleCommand::testFreeze

(

self

)

Definition at line 1571 of file Config.py.

01572                             :
01573             process = Process("Freeze")
01574             m = EDProducer("M", p=PSet(i = int32(1)))
01575             m.p.i = 2
01576             process.m = m
01577             # should be frozen
01578             #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
01579             #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
01580             #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
01581             #self.assertRaises(ValueError, setattr, m, 'j', 1)
01582             # But OK to change through the process
01583             process.m.p.i = 4
01584             self.assertEqual(process.m.p.i.value(), 4)
01585             process.m.p = PSet(j=int32(1))
01586             # should work to clone it, though
01587             m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
01588             m2.p.i = 6
            m2.j = 8

def Config::TestModuleCommand::testGlobalReplace

(

self

)

Definition at line 1315 of file Config.py.

                                   :
            p = Process('test')
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.s = Sequence(p.a*p.b)
            p.p = Path(p.c+p.s+p.a)
            new = EDAnalyzer("NewAnalyzer")
            p.globalReplace("a",new)

def Config::TestModuleCommand::testImplicitSchedule

(

self

)

Definition at line 1442 of file Config.py.

                                      :
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.path1 = Path(p.a)
            p.path2 = Path(p.b)
            self.assert_(p.schedule is None)
            pths = p.paths
            keys = pths.keys()
            self.assertEqual(pths[keys[0]],p.path1)
            self.assertEqual(pths[keys[1]],p.path2)
            p.prune()
            self.assert_(hasattr(p, 'a'))
            self.assert_(hasattr(p, 'b'))
            self.assert_(not hasattr(p, 'c'))
            self.assert_(hasattr(p, 'path1'))
            self.assert_(hasattr(p, 'path2'))


            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.path2 = Path(p.b)
            p.path1 = Path(p.a)
            self.assert_(p.schedule is None)
            pths = p.paths
            keys = pths.keys()
            self.assertEqual(pths[keys[1]],p.path1)
            self.assertEqual(pths[keys[0]],p.path2)

def Config::TestModuleCommand::testOverride

(

self

)

Definition at line 1482 of file Config.py.

                              :
            p = Process('test')
            a = EDProducer("A", a1=int32(0))
            self.assert_(not a.isModified())
            a.a1 = 1
            self.assert_(a.isModified())
            p.a = a
            self.assertEqual(p.a.a1.value(), 1)
            # try adding an unmodified module.
            # should accept it
            p.a = EDProducer("A", a1=int32(2))
            self.assertEqual(p.a.a1.value(), 2)
            # try adding a modified module.  Should throw
            # no longer, since the same (modified) say, geometry
            # could come from more than one cff
            b = EDProducer("A", a1=int32(3))
            b.a1 = 4
            #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
            ps1 = PSet(a = int32(1))
            ps2 = PSet(a = int32(2))
            self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
            self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))

def Config::TestModuleCommand::testParameterizable

(

self

)

Definition at line 1080 of file Config.py.

01081                                      :
01082             p = _Parameterizable()
01083             self.assertEqual(len(p.parameterNames_()),0)
01084             p.a = int32(1)
01085             self.assert_('a' in p.parameterNames_())
01086             self.assertEqual(p.a.value(), 1)
01087             p.a = 10
01088             self.assertEqual(p.a.value(), 10)
01089             p.a = untracked(int32(1))
01090             self.assertEqual(p.a.value(), 1)
01091             self.failIf(p.a.isTracked())
01092             p.a = untracked.int32(1)
01093             self.assertEqual(p.a.value(), 1)
01094             self.failIf(p.a.isTracked())
01095             p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
01096             self.assertEqual(p.foo.value(), 10)
01097             self.assertEqual(p.bar.value(),1.0)
01098             self.failIf(p.bar.isTracked())
01099             self.assertRaises(TypeError,setattr,(p,'c',1))
01100             p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
01101             self.assertEqual(p.a.foo.value(),10)
01102             self.assertEqual(p.a.bar.value(),1.0)
01103             p.b = untracked(PSet(fii = int32(1)))
01104             self.assertEqual(p.b.fii.value(),1)
01105             self.failIf(p.b.isTracked())
01106             #test the fact that values can be shared
01107             v = int32(10)
01108             p=_Parameterizable(a=v)
01109             v.setValue(11)
01110             self.assertEqual(p.a.value(),11)
01111             p.a = 12
01112             self.assertEqual(p.a.value(),12)
            self.assertEqual(v.value(),12)

def Config::TestModuleCommand::testPath

(

self

)

Definition at line 1350 of file Config.py.

                          :
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            path = Path(p.a)
            path *= p.b
            path += p.c
            self.assertEqual(str(path),'a+b+c')
            path = Path(p.a*p.b+p.c)
            self.assertEqual(str(path),'a+b+c')
#            path = Path(p.a)*p.b+p.c #This leads to problems with sequences
#            self.assertEqual(str(path),'((a*b)+c)')
            path = Path(p.a+ p.b*p.c)
            self.assertEqual(str(path),'a+b+c')
            path = Path(p.a*(p.b+p.c))
            self.assertEqual(str(path),'a+b+c')
            path = Path(p.a*(p.b+~p.c))
            self.assertEqual(str(path),'a+b+~c')
            p.es = ESProducer("AnESProducer")
            self.assertRaises(TypeError,Path,p.es)

def Config::TestModuleCommand::testPrefers

(

self

)

Definition at line 1517 of file Config.py.

                             :
            p = Process("Test")
            p.add_(ESSource("ForceSource"))
            p.juicer = ESProducer("JuicerProducer")
            p.prefer("ForceSource")
            p.prefer("juicer")
            self.assertEqual(p.dumpConfig(),
"""process Test = {
    es_module juicer = JuicerProducer { 
    }
    es_source  = ForceSource { 
    }
    es_prefer  = ForceSource { 
    }
    es_prefer juicer = JuicerProducer { 
    }
}
""")
            p.prefer("juicer",fooRcd=vstring("Foo"))
            self.assertEqual(p.dumpConfig(),
"""process Test = {
    es_module juicer = JuicerProducer { 
    }
    es_source  = ForceSource { 
    }
    es_prefer  = ForceSource { 
    }
    es_prefer juicer = JuicerProducer { 
        vstring fooRcd = {
            'Foo'
        }

    }
}
""")
            self.assertEqual(p.dumpPython(),
"""import FWCore.ParameterSet.Config as cms

process = cms.Process("Test")

process.juicer = cms.ESProducer("JuicerProducer")


process.ForceSource = cms.ESSource("ForceSource")


process.prefer("ForceSource")

process.prefer("juicer",
    fooRcd = cms.vstring('Foo')
)

""")

def Config::TestModuleCommand::testProcessDumpPython

(

self

)

Definition at line 1215 of file Config.py.

01216                                        :
01217             p = Process("test")
01218             p.a = EDAnalyzer("MyAnalyzer")
01219             p.p = Path(p.a)
01220             p.s = Sequence(p.a)
01221             p.r = Sequence(p.s)
01222             p.p2 = Path(p.s)
01223             p.schedule = Schedule(p.p2,p.p)
01224             d=p.dumpPython()
01225             self.assertEqual(d,
01226 """import FWCore.ParameterSet.Config as cms
01227 
01228 process = cms.Process("test")
01229 
01230 process.a = cms.EDAnalyzer("MyAnalyzer")
01231 
01232 
01233 process.s = cms.Sequence(process.a)
01234 
01235 
01236 process.r = cms.Sequence(process.s)
01237 
01238 
01239 process.p = cms.Path(process.a)
01240 
01241 
01242 process.p2 = cms.Path(process.s)
01243 
01244 
01245 process.schedule = cms.Schedule(*[ process.p2, process.p ])
01246 """)
01247             #Reverse order of 'r' and 's'
01248             p = Process("test")
01249             p.a = EDAnalyzer("MyAnalyzer")
01250             p.p = Path(p.a)
01251             p.r = Sequence(p.a)
01252             p.s = Sequence(p.r)
01253             p.p2 = Path(p.r)
01254             p.schedule = Schedule(p.p2,p.p)
01255             p.b = EDAnalyzer("YourAnalyzer")
01256             d=p.dumpPython()
01257             self.assertEqual(d,
01258 """import FWCore.ParameterSet.Config as cms
01259 
01260 process = cms.Process("test")
01261 
01262 process.a = cms.EDAnalyzer("MyAnalyzer")
01263 
01264 
01265 process.b = cms.EDAnalyzer("YourAnalyzer")
01266 
01267 
01268 process.r = cms.Sequence(process.a)
01269 
01270 
01271 process.s = cms.Sequence(process.r)
01272 
01273 
01274 process.p = cms.Path(process.a)
01275 
01276 
01277 process.p2 = cms.Path(process.r)
01278 
01279 
01280 process.schedule = cms.Schedule(*[ process.p2, process.p ])
""")

def Config::TestModuleCommand::testProcessExtend

(

self

)

Definition at line 1145 of file Config.py.

                                   :
            class FromArg(object):
                def __init__(self,*arg,**args):
                    for name in args.iterkeys():
                        self.__dict__[name]=args[name]

            a=EDAnalyzer("MyAnalyzer")
            t=EDAnalyzer("MyAnalyzer")
            t.setLabel("foo")
            s1 = Sequence(a)
            s2 = Sequence(s1)
            s3 = Sequence(s2)
            d = FromArg(
                    a=a,
                    b=Service("Full"),
                    c=Path(a),
                    d=s2,
                    e=s1,
                    f=s3,
                    g=Sequence(s1+s2+s3)
                )
            p = Process("Test")
            p.extend(d)
            self.assertEqual(p.a.type_(),"MyAnalyzer")
            self.assertEqual(p.a.label_(),"a")
            self.assertRaises(AttributeError,getattr,p,'b')
            self.assertEqual(p.Full.type_(),"Full")
            self.assertEqual(str(p.c),'a')
            self.assertEqual(str(p.d),'a')

            z1 = FromArg(
                    a=a,
                    b=Service("Full"),
                    c=Path(a),
                    d=s2,
                    e=s1,
                    f=s3,
                    s4=s3,
                    g=Sequence(s1+s2+s3)
                 )
            
            p1 = Process("Test")
            #p1.extend(z1)
            self.assertRaises(ValueError, p1.extend, z1)

            z2 = FromArg(
                    a=a,
                    b=Service("Full"),
                    c=Path(a),
                    d=s2,
                    e=s1,
                    f=s3,
                    aaa=copy.deepcopy(a),
                    s4=copy.deepcopy(s3),
                    g=Sequence(s1+s2+s3),
                    t=t
                )
            p2 = Process("Test")
            p2.extend(z2)
            #self.assertRaises(ValueError, p2.extend, z2)
            self.assertEqual(p2.s4.label_(),"s4")
            #p2.s4.setLabel("foo")
            self.assertRaises(ValueError, p2.s4.setLabel, "foo")
            p2.s4.setLabel("s4")
            p2.s4.setLabel(None)
            p2.s4.setLabel("foo")
            p2._Process__setObjectLabel(p2.s4, "foo")
            p2._Process__setObjectLabel(p2.s4, None)
            p2._Process__setObjectLabel(p2.s4, "bar")

def Config::TestModuleCommand::testProcessInsertion

(

self

)

Definition at line 1120 of file Config.py.

                                      :
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            self.assert_( 'a' in p.analyzers_() )
            self.assert_( 'a' in p.analyzers)
            p.add_(Service("MessageLogger"))
            self.assert_('MessageLogger' in p.services_())
            self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
            p.Tracer = Service("Tracer")
            self.assert_('Tracer' in p.services_())
            self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
            self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
            self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
            p.out = OutputModule("Outer")
            self.assertEqual(p.out.type_(), 'Outer')
            self.assert_( 'out' in p.outputModules_() )

            p.geom = ESSource("GeomProd")
            self.assert_('geom' in p.es_sources_())
            p.add_(ESSource("ConfigDB"))
            self.assert_('ConfigDB' in p.es_sources_())

            p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
            self.assert_('aliasfoo1' in p.aliases_())

def Config::TestModuleCommand::testPrune

(

self

)

Definition at line 1628 of file Config.py.

01629                            :
01630             p = Process("test")
01631             p.a = EDAnalyzer("MyAnalyzer")
01632             p.b = EDAnalyzer("YourAnalyzer")
01633             p.c = EDAnalyzer("OurAnalyzer")
01634             p.d = EDAnalyzer("OurAnalyzer")
01635             p.s = Sequence(p.d)
01636             p.path1 = Path(p.a)
01637             p.path2 = Path(p.b)
01638             self.assert_(p.schedule is None)
01639             pths = p.paths
01640             keys = pths.keys()
01641             self.assertEqual(pths[keys[0]],p.path1)
01642             self.assertEqual(pths[keys[1]],p.path2)
01643             p.pset1 = PSet(parA = string("pset1"))
01644             p.pset2 = untracked.PSet(parA = string("pset2"))
01645             p.vpset1 = VPSet()
01646             p.vpset2 = untracked.VPSet()
01647             p.prune()
01648             self.assert_(hasattr(p, 'a'))
01649             self.assert_(hasattr(p, 'b'))
01650             self.assert_(not hasattr(p, 'c'))
01651             self.assert_(not hasattr(p, 'd'))
01652             self.assert_(not hasattr(p, 's'))
01653             self.assert_(hasattr(p, 'path1'))
01654             self.assert_(hasattr(p, 'path2'))
01655             self.assert_(not hasattr(p, 'pset1'))
01656             self.assert_(hasattr(p, 'pset2'))
01657             self.assert_(not hasattr(p, 'vpset1'))
01658             self.assert_(not hasattr(p, 'vpset2'))
01659 
01660             p = Process("test")
01661             p.a = EDAnalyzer("MyAnalyzer")
01662             p.b = EDAnalyzer("YourAnalyzer")
01663             p.c = EDAnalyzer("OurAnalyzer")
01664             p.d = EDAnalyzer("OurAnalyzer")
01665             p.e = EDAnalyzer("OurAnalyzer")
01666             p.s = Sequence(p.d)
01667             p.s2 = Sequence(p.b)
01668             p.s3 = Sequence(p.e)
01669             p.path1 = Path(p.a)
01670             p.path2 = Path(p.b)
01671             p.path3 = Path(p.b+p.s2)
01672             p.path4 = Path(p.b+p.s3)
01673             p.schedule = Schedule(p.path1,p.path2,p.path3)
01674             pths = p.paths
01675             keys = pths.keys()
01676             self.assertEqual(pths[keys[0]],p.path1)
01677             self.assertEqual(pths[keys[1]],p.path2)
01678             p.prune()
01679             self.assert_(hasattr(p, 'a'))
01680             self.assert_(hasattr(p, 'b'))
01681             self.assert_(not hasattr(p, 'c'))
01682             self.assert_(not hasattr(p, 'd'))
01683             self.assert_(not hasattr(p, 'e'))
01684             self.assert_(not hasattr(p, 's'))
01685             self.assert_(hasattr(p, 's2'))
01686             self.assert_(not hasattr(p, 's3'))
01687             self.assert_(hasattr(p, 'path1'))
01688             self.assert_(hasattr(p, 'path2'))
01689             self.assert_(hasattr(p, 'path3'))
01690             self.assert_(not hasattr(p, 'path4'))
01691             #test SequencePlaceholder
01692             p = Process("test")
01693             p.a = EDAnalyzer("MyAnalyzer")
01694             p.b = EDAnalyzer("YourAnalyzer")
01695             p.s = Sequence(SequencePlaceholder("a")+p.b)
01696             p.pth = Path(p.s)
01697             p.prune()
01698             self.assert_(hasattr(p, 'a'))
01699             self.assert_(hasattr(p, 'b'))
01700             self.assert_(hasattr(p, 's'))
01701             self.assert_(hasattr(p, 'pth'))
01702 
    unittest.main()

def Config::TestModuleCommand::testSchedule

(

self

)

Definition at line 1388 of file Config.py.

                              :
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.d = EDAnalyzer("OurAnalyzer")
            p.path1 = Path(p.a)
            p.path2 = Path(p.b)
            p.path3 = Path(p.d)

            s = Schedule(p.path1,p.path2)
            self.assertEqual(s[0],p.path1)
            self.assertEqual(s[1],p.path2)
            p.schedule = s
            self.assert_('b' in p.schedule.moduleNames())
            self.assert_(hasattr(p, 'b'))
            self.assert_(hasattr(p, 'c'))
            self.assert_(hasattr(p, 'd'))
            self.assert_(hasattr(p, 'path1'))
            self.assert_(hasattr(p, 'path2'))
            self.assert_(hasattr(p, 'path3'))
            p.prune()
            self.assert_('b' in p.schedule.moduleNames())
            self.assert_(hasattr(p, 'b'))
            self.assert_(not hasattr(p, 'c'))
            self.assert_(not hasattr(p, 'd'))
            self.assert_(hasattr(p, 'path1'))
            self.assert_(hasattr(p, 'path2'))
            self.assert_(not hasattr(p, 'path3'))

            #adding a path not attached to the Process should cause an exception
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            path1 = Path(p.a)
            s = Schedule(path1)
            self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )

            #make sure anonymous sequences work
            p = Process("test")
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("MyOtherAnalyzer")
            p.c = EDProducer("MyProd")
            path1 = Path(p.c*Sequence(p.a+p.b))
            s = Schedule(path1)
            self.assert_('a' in s.moduleNames())
            self.assert_('b' in s.moduleNames())
            self.assert_('c' in s.moduleNames())
            p.path1 = path1
            p.schedule = s
            p.prune()
            self.assert_('a' in s.moduleNames())
            self.assert_('b' in s.moduleNames())
            self.assert_('c' in s.moduleNames())

def Config::TestModuleCommand::testSecSource

(

self

)

Definition at line 1310 of file Config.py.

                               :
            p = Process('test')
            p.a = SecSource("MySecSource")
            self.assertEqual(p.dumpPython().replace('\n',''),'import FWCore.ParameterSet.Config as cmsprocess = cms.Process("test")process.a = cms.SecSource("MySecSource")')

def Config::TestModuleCommand::testSequence

(

self

)

Definition at line 1325 of file Config.py.

                              :
            p = Process('test')
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            p.s = Sequence(p.a*p.b)
            self.assertEqual(str(p.s),'a+b')
            self.assertEqual(p.s.label_(),'s')
            path = Path(p.c+p.s)
            self.assertEqual(str(path),'c+a+b')
            p._validateSequence(path, 'p1')
            notInProcess = EDAnalyzer('NotInProcess')
            p2 = Path(p.c+p.s*notInProcess)
            self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')

def Config::TestModuleCommand::testSequence2

(

self

)

Definition at line 1340 of file Config.py.

                               :
            p = Process('test')
            p.a = EDAnalyzer("MyAnalyzer")
            p.b = EDAnalyzer("YourAnalyzer")
            p.c = EDAnalyzer("OurAnalyzer")
            testseq = Sequence(p.a*p.b)
            p.s = testseq
            #p.y = testseq
            self.assertRaises(ValueError, p.__setattr__, "y", testseq) 

def Config::TestModuleCommand::testSubProcess

(

self

)

Definition at line 1589 of file Config.py.

01590                                 :
01591             process = Process("Parent")
01592             subProcess = Process("Child")
01593             subProcess.a = EDProducer("A")
01594             subProcess.p = Path(subProcess.a)
01595             subProcess.add_(Service("Foo"))
01596             process.add_( SubProcess(subProcess) )
01597             d = process.dumpPython()
01598             equalD ="""import FWCore.ParameterSet.Config as cms
01599 
01600 process = cms.Process("Parent")
01601 
01602 parentProcess = process
01603 import FWCore.ParameterSet.Config as cms
01604 
01605 process = cms.Process("Child")
01606 
01607 process.a = cms.EDProducer("A")
01608 
01609 
01610 process.p = cms.Path(process.a)
01611 
01612 
01613 process.Foo = cms.Service("Foo")
01614 
01615 
01616 childProcess = process
01617 process = parentProcess
01618 process.subProcess = cms.SubProcess( process = childProcess, SelectEvents = cms.untracked.PSet(
01619 
01620 ), outputCommands = cms.untracked.vstring())
01621 """
01622             equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcess)))
01623             self.assertEqual(d,equalD)
01624             p = TestMakePSet()
01625             process.subProcess.insertInto(p,"dummy")
01626             self.assertEqual((True,['a']),p.values["@sub_process"][1].values["process"][1].values['@all_modules'])
01627             self.assertEqual((True,['p']),p.values["@sub_process"][1].values["process"][1].values['@paths'])
            self.assertEqual({'@service_type':(True,'Foo')}, p.values["@sub_process"][1].values["process"][1].values["services"][1][0].values)

def Config::TestModuleCommand::testTypedParameterizable

(

self

)

Definition at line 1113 of file Config.py.

                                          :
            p = _TypedParameterizable("blah", b=int32(1))
            #see if copy works deeply
            other = p.copy()
            other.b = 2
            self.assertNotEqual(p.b,other.b)

def Config::TestModuleCommand::testUsing

(

self

)

Definition at line 1475 of file Config.py.

                           :
            p = Process('test')
            p.block = PSet(a = int32(1))
            p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
            self.assertEqual(p.modu.a.value(),1)
            self.assertEqual(p.modu.b.value(),2)

---

Member Data Documentation

tuple Config::TestModuleCommand::d = p.dumpPython() [static]

Definition at line 1289 of file Config.py.

tuple Config::TestModuleCommand::p = Process("test") [static]

Definition at line 1282 of file Config.py.

tuple Config::TestModuleCommand::s = Sequence(p.a) [static]

Definition at line 1285 of file Config.py.