Modules.TestModules Class Reference

Inheritance diagram for Modules.TestModules:

Public Member Functions
def	testEDAnalyzer (self)
def	testESPrefer (self)
def	testIsTaskComponent (self)
def	testSequences (self)
def	testService (self)
def	testSwitchProducer (self)
def	testSwithProducerWithAlias (self)

Detailed Description

Definition at line 450 of file Modules.py.

Member Function Documentation

testEDAnalyzer()

def Modules.TestModules.testEDAnalyzer

(

self

)

Definition at line 451 of file Modules.py.

        def testEDAnalyzer(self):
            empty = EDAnalyzer("Empty")
            withParam = EDAnalyzer("Parameterized",foo=untracked(int32(1)), bar = untracked(string("it")))
            self.assertEqual(withParam.foo.value(), 1)
            self.assertEqual(withParam.bar.value(), "it")
            aCopy = withParam.copy()
            self.assertEqual(aCopy.foo.value(), 1)
            self.assertEqual(aCopy.bar.value(), "it")
            withType = EDAnalyzer("Test",type = int32(1))
            self.assertEqual(withType.type.value(),1)
            block = PSet(i = int32(9))
            m = EDProducer("DumbProducer", block, j = int32(10))
            self.assertEqual(9, m.i.value())
            self.assertEqual(10, m.j.value())

References Types.untracked.

testESPrefer()

def Modules.TestModules.testESPrefer

(

self

)

Definition at line 465 of file Modules.py.

        def testESPrefer(self):
            juicer = ESPrefer("JuiceProducer")
            options = PrintOptions()
            options.isCfg = True
            self.assertEqual(juicer.dumpPythonAs("juicer", options), "process.prefer(\"JuiceProducer\")\n")
            options.isCfg = False
            self.assertEqual(juicer.dumpPythonAs("juicer", options), "es_prefer_JuiceProducer = cms.ESPrefer(\"JuiceProducer\")\n")
 
            juicer = ESPrefer("JuiceProducer","juicer")
            options = PrintOptions()
            options.isCfg = True
            self.assertEqual(juicer.dumpPythonAs("juicer", options), 'process.prefer("juicer")\n')
            options.isCfg = False
            self.assertEqual(juicer.dumpPythonAs("juicer", options), 'es_prefer_juicer = cms.ESPrefer("JuiceProducer","juicer")\n')
            juicer = ESPrefer("JuiceProducer",fooRcd=vstring())
            self.assertEqual(juicer.dumpConfig(options),
"""JuiceProducer { 
    vstring fooRcd = {
    }
 
}
""")
            options = PrintOptions()
            options.isCfg = True
            self.assertEqual(juicer.dumpPythonAs("juicer"),
"""process.prefer("JuiceProducer",
    fooRcd = cms.vstring()
)
""")
            options.isCfg = False
            self.assertEqual(juicer.dumpPythonAs("juicer", options),
"""es_prefer_JuiceProducer = cms.ESPrefer("JuiceProducer",
    fooRcd = cms.vstring()
)
""")
        

testIsTaskComponent()

def Modules.TestModules.testIsTaskComponent

(

self

)

Definition at line 516 of file Modules.py.

        def testIsTaskComponent(self):
            m = EDProducer("x")
            self.assertTrue(m._isTaskComponent())
            self.assertTrue(m.isLeaf())
            m = SwitchProducerTest(test1=EDProducer("x"))
            self.assertTrue(m._isTaskComponent())
            self.assertTrue(m.isLeaf())
            m = EDFilter("x")
            self.assertTrue(m._isTaskComponent())
            self.assertTrue(m.isLeaf())
            m = OutputModule("x")
            self.assertFalse(m._isTaskComponent())
            self.assertTrue(m.isLeaf())
            m = EDAnalyzer("x")
            self.assertFalse(m._isTaskComponent())
            self.assertTrue(m.isLeaf())
            m = Service("x")
            self.assertTrue(m._isTaskComponent())
            self.assertTrue(m.isLeaf())
            m = ESProducer("x")
            self.assertTrue(m._isTaskComponent())
            self.assertTrue(m.isLeaf())
            m = ESSource("x")
            self.assertTrue(m._isTaskComponent())
            self.assertTrue(m.isLeaf())
            m = Sequence()
            self.assertFalse(m._isTaskComponent())
            self.assertFalse(m.isLeaf())
            m = Path()
            self.assertFalse(m._isTaskComponent())
            m = EndPath()
            self.assertFalse(m._isTaskComponent())
            m = Task()
            self.assertTrue(m._isTaskComponent())
            self.assertFalse(m.isLeaf())
 

testSequences()

def Modules.TestModules.testSequences

(

self

)

Definition at line 508 of file Modules.py.

        def testSequences(self):
            m = EDProducer("MProducer")
            n = EDProducer("NProducer")
            m.setLabel("m")
            n.setLabel("n")
            s1 = Sequence(m*n)
            options = PrintOptions()
 

testService()

def Modules.TestModules.testService

(

self

)

Definition at line 501 of file Modules.py.

        def testService(self):
            empty = Service("Empty")
            withParam = Service("Parameterized",foo=untracked(int32(1)), bar = untracked(string("it")))
            self.assertEqual(withParam.foo.value(), 1)
            self.assertEqual(withParam.bar.value(), "it")
            self.assertEqual(empty.dumpPython(), "cms.Service(\"Empty\")\n")
            self.assertEqual(withParam.dumpPython(), "cms.Service(\"Parameterized\",\n    bar = cms.untracked.string(\'it\'),\n    foo = cms.untracked.int32(1)\n)\n")

References Types.untracked.

testSwitchProducer()

def Modules.TestModules.testSwitchProducer

(

self

)

Definition at line 552 of file Modules.py.

        def testSwitchProducer(self):
            # Constructor
            sp = SwitchProducerTest(test1 = EDProducer("Foo"), test2 = EDProducer("Bar"))
            self.assertEqual(sp.test1.type_(), "Foo")
            self.assertEqual(sp.test2.type_(), "Bar")
            self.assertRaises(ValueError, lambda: SwitchProducerTest(nonexistent = EDProducer("Foo")))
            self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = EDAnalyzer("Foo")))
            self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = EDFilter("Foo")))
            self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = Source("Foo")))
            self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = OutputModule("Foo")))
            self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = Looper("Foo")))
            self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = Service("Foo")))
            self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = ESSource("Foo")))
            self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = ESProducer("Foo")))
            self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = ESPrefer("Foo")))
            self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = SwitchProducerTest(test1 = EDProducer("Foo"))))
 
            # Case decision
            sp = SwitchProducerTest(test1 = EDProducer("Foo"), test2 = EDProducer("Bar"))
            self.assertEqual(sp._getProducer().type_(), "Bar")
            sp = SwitchProducerTest1Dis(test1 = EDProducer("Foo"), test2 = EDProducer("Bar"))
            self.assertEqual(sp._getProducer().type_(), "Bar")
            sp = SwitchProducerTest2Dis(test1 = EDProducer("Foo"), test2 = EDProducer("Bar"))
            self.assertEqual(sp._getProducer().type_(), "Foo")
            sp = SwitchProducerTest(test1 = EDProducer("Bar"))
            self.assertEqual(sp._getProducer().type_(), "Bar")
            sp = SwitchProducerTest1Dis(test1 = EDProducer("Bar"))
            self.assertRaises(RuntimeError, sp._getProducer)
 
            # Mofications
            from .Types import int32, string, PSet
            sp = SwitchProducerTest(test1 = EDProducer("Foo",
                                                       a = int32(1),
                                                       b = PSet(c = int32(2))),
                                    test2 = EDProducer("Bar",
                                                       aa = int32(11),
                                                       bb = PSet(cc = int32(12))))
            # Simple clone
            cl = sp.clone()
            self.assertEqual(cl.test1.type_(), "Foo")
            self.assertEqual(cl.test1.a.value(), 1)
            self.assertEqual(cl.test1.b.c.value(), 2)
            self.assertEqual(cl.test2.type_(), "Bar")
            self.assertEqual(cl.test2.aa.value(), 11)
            self.assertEqual(cl.test2.bb.cc.value(), 12)
            self.assertEqual(sp._getProducer().type_(), "Bar")
            # Modify clone
            cl.test1.a = 3
            self.assertEqual(cl.test1.a.value(), 3)
            cl.test1 = EDProducer("Fred")
            self.assertEqual(cl.test1.type_(), "Fred")
            def _assignEDAnalyzer():
                cl.test1 = EDAnalyzer("Foo")
            self.assertRaises(TypeError, _assignEDAnalyzer)
            def _assignSwitchProducer():
                cl.test1 = SwitchProducerTest(test1 = SwitchProducerTest(test1 = EDProducer("Foo")))
            self.assertRaises(TypeError, _assignSwitchProducer)
            # Modify values with a dict
            cl = sp.clone(test1 = dict(a = 4, b = dict(c = None)),
                          test2 = dict(aa = 15, bb = dict(cc = 45, dd = string("foo"))))
            self.assertEqual(cl.test1.a.value(), 4)
            self.assertEqual(cl.test1.b.hasParameter("c"), False)
            self.assertEqual(cl.test2.aa.value(), 15)
            self.assertEqual(cl.test2.bb.cc.value(), 45)
            self.assertEqual(cl.test2.bb.dd.value(), "foo")
            # Replace/add/remove EDProducers
            cl = sp.clone(test1 = EDProducer("Fred", x = int32(42)),
                          test3 = EDProducer("Wilma", y = int32(24)),
                          test2 = None)
            self.assertEqual(cl.test1.type_(), "Fred")
            self.assertEqual(cl.test1.x.value(), 42)
            self.assertEqual(cl.test3.type_(), "Wilma")
            self.assertEqual(cl.test3.y.value(), 24)
            self.assertEqual(hasattr(cl, "test2"), False)
            self.assertRaises(TypeError, lambda: sp.clone(test1 = EDAnalyzer("Foo")))
            self.assertRaises(TypeError, lambda: sp.clone(test1 = SwitchProducerTest(test1 = SwitchProducerTest(test1 = EDProducer("Foo")))))
 
            # Dump
            sp = SwitchProducerTest(test2 = EDProducer("Foo",
                                                       a = int32(1),
                                                       b = PSet(c = int32(2))),
                                    test1 = EDProducer("Bar",
                                                       aa = int32(11),
                                                       bb = PSet(cc = int32(12))))
            self.assertEqual(sp.dumpPython(),
"""SwitchProducerTest(
    test1 = cms.EDProducer("Bar",
        aa = cms.int32(11),
        bb = cms.PSet(
            cc = cms.int32(12)
        )
    ),
    test2 = cms.EDProducer("Foo",
        a = cms.int32(1),
        b = cms.PSet(
            c = cms.int32(2)
        )
    )
)
""")
            # Pickle
            import pickle
            sp = SwitchProducerPickleable(cpu = EDProducer("Foo"))
            pkl = pickle.dumps(sp)
            unpkl = pickle.loads(pkl)
            self.assertEqual(unpkl.cpu.type_(), "Foo")
 

testSwithProducerWithAlias()

def Modules.TestModules.testSwithProducerWithAlias

(

self

)

Definition at line 659 of file Modules.py.

        def testSwithProducerWithAlias(self):
            # Constructor
            sp = SwitchProducerTest(test1 = EDProducer("Foo"), test2 = EDAlias())
            self.assertEqual(sp.test1.type_(), "Foo")
            self.assertTrue(isinstance(sp.test2, EDAlias))
 
            # Modifications
            from .Types import int32, string, PSet, VPSet
            sp = SwitchProducerTest(test1 = EDProducer("Foo"),
                                    test2 = EDAlias(foo = VPSet(PSet(type = string("Foo2")))))
 
            # Simple clone
            cl = sp.clone()
            self.assertTrue(hasattr(cl.test2, "foo"))
            # Modify clone
            cl.test2.foo[0].type = "Foo3"
            self.assertEqual(cl.test2.foo[0].type, "Foo3")
            # Modify values with a dict
            cl = sp.clone(test2 = dict(foo = {0: dict(type = "Foo4")}))
            self.assertEqual(cl.test2.foo[0].type, "Foo4")
            # Replace or add EDAlias
            cl = sp.clone(test1 = EDAlias(foo = VPSet(PSet(type = string("Foo5")))),
                          test3 = EDAlias(foo = VPSet(PSet(type = string("Foo6")))))
            self.assertEqual(cl.test1.foo[0].type, "Foo5")
            self.assertEqual(cl.test3.foo[0].type, "Foo6")
            # Modify clone
            cl.test1 = EDProducer("Xyzzy")
            self.assertEqual(cl.test1.type_(), "Xyzzy")
            cl.test1 = EDAlias(foo = VPSet(PSet(type = string("Foo7"))))
            self.assertEqual(cl.test1.foo[0].type, "Foo7")
 
 
            # Dump
            from .Types import int32, string, PSet, VPSet
            sp = SwitchProducerTest(test1 = EDProducer("Foo"),
                                    test2 = EDAlias(foo = VPSet(PSet(type = string("Foo2")))))
 
            self.assertEqual(sp.dumpPython(),
"""SwitchProducerTest(
    test1 = cms.EDProducer("Foo"),
    test2 = cms.EDAlias(
        foo = cms.VPSet(cms.PSet(
            type = cms.string('Foo2')
        ))
)
)
""")
 
            # Pickle
            import pickle
            sp = SwitchProducerPickleable(cpu = EDAlias(foo = VPSet(PSet(type = string("Foo2")))))
            pkl = pickle.dumps(sp)
            unpkl = pickle.loads(pkl)
            self.assertEqual(sp.cpu.foo[0].type, "Foo2")
    unittest.main()