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	testProcessDumpConfig
def	testProcessExtend
def	testProcessInsertion
def	testSchedule
def	testSecSource
def	testSequence
def	testSubProcess
def	testTypedParameterizable
def	testUsing

---

Detailed Description

Definition at line 961 of file Config.py.

---

Member Function Documentation

def Config::TestModuleCommand::setUp

(

self

)

Nothing to do 

Definition at line 962 of file Config.py.

00963                        :
00964             """Nothing to do """
            None

def Config::TestModuleCommand::testCloneSequence

(

self

)

Definition at line 1172 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 1283 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 1349 of file Config.py.

01350                             :
01351             process = Process("Freeze")
01352             m = EDProducer("M", p=PSet(i = int32(1)))
01353             m.p.i = 2
01354             process.m = m
01355             # should be frozen
01356             #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
01357             #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
01358             #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
01359             #self.assertRaises(ValueError, setattr, m, 'j', 1)
01360             # But OK to change through the process
01361             process.m.p.i = 4
01362             self.assertEqual(process.m.p.i.value(), 4)
01363             process.m.p = PSet(j=int32(1))
01364             # should work to clone it, though
01365             m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
01366             m2.p.i = 6
            m2.j = 8

def Config::TestModuleCommand::testGlobalReplace

(

self

)

Definition at line 1125 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 1227 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 = 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 1260 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 965 of file Config.py.

00966                                      :
00967             p = _Parameterizable()
00968             self.assertEqual(len(p.parameterNames_()),0)
00969             p.a = int32(1)
00970             self.assert_('a' in p.parameterNames_())
00971             self.assertEqual(p.a.value(), 1)
00972             p.a = 10
00973             self.assertEqual(p.a.value(), 10)
00974             p.a = untracked(int32(1))
00975             self.assertEqual(p.a.value(), 1)
00976             self.failIf(p.a.isTracked())
00977             p.a = untracked.int32(1)
00978             self.assertEqual(p.a.value(), 1)
00979             self.failIf(p.a.isTracked())
00980             p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
00981             self.assertEqual(p.foo.value(), 10)
00982             self.assertEqual(p.bar.value(),1.0)
00983             self.failIf(p.bar.isTracked())
00984             self.assertRaises(TypeError,setattr,(p,'c',1))
00985             p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
00986             self.assertEqual(p.a.foo.value(),10)
00987             self.assertEqual(p.a.bar.value(),1.0)
00988             p.b = untracked(PSet(fii = int32(1)))
00989             self.assertEqual(p.b.fii.value(),1)
00990             self.failIf(p.b.isTracked())
00991             #test the fact that values can be shared
00992             v = int32(10)
00993             p=_Parameterizable(a=v)
00994             v.setValue(11)
00995             self.assertEqual(p.a.value(),11)
00996             p.a = 12
00997             self.assertEqual(p.a.value(),12)
            self.assertEqual(v.value(),12)

def Config::TestModuleCommand::testPath

(

self

)

Definition at line 1150 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 1295 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::testProcessDumpConfig

(

self

)

Definition at line 1054 of file Config.py.

01055                                        :
01056             p = Process("test")
01057             p.a = EDAnalyzer("MyAnalyzer")
01058             p.p = Path(p.a)
01059             p.s = Sequence(p.a)
01060             p.r = Sequence(p.s)
01061             p.p2 = Path(p.s)
01062             p.schedule = Schedule(p.p2,p.p)
01063             d=p.dumpPython()
01064             self.assertEqual(d,
01065 """import FWCore.ParameterSet.Config as cms
01066 
01067 process = cms.Process("test")
01068 
01069 process.a = cms.EDAnalyzer("MyAnalyzer")
01070 
01071 
01072 process.s = cms.Sequence(process.a)
01073 
01074 
01075 process.r = cms.Sequence(process.s)
01076 
01077 
01078 process.p = cms.Path(process.a)
01079 
01080 
01081 process.p2 = cms.Path(process.s)
01082 
01083 
01084 process.schedule = cms.Schedule(process.p2,process.p)
01085 """)
01086             #Reverse order of 'r' and 's'
01087             p = Process("test")
01088             p.a = EDAnalyzer("MyAnalyzer")
01089             p.p = Path(p.a)
01090             p.r = Sequence(p.a)
01091             p.s = Sequence(p.r)
01092             p.p2 = Path(p.r)
01093             p.schedule = Schedule(p.p2,p.p)
01094             p.b = EDAnalyzer("YourAnalyzer")
01095             d=p.dumpPython()
01096             self.assertEqual(d,
01097 """import FWCore.ParameterSet.Config as cms
01098 
01099 process = cms.Process("test")
01100 
01101 process.a = cms.EDAnalyzer("MyAnalyzer")
01102 
01103 
01104 process.b = cms.EDAnalyzer("YourAnalyzer")
01105 
01106 
01107 process.r = cms.Sequence(process.a)
01108 
01109 
01110 process.s = cms.Sequence(process.r)
01111 
01112 
01113 process.p = cms.Path(process.a)
01114 
01115 
01116 process.p2 = cms.Path(process.r)
01117 
01118 
01119 process.schedule = cms.Schedule(process.p2,process.p)
""")

def Config::TestModuleCommand::testProcessExtend

(

self

)

Definition at line 1027 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")
            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.assertRaises(AttributeError,getattr,p,'b')
            self.assertEqual(p.Full.type_(),"Full")
            self.assertEqual(str(p.c),'a')
            self.assertEqual(str(p.d),'a')

def Config::TestModuleCommand::testProcessInsertion

(

self

)

Definition at line 1005 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_())

def Config::TestModuleCommand::testSchedule

(

self

)

Definition at line 1188 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)

            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'))
            p.prune()
            self.assert_('b' in p.schedule.moduleNames())
            self.assert_(hasattr(p, 'b'))
            self.assert_(not hasattr(p, 'c'))

            #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())
            

def Config::TestModuleCommand::testSecSource

(

self

)

Definition at line 1120 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 1135 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::testSubProcess

(

self

)

Definition at line 1367 of file Config.py.

01368                                 :
01369             process = Process("Parent")
01370             subProcess = Process("Child")
01371             subProcess.a = EDProducer("A")
01372             subProcess.p = Path(subProcess.a)
01373             subProcess.add_(Service("Foo"))
01374             process.add_( SubProcess(subProcess) )
01375             d = process.dumpPython()
01376             equalD ="""import FWCore.ParameterSet.Config as cms
01377 
01378 process = cms.Process("Parent")
01379 
01380 parentProcess = process
01381 import FWCore.ParameterSet.Config as cms
01382 
01383 process = cms.Process("Child")
01384 
01385 process.a = cms.EDProducer("A")
01386 
01387 
01388 process.p = cms.Path(process.a)
01389 
01390 
01391 process.Foo = cms.Service("Foo")
01392 
01393 
01394 childProcess = process
01395 process = parentProcess
01396 process.subProcess = cms.SubProcess( process = childProcess, SelectEvents = cms.untracked.PSet(
01397 
01398 ), outputCommands = cms.untracked.vstring())
01399 """
01400             equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcess)))
01401             self.assertEqual(d,equalD)
01402             p = TestMakePSet()
01403             process.subProcess.insertInto(p,"dummy")
01404             self.assertEqual((True,['a']),p.values["@sub_process"][1].values["process"][1].values['@all_modules'])
01405             self.assertEqual((True,['p']),p.values["@sub_process"][1].values["process"][1].values['@paths'])
01406             self.assertEqual({'@service_type':(True,'Foo')}, p.values["@sub_process"][1].values["process"][1].values["services"][1][0].values)
01407 
    unittest.main()

def Config::TestModuleCommand::testTypedParameterizable

(

self

)

Definition at line 998 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 1253 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)