CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
List of all members | Public Member Functions
Modules.TestModules Class Reference
Inheritance diagram for Modules.TestModules:

Public Member Functions

def testEDAnalyzer
 
def testESPrefer
 
def testIsTaskComponent
 
def testSequences
 
def testService
 
def testSwitchProducer
 
def testSwithProducerWithAlias
 

Detailed Description

Definition at line 435 of file Modules.py.

Member Function Documentation

def Modules.TestModules.testEDAnalyzer (   self)

Definition at line 436 of file Modules.py.

References AlCaHLTBitMon_QueryRunRegistry.string, and Types.untracked.

436 
437  def testEDAnalyzer(self):
438  empty = EDAnalyzer("Empty")
439  withParam = EDAnalyzer("Parameterized",foo=untracked(int32(1)), bar = untracked(string("it")))
440  self.assertEqual(withParam.foo.value(), 1)
441  self.assertEqual(withParam.bar.value(), "it")
442  aCopy = withParam.copy()
443  self.assertEqual(aCopy.foo.value(), 1)
444  self.assertEqual(aCopy.bar.value(), "it")
445  withType = EDAnalyzer("Test",type = int32(1))
446  self.assertEqual(withType.type.value(),1)
447  block = PSet(i = int32(9))
448  m = EDProducer("DumbProducer", block, j = int32(10))
449  self.assertEqual(9, m.i.value())
self.assertEqual(10, m.j.value())
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
Types.untracked
tuple untracked
Definition: Types.py:34
def Modules.TestModules.testESPrefer (   self)

Definition at line 450 of file Modules.py.

450 
451  def testESPrefer(self):
452  juicer = ESPrefer("JuiceProducer")
453  options = PrintOptions()
454  options.isCfg = True
455  self.assertEqual(juicer.dumpPythonAs("juicer", options), "process.prefer(\"JuiceProducer\")\n")
456  options.isCfg = False
457  self.assertEqual(juicer.dumpPythonAs("juicer", options), "es_prefer_JuiceProducer = cms.ESPrefer(\"JuiceProducer\")\n")
458 
459  juicer = ESPrefer("JuiceProducer","juicer")
460  options = PrintOptions()
461  options.isCfg = True
462  self.assertEqual(juicer.dumpPythonAs("juicer", options), 'process.prefer("juicer")\n')
463  options.isCfg = False
464  self.assertEqual(juicer.dumpPythonAs("juicer", options), 'es_prefer_juicer = cms.ESPrefer("JuiceProducer","juicer")\n')
465  juicer = ESPrefer("JuiceProducer",fooRcd=vstring())
466  self.assertEqual(juicer.dumpConfig(options),
467 """JuiceProducer {
468  vstring fooRcd = {
469  }
470 
471 }
472 """)
473  options = PrintOptions()
474  options.isCfg = True
475  self.assertEqual(juicer.dumpPythonAs("juicer"),
476 """process.prefer("JuiceProducer",
477  fooRcd = cms.vstring()
478 )
479 """)
480  options.isCfg = False
481  self.assertEqual(juicer.dumpPythonAs("juicer", options),
482 """es_prefer_JuiceProducer = cms.ESPrefer("JuiceProducer",
483  fooRcd = cms.vstring()
484 )
485 """)
vstring
vector< string > vstring
Definition: ExoticaDQM.cc:8
def Modules.TestModules.testIsTaskComponent (   self)

Definition at line 501 of file Modules.py.

References mps_fire.Path, and cmsswSequenceInfo.Sequence.

501 
502  def testIsTaskComponent(self):
503  m = EDProducer("x")
504  self.assertTrue(m._isTaskComponent())
505  self.assertTrue(m.isLeaf())
506  m = SwitchProducerTest(test1=EDProducer("x"))
507  self.assertTrue(m._isTaskComponent())
508  self.assertTrue(m.isLeaf())
509  m = EDFilter("x")
510  self.assertTrue(m._isTaskComponent())
511  self.assertTrue(m.isLeaf())
512  m = OutputModule("x")
513  self.assertFalse(m._isTaskComponent())
514  self.assertTrue(m.isLeaf())
515  m = EDAnalyzer("x")
516  self.assertFalse(m._isTaskComponent())
517  self.assertTrue(m.isLeaf())
518  m = Service("x")
519  self.assertTrue(m._isTaskComponent())
520  self.assertTrue(m.isLeaf())
521  m = ESProducer("x")
522  self.assertTrue(m._isTaskComponent())
523  self.assertTrue(m.isLeaf())
524  m = ESSource("x")
525  self.assertTrue(m._isTaskComponent())
526  self.assertTrue(m.isLeaf())
527  m = Sequence()
528  self.assertFalse(m._isTaskComponent())
529  self.assertFalse(m.isLeaf())
530  m = Path()
531  self.assertFalse(m._isTaskComponent())
532  m = EndPath()
533  self.assertFalse(m._isTaskComponent())
534  m = Task()
535  self.assertTrue(m._isTaskComponent())
536  self.assertFalse(m.isLeaf())
mps_fire.Path
tuple Path
Definition: mps_fire.py:298
def Modules.TestModules.testSequences (   self)

Definition at line 493 of file Modules.py.

References cmsswSequenceInfo.Sequence.

493 
494  def testSequences(self):
495  m = EDProducer("MProducer")
496  n = EDProducer("NProducer")
497  m.setLabel("m")
498  n.setLabel("n")
499  s1 = Sequence(m*n)
500  options = PrintOptions()
def Modules.TestModules.testService (   self)

Definition at line 486 of file Modules.py.

References AlCaHLTBitMon_QueryRunRegistry.string, and Types.untracked.

486 
487  def testService(self):
488  empty = Service("Empty")
489  withParam = Service("Parameterized",foo=untracked(int32(1)), bar = untracked(string("it")))
490  self.assertEqual(withParam.foo.value(), 1)
491  self.assertEqual(withParam.bar.value(), "it")
492  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")
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
Types.untracked
tuple untracked
Definition: Types.py:34
def Modules.TestModules.testSwitchProducer (   self)

Definition at line 537 of file Modules.py.

References AlCaHLTBitMon_QueryRunRegistry.string.

537 
538  def testSwitchProducer(self):
539  # Constructor
540  sp = SwitchProducerTest(test1 = EDProducer("Foo"), test2 = EDProducer("Bar"))
541  self.assertEqual(sp.test1.type_(), "Foo")
542  self.assertEqual(sp.test2.type_(), "Bar")
543  self.assertRaises(ValueError, lambda: SwitchProducerTest(nonexistent = EDProducer("Foo")))
544  self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = EDAnalyzer("Foo")))
545  self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = EDFilter("Foo")))
546  self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = Source("Foo")))
547  self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = OutputModule("Foo")))
548  self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = Looper("Foo")))
549  self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = Service("Foo")))
550  self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = ESSource("Foo")))
551  self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = ESProducer("Foo")))
552  self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = ESPrefer("Foo")))
553  self.assertRaises(TypeError, lambda: SwitchProducerTest(test1 = SwitchProducerTest(test1 = EDProducer("Foo"))))
554 
555  # Case decision
556  accelerators = ["test1", "test2", "test3"]
557  sp = SwitchProducerTest(test1 = EDProducer("Foo"), test2 = EDProducer("Bar"))
558  self.assertEqual(sp._getProducer(["test1", "test2", "test3"]).type_(), "Bar")
559  self.assertEqual(sp._getProducer(["test2", "test3"]).type_(), "Bar")
560  self.assertEqual(sp._getProducer(["test1", "test3"]).type_(), "Foo")
561  sp = SwitchProducerTest(test1 = EDProducer("Bar"))
562  self.assertEqual(sp._getProducer(["test1", "test2", "test3"]).type_(), "Bar")
563  self.assertRaises(RuntimeError, sp._getProducer, ["test2", "test3"])
564 
565  # Mofications
566  from .Types import int32, string, PSet
567  sp = SwitchProducerTest(test1 = EDProducer("Foo",
568  a = int32(1),
569  b = PSet(c = int32(2))),
570  test2 = EDProducer("Bar",
571  aa = int32(11),
572  bb = PSet(cc = int32(12))))
573  # Simple clone
574  cl = sp.clone()
575  self.assertEqual(cl.test1.type_(), "Foo")
576  self.assertEqual(cl.test1.a.value(), 1)
577  self.assertEqual(cl.test1.b.c.value(), 2)
578  self.assertEqual(cl.test2.type_(), "Bar")
579  self.assertEqual(cl.test2.aa.value(), 11)
580  self.assertEqual(cl.test2.bb.cc.value(), 12)
581  self.assertEqual(sp._getProducer(accelerators).type_(), "Bar")
582  # Modify clone
583  cl.test1.a = 3
584  self.assertEqual(cl.test1.a.value(), 3)
585  cl.test1 = EDProducer("Fred")
586  self.assertEqual(cl.test1.type_(), "Fred")
587  def _assignEDAnalyzer():
588  cl.test1 = EDAnalyzer("Foo")
589  self.assertRaises(TypeError, _assignEDAnalyzer)
590  def _assignSwitchProducer():
591  cl.test1 = SwitchProducerTest(test1 = SwitchProducerTest(test1 = EDProducer("Foo")))
592  self.assertRaises(TypeError, _assignSwitchProducer)
593  # Modify values with a dict
594  cl = sp.clone(test1 = dict(a = 4, b = dict(c = None)),
595  test2 = dict(aa = 15, bb = dict(cc = 45, dd = string("foo"))))
596  self.assertEqual(cl.test1.a.value(), 4)
597  self.assertEqual(cl.test1.b.hasParameter("c"), False)
598  self.assertEqual(cl.test2.aa.value(), 15)
599  self.assertEqual(cl.test2.bb.cc.value(), 45)
600  self.assertEqual(cl.test2.bb.dd.value(), "foo")
601  # Replace/add/remove EDProducers
602  cl = sp.clone(test1 = EDProducer("Fred", x = int32(42)),
603  test3 = EDProducer("Wilma", y = int32(24)),
604  test2 = None)
605  self.assertEqual(cl.test1.type_(), "Fred")
606  self.assertEqual(cl.test1.x.value(), 42)
607  self.assertEqual(cl.test3.type_(), "Wilma")
608  self.assertEqual(cl.test3.y.value(), 24)
609  self.assertEqual(hasattr(cl, "test2"), False)
610  self.assertRaises(TypeError, lambda: sp.clone(test1 = EDAnalyzer("Foo")))
611  self.assertRaises(TypeError, lambda: sp.clone(test1 = SwitchProducerTest(test1 = SwitchProducerTest(test1 = EDProducer("Foo")))))
612 
613  # Dump
614  sp = SwitchProducerTest(test2 = EDProducer("Foo",
615  a = int32(1),
616  b = PSet(c = int32(2))),
617  test1 = EDProducer("Bar",
618  aa = int32(11),
619  bb = PSet(cc = int32(12))))
620  self.assertEqual(sp.dumpPython(),
621 """SwitchProducerTest(
622  test1 = cms.EDProducer("Bar",
623  aa = cms.int32(11),
624  bb = cms.PSet(
625  cc = cms.int32(12)
626  )
627  ),
628  test2 = cms.EDProducer("Foo",
629  a = cms.int32(1),
630  b = cms.PSet(
631  c = cms.int32(2)
632  )
633  )
634 )
635 """)
636  # Pickle
637  import pickle
638  sp = SwitchProducerPickleable(cpu = EDProducer("Foo"))
639  pkl = pickle.dumps(sp)
640  unpkl = pickle.loads(pkl)
641  self.assertEqual(unpkl.cpu.type_(), "Foo")
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
def Modules.TestModules.testSwithProducerWithAlias (   self)

Definition at line 642 of file Modules.py.

References AlCaHLTBitMon_QueryRunRegistry.string, and HistogramManager_cfi.VPSet().

642 
643  def testSwithProducerWithAlias(self):
644  # Constructor
645  sp = SwitchProducerTest(test1 = EDProducer("Foo"), test2 = EDAlias())
646  self.assertEqual(sp.test1.type_(), "Foo")
647  self.assertTrue(isinstance(sp.test2, EDAlias))
648 
649  # Modifications
650  from .Types import int32, string, PSet, VPSet
651  sp = SwitchProducerTest(test1 = EDProducer("Foo"),
652  test2 = EDAlias(foo = VPSet(PSet(type = string("Foo2")))))
653 
654  # Simple clone
655  cl = sp.clone()
656  self.assertTrue(hasattr(cl.test2, "foo"))
657  # Modify clone
658  cl.test2.foo[0].type = "Foo3"
659  self.assertEqual(cl.test2.foo[0].type, "Foo3")
660  # Modify values with a dict
661  cl = sp.clone(test2 = dict(foo = {0: dict(type = "Foo4")}))
662  self.assertEqual(cl.test2.foo[0].type, "Foo4")
663  # Replace or add EDAlias
664  cl = sp.clone(test1 = EDAlias(foo = VPSet(PSet(type = string("Foo5")))),
665  test3 = EDAlias(foo = VPSet(PSet(type = string("Foo6")))))
666  self.assertEqual(cl.test1.foo[0].type, "Foo5")
667  self.assertEqual(cl.test3.foo[0].type, "Foo6")
668  # Modify clone
669  cl.test1 = EDProducer("Xyzzy")
670  self.assertEqual(cl.test1.type_(), "Xyzzy")
671  cl.test1 = EDAlias(foo = VPSet(PSet(type = string("Foo7"))))
672  self.assertEqual(cl.test1.foo[0].type, "Foo7")
673 
674 
675  # Dump
676  from .Types import int32, string, PSet, VPSet
677  sp = SwitchProducerTest(test1 = EDProducer("Foo"),
678  test2 = EDAlias(foo = VPSet(PSet(type = string("Foo2")))))
679 
680  self.assertEqual(sp.dumpPython(),
681 """SwitchProducerTest(
682  test1 = cms.EDProducer("Foo"),
683  test2 = cms.EDAlias(
684  foo = cms.VPSet(cms.PSet(
685  type = cms.string('Foo2')
686  ))
687  )
688 )
689 """)
690 
691  # Pickle
692  import pickle
693  sp = SwitchProducerPickleable(cpu = EDAlias(foo = VPSet(PSet(type = string("Foo2")))))
694  pkl = pickle.dumps(sp)
695  unpkl = pickle.loads(pkl)
696  self.assertEqual(sp.cpu.foo[0].type, "Foo2")
unittest.main()
HistogramManager_cfi.VPSet
def VPSet
Definition: HistogramManager_cfi.py:408
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
Modules.TestModules.testSwithProducerWithAlias
def testSwithProducerWithAlias
Definition: Modules.py:642
Generated for CMSSW Reference Manual by doxygen 1.8.5