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

Member Function Documentation

def Config::TestModuleCommand::setUp ( self )

Nothing to do

Definition at line 1052 of file Config.py.

01053                        :
01054             """Nothing to do """
            None

def Config::TestModuleCommand::testCloneSequence ( self )

Definition at line 1294 of file Config.py.

01295                                    :
01296             p = Process("test")
01297             a = EDAnalyzer("MyAnalyzer")
01298             p.a = a
01299             a.setLabel("a")
01300             b = EDAnalyzer("YOurAnalyzer")
01301             p.b = b
01302             b.setLabel("b")
01303             path = Path(a * b)
01304             p.path = Path(p.a*p.b)
01305             lookuptable = {id(a): p.a, id(b): p.b}
01306             #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
01307             #lookuptable = p._cloneToObjectDict
01308             #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
01309             self.assertEqual(str(path),str(p.path))

def Config::TestModuleCommand::testExamples ( self )

Definition at line 1427 of file Config.py.

01428                               :
01429             p = Process("Test")
01430             p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
01431             p.foos = EDProducer("FooProducer")
01432             p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
01433             p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
01434             p.bars.foos = 'Foosball'
01435             self.assertEqual(p.bars.foos, InputTag('Foosball'))
01436             p.p = Path(p.foos*p.bars)
01437             p.e = EndPath(p.out)
01438             p.add_(Service("MessageLogger"))

def Config::TestModuleCommand::testFreeze ( self )

Definition at line 1493 of file Config.py.

01494                             :
01495             process = Process("Freeze")
01496             m = EDProducer("M", p=PSet(i = int32(1)))
01497             m.p.i = 2
01498             process.m = m
01499             # should be frozen
01500             #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
01501             #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
01502             #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
01503             #self.assertRaises(ValueError, setattr, m, 'j', 1)
01504             # But OK to change through the process
01505             process.m.p.i = 4
01506             self.assertEqual(process.m.p.i.value(), 4)
01507             process.m.p = PSet(j=int32(1))
01508             # should work to clone it, though
01509             m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
01510             m2.p.i = 6
            m2.j = 8

def Config::TestModuleCommand::testGlobalReplace ( self )

Definition at line 1247 of file Config.py.

01248                                    :
01249             p = Process('test')
01250             p.a = EDAnalyzer("MyAnalyzer")
01251             p.b = EDAnalyzer("YourAnalyzer")
01252             p.c = EDAnalyzer("OurAnalyzer")
01253             p.s = Sequence(p.a*p.b)
01254             p.p = Path(p.c+p.s+p.a)
01255             new = EDAnalyzer("NewAnalyzer")
01256             p.globalReplace("a",new)

def Config::TestModuleCommand::testImplicitSchedule ( self )

Definition at line 1364 of file Config.py.

01365                                       :
01366             p = Process("test")
01367             p.a = EDAnalyzer("MyAnalyzer")
01368             p.b = EDAnalyzer("YourAnalyzer")
01369             p.c = EDAnalyzer("OurAnalyzer")
01370             p.path1 = Path(p.a)
01371             p.path2 = Path(p.b)
01372             self.assert_(p.schedule is None)
01373             pths = p.paths
01374             keys = pths.keys()
01375             self.assertEqual(pths[keys[0]],p.path1)
01376             self.assertEqual(pths[keys[1]],p.path2)
01377             p.prune()
01378             self.assert_(hasattr(p, 'a'))
01379             self.assert_(hasattr(p, 'b'))
01380             self.assert_(not hasattr(p, 'c'))
01381             self.assert_(hasattr(p, 'path1'))
01382             self.assert_(hasattr(p, 'path2'))
01383 
01384 
01385             p = Process("test")
01386             p.a = EDAnalyzer("MyAnalyzer")
01387             p.b = EDAnalyzer("YourAnalyzer")
01388             p.c = EDAnalyzer("OurAnalyzer")
01389             p.path2 = Path(p.b)
01390             p.path1 = Path(p.a)
01391             self.assert_(p.schedule is None)
01392             pths = p.paths
01393             keys = pths.keys()
01394             self.assertEqual(pths[keys[1]],p.path1)
01395             self.assertEqual(pths[keys[0]],p.path2)
01396

def Config::TestModuleCommand::testOverride ( self )

Definition at line 1404 of file Config.py.

01405                               :
01406             p = Process('test')
01407             a = EDProducer("A", a1=int32(0))
01408             self.assert_(not a.isModified())
01409             a.a1 = 1
01410             self.assert_(a.isModified())
01411             p.a = a
01412             self.assertEqual(p.a.a1.value(), 1)
01413             # try adding an unmodified module.
01414             # should accept it
01415             p.a = EDProducer("A", a1=int32(2))
01416             self.assertEqual(p.a.a1.value(), 2)
01417             # try adding a modified module.  Should throw
01418             # no longer, since the same (modified) say, geometry
01419             # could come from more than one cff
01420             b = EDProducer("A", a1=int32(3))
01421             b.a1 = 4
01422             #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
01423             ps1 = PSet(a = int32(1))
01424             ps2 = PSet(a = int32(2))
01425             self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
01426             self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))

def Config::TestModuleCommand::testParameterizable ( self )

Definition at line 1055 of file Config.py.

01056                                      :
01057             p = _Parameterizable()
01058             self.assertEqual(len(p.parameterNames_()),0)
01059             p.a = int32(1)
01060             self.assert_('a' in p.parameterNames_())
01061             self.assertEqual(p.a.value(), 1)
01062             p.a = 10
01063             self.assertEqual(p.a.value(), 10)
01064             p.a = untracked(int32(1))
01065             self.assertEqual(p.a.value(), 1)
01066             self.failIf(p.a.isTracked())
01067             p.a = untracked.int32(1)
01068             self.assertEqual(p.a.value(), 1)
01069             self.failIf(p.a.isTracked())
01070             p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
01071             self.assertEqual(p.foo.value(), 10)
01072             self.assertEqual(p.bar.value(),1.0)
01073             self.failIf(p.bar.isTracked())
01074             self.assertRaises(TypeError,setattr,(p,'c',1))
01075             p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
01076             self.assertEqual(p.a.foo.value(),10)
01077             self.assertEqual(p.a.bar.value(),1.0)
01078             p.b = untracked(PSet(fii = int32(1)))
01079             self.assertEqual(p.b.fii.value(),1)
01080             self.failIf(p.b.isTracked())
01081             #test the fact that values can be shared
01082             v = int32(10)
01083             p=_Parameterizable(a=v)
01084             v.setValue(11)
01085             self.assertEqual(p.a.value(),11)
01086             p.a = 12
01087             self.assertEqual(p.a.value(),12)
            self.assertEqual(v.value(),12)

def Config::TestModuleCommand::testPath ( self )

Definition at line 1272 of file Config.py.

01273                           :
01274             p = Process("test")
01275             p.a = EDAnalyzer("MyAnalyzer")
01276             p.b = EDAnalyzer("YourAnalyzer")
01277             p.c = EDAnalyzer("OurAnalyzer")
01278             path = Path(p.a)
01279             path *= p.b
01280             path += p.c
01281             self.assertEqual(str(path),'a+b+c')
01282             path = Path(p.a*p.b+p.c)
01283             self.assertEqual(str(path),'a+b+c')
01284 #            path = Path(p.a)*p.b+p.c #This leads to problems with sequences
01285 #            self.assertEqual(str(path),'((a*b)+c)')
01286             path = Path(p.a+ p.b*p.c)
01287             self.assertEqual(str(path),'a+b+c')
01288             path = Path(p.a*(p.b+p.c))
01289             self.assertEqual(str(path),'a+b+c')
01290             path = Path(p.a*(p.b+~p.c))
01291             self.assertEqual(str(path),'a+b+~c')
01292             p.es = ESProducer("AnESProducer")
01293             self.assertRaises(TypeError,Path,p.es)

def Config::TestModuleCommand::testPrefers ( self )

Definition at line 1439 of file Config.py.

01440                              :
01441             p = Process("Test")
01442             p.add_(ESSource("ForceSource"))
01443             p.juicer = ESProducer("JuicerProducer")
01444             p.prefer("ForceSource")
01445             p.prefer("juicer")
01446             self.assertEqual(p.dumpConfig(),
01447 """process Test = {
01448     es_module juicer = JuicerProducer { 
01449     }
01450     es_source  = ForceSource { 
01451     }
01452     es_prefer  = ForceSource { 
01453     }
01454     es_prefer juicer = JuicerProducer { 
01455     }
01456 }
01457 """)
01458             p.prefer("juicer",fooRcd=vstring("Foo"))
01459             self.assertEqual(p.dumpConfig(),
01460 """process Test = {
01461     es_module juicer = JuicerProducer { 
01462     }
01463     es_source  = ForceSource { 
01464     }
01465     es_prefer  = ForceSource { 
01466     }
01467     es_prefer juicer = JuicerProducer { 
01468         vstring fooRcd = {
01469             'Foo'
01470         }
01471 
01472     }
01473 }
01474 """)
01475             self.assertEqual(p.dumpPython(),
01476 """import FWCore.ParameterSet.Config as cms
01477 
01478 process = cms.Process("Test")
01479 
01480 process.juicer = cms.ESProducer("JuicerProducer")
01481 
01482 
01483 process.ForceSource = cms.ESSource("ForceSource")
01484 
01485 
01486 process.prefer("ForceSource")
01487 
01488 process.prefer("juicer",
01489     fooRcd = cms.vstring('Foo')
01490 )
01491 
01492 """)

def Config::TestModuleCommand::testProcessDumpPython ( self )

Definition at line 1147 of file Config.py.

01148                                        :
01149             p = Process("test")
01150             p.a = EDAnalyzer("MyAnalyzer")
01151             p.p = Path(p.a)
01152             p.s = Sequence(p.a)
01153             p.r = Sequence(p.s)
01154             p.p2 = Path(p.s)
01155             p.schedule = Schedule(p.p2,p.p)
01156             d=p.dumpPython()
01157             self.assertEqual(d,
01158 """import FWCore.ParameterSet.Config as cms
01159 
01160 process = cms.Process("test")
01161 
01162 process.a = cms.EDAnalyzer("MyAnalyzer")
01163 
01164 
01165 process.s = cms.Sequence(process.a)
01166 
01167 
01168 process.r = cms.Sequence(process.s)
01169 
01170 
01171 process.p = cms.Path(process.a)
01172 
01173 
01174 process.p2 = cms.Path(process.s)
01175 
01176 
01177 process.schedule = cms.Schedule(*[ process.p2, process.p ])
01178 """)
01179             #Reverse order of 'r' and 's'
01180             p = Process("test")
01181             p.a = EDAnalyzer("MyAnalyzer")
01182             p.p = Path(p.a)
01183             p.r = Sequence(p.a)
01184             p.s = Sequence(p.r)
01185             p.p2 = Path(p.r)
01186             p.schedule = Schedule(p.p2,p.p)
01187             p.b = EDAnalyzer("YourAnalyzer")
01188             d=p.dumpPython()
01189             self.assertEqual(d,
01190 """import FWCore.ParameterSet.Config as cms
01191 
01192 process = cms.Process("test")
01193 
01194 process.a = cms.EDAnalyzer("MyAnalyzer")
01195 
01196 
01197 process.b = cms.EDAnalyzer("YourAnalyzer")
01198 
01199 
01200 process.r = cms.Sequence(process.a)
01201 
01202 
01203 process.s = cms.Sequence(process.r)
01204 
01205 
01206 process.p = cms.Path(process.a)
01207 
01208 
01209 process.p2 = cms.Path(process.r)
01210 
01211 
01212 process.schedule = cms.Schedule(*[ process.p2, process.p ])
""")

def Config::TestModuleCommand::testProcessExtend ( self )

Definition at line 1120 of file Config.py.

01121                                    :
01122             class FromArg(object):
01123                 def __init__(self,*arg,**args):
01124                     for name in args.iterkeys():
01125                         self.__dict__[name]=args[name]
01126 
01127             a=EDAnalyzer("MyAnalyzer")
01128             s1 = Sequence(a)
01129             s2 = Sequence(s1)
01130             s3 = Sequence(s2)
01131             d = FromArg(
01132                     a=a,
01133                     b=Service("Full"),
01134                     c=Path(a),
01135                     d=s2,
01136                     e=s1,
01137                     f=s3,
01138                     g=Sequence(s1+s2+s3)
01139                 )
01140             p = Process("Test")
01141             p.extend(d)
01142             self.assertEqual(p.a.type_(),"MyAnalyzer")
01143             self.assertRaises(AttributeError,getattr,p,'b')
01144             self.assertEqual(p.Full.type_(),"Full")
01145             self.assertEqual(str(p.c),'a')
01146             self.assertEqual(str(p.d),'a')

def Config::TestModuleCommand::testProcessInsertion ( self )

Definition at line 1095 of file Config.py.

01096                                       :
01097             p = Process("test")
01098             p.a = EDAnalyzer("MyAnalyzer")
01099             self.assert_( 'a' in p.analyzers_() )
01100             self.assert_( 'a' in p.analyzers)
01101             p.add_(Service("MessageLogger"))
01102             self.assert_('MessageLogger' in p.services_())
01103             self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
01104             p.Tracer = Service("Tracer")
01105             self.assert_('Tracer' in p.services_())
01106             self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
01107             self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
01108             self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
01109             p.out = OutputModule("Outer")
01110             self.assertEqual(p.out.type_(), 'Outer')
01111             self.assert_( 'out' in p.outputModules_() )
01112 
01113             p.geom = ESSource("GeomProd")
01114             self.assert_('geom' in p.es_sources_())
01115             p.add_(ESSource("ConfigDB"))
01116             self.assert_('ConfigDB' in p.es_sources_())
01117 
01118             p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
01119             self.assert_('aliasfoo1' in p.aliases_())

def Config::TestModuleCommand::testPrune ( self )

Definition at line 1550 of file Config.py.

01551                            :
01552             p = Process("test")
01553             p.a = EDAnalyzer("MyAnalyzer")
01554             p.b = EDAnalyzer("YourAnalyzer")
01555             p.c = EDAnalyzer("OurAnalyzer")
01556             p.d = EDAnalyzer("OurAnalyzer")
01557             p.s = Sequence(p.d)
01558             p.path1 = Path(p.a)
01559             p.path2 = Path(p.b)
01560             self.assert_(p.schedule is None)
01561             pths = p.paths
01562             keys = pths.keys()
01563             self.assertEqual(pths[keys[0]],p.path1)
01564             self.assertEqual(pths[keys[1]],p.path2)
01565             p.prune()
01566             self.assert_(hasattr(p, 'a'))
01567             self.assert_(hasattr(p, 'b'))
01568             self.assert_(not hasattr(p, 'c'))
01569             self.assert_(not hasattr(p, 'd'))
01570             self.assert_(not hasattr(p, 's'))
01571             self.assert_(hasattr(p, 'path1'))
01572             self.assert_(hasattr(p, 'path2'))
01573 
01574             p = Process("test")
01575             p.a = EDAnalyzer("MyAnalyzer")
01576             p.b = EDAnalyzer("YourAnalyzer")
01577             p.c = EDAnalyzer("OurAnalyzer")
01578             p.d = EDAnalyzer("OurAnalyzer")
01579             p.e = EDAnalyzer("OurAnalyzer")
01580             p.s = Sequence(p.d)
01581             p.s2 = Sequence(p.b)
01582             p.s3 = Sequence(p.e)
01583             p.path1 = Path(p.a)
01584             p.path2 = Path(p.b)
01585             p.path3 = Path(p.b+p.s2)
01586             p.path4 = Path(p.b+p.s3)
01587             p.schedule = Schedule(p.path1,p.path2,p.path3)
01588             pths = p.paths
01589             keys = pths.keys()
01590             self.assertEqual(pths[keys[0]],p.path1)
01591             self.assertEqual(pths[keys[1]],p.path2)
01592             p.prune()
01593             self.assert_(hasattr(p, 'a'))
01594             self.assert_(hasattr(p, 'b'))
01595             self.assert_(not hasattr(p, 'c'))
01596             self.assert_(not hasattr(p, 'd'))
01597             self.assert_(not hasattr(p, 'e'))
01598             self.assert_(not hasattr(p, 's'))
01599             self.assert_(hasattr(p, 's2'))
01600             self.assert_(not hasattr(p, 's3'))
01601             self.assert_(hasattr(p, 'path1'))
01602             self.assert_(hasattr(p, 'path2'))
01603             self.assert_(hasattr(p, 'path3'))
01604             self.assert_(not hasattr(p, 'path4'))
01605             #test SequencePlaceholder
01606             p = Process("test")
01607             p.a = EDAnalyzer("MyAnalyzer")
01608             p.b = EDAnalyzer("YourAnalyzer")
01609             p.s = Sequence(SequencePlaceholder("a")+p.b)
01610             p.pth = Path(p.s)
01611             p.prune()
01612             self.assert_(hasattr(p, 'a'))
01613             self.assert_(hasattr(p, 'b'))
01614             self.assert_(hasattr(p, 's'))
01615             self.assert_(hasattr(p, 'pth'))
01616 
    unittest.main()

def Config::TestModuleCommand::testSchedule ( self )

Definition at line 1310 of file Config.py.

01311                               :
01312             p = Process("test")
01313             p.a = EDAnalyzer("MyAnalyzer")
01314             p.b = EDAnalyzer("YourAnalyzer")
01315             p.c = EDAnalyzer("OurAnalyzer")
01316             p.d = EDAnalyzer("OurAnalyzer")
01317             p.path1 = Path(p.a)
01318             p.path2 = Path(p.b)
01319             p.path3 = Path(p.d)
01320 
01321             s = Schedule(p.path1,p.path2)
01322             self.assertEqual(s[0],p.path1)
01323             self.assertEqual(s[1],p.path2)
01324             p.schedule = s
01325             self.assert_('b' in p.schedule.moduleNames())
01326             self.assert_(hasattr(p, 'b'))
01327             self.assert_(hasattr(p, 'c'))
01328             self.assert_(hasattr(p, 'd'))
01329             self.assert_(hasattr(p, 'path1'))
01330             self.assert_(hasattr(p, 'path2'))
01331             self.assert_(hasattr(p, 'path3'))
01332             p.prune()
01333             self.assert_('b' in p.schedule.moduleNames())
01334             self.assert_(hasattr(p, 'b'))
01335             self.assert_(not hasattr(p, 'c'))
01336             self.assert_(not hasattr(p, 'd'))
01337             self.assert_(hasattr(p, 'path1'))
01338             self.assert_(hasattr(p, 'path2'))
01339             self.assert_(not hasattr(p, 'path3'))
01340 
01341             #adding a path not attached to the Process should cause an exception
01342             p = Process("test")
01343             p.a = EDAnalyzer("MyAnalyzer")
01344             path1 = Path(p.a)
01345             s = Schedule(path1)
01346             self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
01347 
01348             #make sure anonymous sequences work
01349             p = Process("test")
01350             p.a = EDAnalyzer("MyAnalyzer")
01351             p.b = EDAnalyzer("MyOtherAnalyzer")
01352             p.c = EDProducer("MyProd")
01353             path1 = Path(p.c*Sequence(p.a+p.b))
01354             s = Schedule(path1)
01355             self.assert_('a' in s.moduleNames())
01356             self.assert_('b' in s.moduleNames())
01357             self.assert_('c' in s.moduleNames())
01358             p.path1 = path1
01359             p.schedule = s
01360             p.prune()
01361             self.assert_('a' in s.moduleNames())
01362             self.assert_('b' in s.moduleNames())
01363             self.assert_('c' in s.moduleNames())

def Config::TestModuleCommand::testSecSource ( self )

Definition at line 1242 of file Config.py.

01243                                :
01244             p = Process('test')
01245             p.a = SecSource("MySecSource")
01246             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 1257 of file Config.py.

01258                               :
01259             p = Process('test')
01260             p.a = EDAnalyzer("MyAnalyzer")
01261             p.b = EDAnalyzer("YourAnalyzer")
01262             p.c = EDAnalyzer("OurAnalyzer")
01263             p.s = Sequence(p.a*p.b)
01264             self.assertEqual(str(p.s),'a+b')
01265             self.assertEqual(p.s.label_(),'s')
01266             path = Path(p.c+p.s)
01267             self.assertEqual(str(path),'c+a+b')
01268             p._validateSequence(path, 'p1')
01269             notInProcess = EDAnalyzer('NotInProcess')
01270             p2 = Path(p.c+p.s*notInProcess)
01271             self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')

def Config::TestModuleCommand::testSubProcess ( self )

Definition at line 1511 of file Config.py.

01512                                 :
01513             process = Process("Parent")
01514             subProcess = Process("Child")
01515             subProcess.a = EDProducer("A")
01516             subProcess.p = Path(subProcess.a)
01517             subProcess.add_(Service("Foo"))
01518             process.add_( SubProcess(subProcess) )
01519             d = process.dumpPython()
01520             equalD ="""import FWCore.ParameterSet.Config as cms
01521 
01522 process = cms.Process("Parent")
01523 
01524 parentProcess = process
01525 import FWCore.ParameterSet.Config as cms
01526 
01527 process = cms.Process("Child")
01528 
01529 process.a = cms.EDProducer("A")
01530 
01531 
01532 process.p = cms.Path(process.a)
01533 
01534 
01535 process.Foo = cms.Service("Foo")
01536 
01537 
01538 childProcess = process
01539 process = parentProcess
01540 process.subProcess = cms.SubProcess( process = childProcess, SelectEvents = cms.untracked.PSet(
01541 
01542 ), outputCommands = cms.untracked.vstring())
01543 """
01544             equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcess)))
01545             self.assertEqual(d,equalD)
01546             p = TestMakePSet()
01547             process.subProcess.insertInto(p,"dummy")
01548             self.assertEqual((True,['a']),p.values["@sub_process"][1].values["process"][1].values['@all_modules'])
01549             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 1088 of file Config.py.

01089                                           :
01090             p = _TypedParameterizable("blah", b=int32(1))
01091             #see if copy works deeply
01092             other = p.copy()
01093             other.b = 2
01094             self.assertNotEqual(p.b,other.b)

def Config::TestModuleCommand::testUsing ( self )

Definition at line 1397 of file Config.py.

01398                            :
01399             p = Process('test')
01400             p.block = PSet(a = int32(1))
01401             p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
01402             self.assertEqual(p.modu.a.value(),1)
01403             self.assertEqual(p.modu.b.value(),2)

Member Data Documentation

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

Definition at line 1221 of file Config.py.

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

Definition at line 1214 of file Config.py.

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

Definition at line 1217 of file Config.py.

Config::TestModuleCommand Class Reference

Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation