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	testTypedParameterizable
def	testUsing

---

Detailed Description

Definition at line 832 of file Config.py.

---

Member Function Documentation

def Config::TestModuleCommand::setUp

(

self

)

Nothing to do 

Definition at line 833 of file Config.py.

00834                        :
00835             """Nothing to do """
            None

def Config::TestModuleCommand::testCloneSequence

(

self

)

Definition at line 1043 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 1154 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 1220 of file Config.py.

01221                             :
01222             process = Process("Freeze")
01223             m = EDProducer("M", p=PSet(i = int32(1)))
01224             m.p.i = 2
01225             process.m = m
01226             # should be frozen
01227             #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
01228             #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
01229             #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
01230             #self.assertRaises(ValueError, setattr, m, 'j', 1)
01231             # But OK to change through the process
01232             process.m.p.i = 4
01233             self.assertEqual(process.m.p.i.value(), 4)
01234             process.m.p = PSet(j=int32(1))
01235             # should work to clone it, though
01236             m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
01237             m2.p.i = 6
01238             m2.j = 8
01239 
01240 
    unittest.main()

def Config::TestModuleCommand::testGlobalReplace

(

self

)

Definition at line 996 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 1098 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 1131 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 836 of file Config.py.

00837                                      :
00838             p = _Parameterizable()
00839             self.assertEqual(len(p.parameterNames_()),0)
00840             p.a = int32(1)
00841             self.assert_('a' in p.parameterNames_())
00842             self.assertEqual(p.a.value(), 1)
00843             p.a = 10
00844             self.assertEqual(p.a.value(), 10)
00845             p.a = untracked(int32(1))
00846             self.assertEqual(p.a.value(), 1)
00847             self.failIf(p.a.isTracked())
00848             p.a = untracked.int32(1)
00849             self.assertEqual(p.a.value(), 1)
00850             self.failIf(p.a.isTracked())
00851             p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
00852             self.assertEqual(p.foo.value(), 10)
00853             self.assertEqual(p.bar.value(),1.0)
00854             self.failIf(p.bar.isTracked())
00855             self.assertRaises(TypeError,setattr,(p,'c',1))
00856             p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
00857             self.assertEqual(p.a.foo.value(),10)
00858             self.assertEqual(p.a.bar.value(),1.0)
00859             p.b = untracked(PSet(fii = int32(1)))
00860             self.assertEqual(p.b.fii.value(),1)
00861             self.failIf(p.b.isTracked())
00862             #test the fact that values can be shared
00863             v = int32(10)
00864             p=_Parameterizable(a=v)
00865             v.setValue(11)
00866             self.assertEqual(p.a.value(),11)
00867             p.a = 12
00868             self.assertEqual(p.a.value(),12)
            self.assertEqual(v.value(),12)

def Config::TestModuleCommand::testPath

(

self

)

Definition at line 1021 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 1166 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 925 of file Config.py.

00926                                        :
00927             p = Process("test")
00928             p.a = EDAnalyzer("MyAnalyzer")
00929             p.p = Path(p.a)
00930             p.s = Sequence(p.a)
00931             p.r = Sequence(p.s)
00932             p.p2 = Path(p.s)
00933             p.schedule = Schedule(p.p2,p.p)
00934             d=p.dumpPython()
00935             self.assertEqual(d,
00936 """import FWCore.ParameterSet.Config as cms
00937 
00938 process = cms.Process("test")
00939 
00940 process.a = cms.EDAnalyzer("MyAnalyzer")
00941 
00942 
00943 process.s = cms.Sequence(process.a)
00944 
00945 
00946 process.r = cms.Sequence(process.s)
00947 
00948 
00949 process.p = cms.Path(process.a)
00950 
00951 
00952 process.p2 = cms.Path(process.s)
00953 
00954 
00955 process.schedule = cms.Schedule(process.p2,process.p)
00956 """)
00957             #Reverse order of 'r' and 's'
00958             p = Process("test")
00959             p.a = EDAnalyzer("MyAnalyzer")
00960             p.p = Path(p.a)
00961             p.r = Sequence(p.a)
00962             p.s = Sequence(p.r)
00963             p.p2 = Path(p.r)
00964             p.schedule = Schedule(p.p2,p.p)
00965             p.b = EDAnalyzer("YourAnalyzer")
00966             d=p.dumpPython()
00967             self.assertEqual(d,
00968 """import FWCore.ParameterSet.Config as cms
00969 
00970 process = cms.Process("test")
00971 
00972 process.a = cms.EDAnalyzer("MyAnalyzer")
00973 
00974 
00975 process.b = cms.EDAnalyzer("YourAnalyzer")
00976 
00977 
00978 process.r = cms.Sequence(process.a)
00979 
00980 
00981 process.s = cms.Sequence(process.r)
00982 
00983 
00984 process.p = cms.Path(process.a)
00985 
00986 
00987 process.p2 = cms.Path(process.r)
00988 
00989 
00990 process.schedule = cms.Schedule(process.p2,process.p)
""")

def Config::TestModuleCommand::testProcessExtend

(

self

)

Definition at line 898 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 876 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 1059 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 991 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 1006 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::testTypedParameterizable

(

self

)

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