test
CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Public Attributes | Static Public Attributes
Config.TestModuleCommand Class Reference
Inheritance diagram for Config.TestModuleCommand:

Public Member Functions

def setUp
 
def testCloneSequence
 
def testExamples
 
def testFreeze
 
def testGlobalReplace
 
def testImplicitSchedule
 
def testModifier
 
def testOverride
 
def testParameterizable
 
def testPath
 
def testPrefers
 
def testProcessDumpPython
 
def testProcessExtend
 
def testProcessInsertion
 
def testPrune
 
def testRefToPSet
 
def testSchedule
 
def testSecSource
 
def testSequence
 
def testSequence2
 
def testSubProcess
 
def testTypedParameterizable
 
def testUsing
 

Public Attributes

 a
 
 proc_mod_
 

Static Public Attributes

tuple a = EDProducer("A")
 
tuple d = p.dumpPython()
 
tuple p = Process("test")
 
tuple process = Process("DUMP")
 
tuple s = Sequence(p.a)
 
tuple s1 = Sequence(s)
 
tuple s2 = Sequence(a)
 

Detailed Description

Definition at line 1318 of file Config.py.

Member Function Documentation

def Config.TestModuleCommand.setUp (   self) 
Nothing to do

Definition at line 1319 of file Config.py.

1319 
1320  def setUp(self):
1321  """Nothing to do """
None
def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 1656 of file Config.py.

1656 
1657  def testCloneSequence(self):
1658  p = Process("test")
1659  a = EDAnalyzer("MyAnalyzer")
1660  p.a = a
1661  a.setLabel("a")
1662  b = EDAnalyzer("YOurAnalyzer")
1663  p.b = b
1664  b.setLabel("b")
1665  path = Path(a * b)
1666  p.path = Path(p.a*p.b)
1667  lookuptable = {id(a): p.a, id(b): p.b}
1668  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1669  #lookuptable = p._cloneToObjectDict
1670  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1671  self.assertEqual(str(path),str(p.path))
def Config.TestModuleCommand.testExamples (   self)

Definition at line 1789 of file Config.py.

References Types.untracked.

1789 
1790  def testExamples(self):
1791  p = Process("Test")
1792  p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
1793  p.foos = EDProducer("FooProducer")
1794  p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
1795  p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
1796  p.bars.foos = 'Foosball'
1797  self.assertEqual(p.bars.foos, InputTag('Foosball'))
1798  p.p = Path(p.foos*p.bars)
1799  p.e = EndPath(p.out)
1800  p.add_(Service("MessageLogger"))
Types.untracked
tuple untracked
Definition: Types.py:27
def Config.TestModuleCommand.testFreeze (   self)

Definition at line 1855 of file Config.py.

1855 
1856  def testFreeze(self):
1857  process = Process("Freeze")
1858  m = EDProducer("M", p=PSet(i = int32(1)))
1859  m.p.i = 2
1860  process.m = m
1861  # should be frozen
1862  #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
1863  #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
1864  #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
1865  #self.assertRaises(ValueError, setattr, m, 'j', 1)
1866  # But OK to change through the process
1867  process.m.p.i = 4
1868  self.assertEqual(process.m.p.i.value(), 4)
1869  process.m.p = PSet(j=int32(1))
1870  # should work to clone it, though
1871  m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
1872  m2.p.i = 6
m2.j = 8
def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 1599 of file Config.py.

1599 
1600  def testGlobalReplace(self):
1601  p = Process('test')
1602  p.a = EDAnalyzer("MyAnalyzer")
1603  p.b = EDAnalyzer("YourAnalyzer")
1604  p.c = EDAnalyzer("OurAnalyzer")
1605  p.s = Sequence(p.a*p.b)
1606  p.p = Path(p.c+p.s+p.a)
1607  new = EDAnalyzer("NewAnalyzer")
1608  p.globalReplace("a",new)
def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 1726 of file Config.py.

1726 
1727  def testImplicitSchedule(self):
1728  p = Process("test")
1729  p.a = EDAnalyzer("MyAnalyzer")
1730  p.b = EDAnalyzer("YourAnalyzer")
1731  p.c = EDAnalyzer("OurAnalyzer")
1732  p.path1 = Path(p.a)
1733  p.path2 = Path(p.b)
1734  self.assert_(p.schedule is None)
1735  pths = p.paths
1736  keys = pths.keys()
1737  self.assertEqual(pths[keys[0]],p.path1)
1738  self.assertEqual(pths[keys[1]],p.path2)
1739  p.prune()
1740  self.assert_(hasattr(p, 'a'))
1741  self.assert_(hasattr(p, 'b'))
1742  self.assert_(not hasattr(p, 'c'))
1743  self.assert_(hasattr(p, 'path1'))
1744  self.assert_(hasattr(p, 'path2'))
1745 
1746 
1747  p = Process("test")
1748  p.a = EDAnalyzer("MyAnalyzer")
1749  p.b = EDAnalyzer("YourAnalyzer")
1750  p.c = EDAnalyzer("OurAnalyzer")
1751  p.path2 = Path(p.b)
1752  p.path1 = Path(p.a)
1753  self.assert_(p.schedule is None)
1754  pths = p.paths
1755  keys = pths.keys()
1756  self.assertEqual(pths[keys[1]],p.path1)
1757  self.assertEqual(pths[keys[0]],p.path2)
1758 
def Config.TestModuleCommand.testModifier (   self)

Definition at line 2012 of file Config.py.

References cmsPerfStripChart.dict.

2012 
2013  def testModifier(self):
2014  m1 = Modifier()
2015  p = Process("test",m1)
2016  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
2017  def _mod_fred(obj):
2018  obj.fred = 2
2019  m1.toModify(p.a,_mod_fred)
2020  self.assertEqual(p.a.fred.value(),2)
2021  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
2022  m1.toModify(p.b, wilma = 2)
2023  self.assertEqual(p.b.wilma.value(),2)
2024  #check that Modifier not attached to a process doesn't run
2025  m1 = Modifier()
2026  p = Process("test")
2027  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
2028  m1.toModify(p.a,_mod_fred)
2029  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
2030  m1.toModify(p.b, wilma = 2)
2031  self.assertEqual(p.a.fred.value(),1)
2032  self.assertEqual(p.b.wilma.value(),1)
2033  #make sure clones get the changes
2034  m1 = Modifier()
2035  p = Process("test",m1)
2036  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2037  m1.toModify(p.a, fred = int32(2))
2038  p.b = p.a.clone(wilma = int32(3))
2039  self.assertEqual(p.a.fred.value(),2)
2040  self.assertEqual(p.a.wilma.value(),1)
2041  self.assertEqual(p.b.fred.value(),2)
2042  self.assertEqual(p.b.wilma.value(),3)
2043  #test removal of parameter
2044  m1 = Modifier()
2045  p = Process("test",m1)
2046  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2047  m1.toModify(p.a, fred = None)
2048  self.assertEqual(hasattr(p.a, "fred"), False)
2049  self.assertEqual(p.a.wilma.value(),1)
2050  #test adding a parameter
2051  m1 = Modifier()
2052  p = Process("test",m1)
2053  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
2054  m1.toModify(p.a, wilma = int32(2))
2055  self.assertEqual(p.a.fred.value(), 1)
2056  self.assertEqual(p.a.wilma.value(),2)
2057  #test setting of value in PSet
2058  m1 = Modifier()
2059  p = Process("test",m1)
2060  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = int32(1), wilma = int32(1)))
2061  m1.toModify(p.a, flintstones = dict(fred = int32(2)))
2062  self.assertEqual(p.a.flintstones.fred.value(),2)
2063  self.assertEqual(p.a.flintstones.wilma.value(),1)
2064  #test that load causes process wide methods to run
2065  def _rem_a(proc):
2066  del proc.a
2067  class ProcModifierMod(object):
2068  def __init__(self,modifier,func):
2069  self.proc_mod_ = modifier.makeProcessModifier(func)
2070  class DummyMod(object):
2071  def __init__(self):
2072  self.a = EDAnalyzer("Dummy")
2073  testMod = DummyMod()
2074  p.extend(testMod)
2075  self.assert_(hasattr(p,"a"))
2076  m1 = Modifier()
2077  p = Process("test",m1)
2078  testProcMod = ProcModifierMod(m1,_rem_a)
2079  p.extend(testMod)
2080  p.extend(testProcMod)
2081  self.assert_(not hasattr(p,"a"))
2082  #test ModifierChain
2083  m1 = Modifier()
2084  mc = ModifierChain(m1)
2085  p = Process("test",mc)
2086  testMod = DummyMod()
2087  p.b = EDAnalyzer("Dummy2", fred = int32(1))
2088  m1.toModify(p.b, fred = int32(3))
2089  p.extend(testMod)
2090  testProcMod = ProcModifierMod(m1,_rem_a)
2091  p.extend(testProcMod)
2092  self.assert_(not hasattr(p,"a"))
2093  self.assertEqual(p.b.fred.value(),3)
2094  #check combining
2095  m1 = Modifier()
2096  m2 = Modifier()
2097  p = Process("test",m1)
2098  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2099  (m1 & m2).toModify(p.a, fred = int32(2))
2100  self.assertEqual(p.a.fred, 1)
2101  m1 = Modifier()
2102  m2 = Modifier()
2103  p = Process("test",m1,m2)
2104  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2105  (m1 & m2).toModify(p.a, fred = int32(2))
2106  self.assertEqual(p.a.fred, 2)
2107  m1 = Modifier()
2108  m2 = Modifier()
2109  m3 = Modifier()
2110  p = Process("test",m1,m2,m3)
2111  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2112  (m1 & m2 & m3).toModify(p.a, fred = int32(2))
2113  self.assertEqual(p.a.fred, 2)
2114  #check toReplaceWith
2115  m1 = Modifier()
2116  p = Process("test",m1)
2117  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
2118  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
2119  p.b =EDAnalyzer("BAn")
2120  p.s = Sequence(p.a)
2121  m1.toReplaceWith(p.s, Sequence(p.a+p.b))
2122  self.assertEqual(p.a.wilma.value(),3)
2123  self.assertEqual(p.a.type_(),"YourAnalyzer")
2124  self.assertEqual(hasattr(p,"fred"),False)
2125  self.assertEqual(p.s.dumpPython(""),"cms.Sequence(process.a+process.b)\n")
2126  #check toReplaceWith doesn't activate not chosen
2127  m1 = Modifier()
2128  p = Process("test")
2129  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
2130  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
2131  self.assertEqual(p.a.type_(),"MyAnalyzer")
unittest.main()
def Config.TestModuleCommand.testOverride (   self)

Definition at line 1766 of file Config.py.

1766 
1767  def testOverride(self):
1768  p = Process('test')
1769  a = EDProducer("A", a1=int32(0))
1770  self.assert_(not a.isModified())
1771  a.a1 = 1
1772  self.assert_(a.isModified())
1773  p.a = a
1774  self.assertEqual(p.a.a1.value(), 1)
1775  # try adding an unmodified module.
1776  # should accept it
1777  p.a = EDProducer("A", a1=int32(2))
1778  self.assertEqual(p.a.a1.value(), 2)
1779  # try adding a modified module. Should throw
1780  # no longer, since the same (modified) say, geometry
1781  # could come from more than one cff
1782  b = EDProducer("A", a1=int32(3))
1783  b.a1 = 4
1784  #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
1785  ps1 = PSet(a = int32(1))
1786  ps2 = PSet(a = int32(2))
1787  self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
1788  self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 1322 of file Config.py.

1322 
1323  def testParameterizable(self):
1324  p = _Parameterizable()
1325  self.assertEqual(len(p.parameterNames_()),0)
1326  p.a = int32(1)
1327  self.assert_('a' in p.parameterNames_())
1328  self.assertEqual(p.a.value(), 1)
1329  p.a = 10
1330  self.assertEqual(p.a.value(), 10)
1331  p.a = untracked(int32(1))
1332  self.assertEqual(p.a.value(), 1)
1333  self.failIf(p.a.isTracked())
1334  p.a = untracked.int32(1)
1335  self.assertEqual(p.a.value(), 1)
1336  self.failIf(p.a.isTracked())
1337  p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
1338  self.assertEqual(p.foo.value(), 10)
1339  self.assertEqual(p.bar.value(),1.0)
1340  self.failIf(p.bar.isTracked())
1341  self.assertRaises(TypeError,setattr,(p,'c',1))
1342  p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
1343  self.assertEqual(p.a.foo.value(),10)
1344  self.assertEqual(p.a.bar.value(),1.0)
1345  p.b = untracked(PSet(fii = int32(1)))
1346  self.assertEqual(p.b.fii.value(),1)
1347  self.failIf(p.b.isTracked())
1348  #test the fact that values can be shared
1349  v = int32(10)
1350  p=_Parameterizable(a=v)
1351  v.setValue(11)
1352  self.assertEqual(p.a.value(),11)
1353  p.a = 12
1354  self.assertEqual(p.a.value(),12)
self.assertEqual(v.value(),12)
Mixins._Parameterizable
Definition: Mixins.py:108
Types.untracked
tuple untracked
Definition: Types.py:27
def Config.TestModuleCommand.testPath (   self)

Definition at line 1634 of file Config.py.

1634 
1635  def testPath(self):
1636  p = Process("test")
1637  p.a = EDAnalyzer("MyAnalyzer")
1638  p.b = EDAnalyzer("YourAnalyzer")
1639  p.c = EDAnalyzer("OurAnalyzer")
1640  path = Path(p.a)
1641  path *= p.b
1642  path += p.c
1643  self.assertEqual(str(path),'a+b+c')
1644  path = Path(p.a*p.b+p.c)
1645  self.assertEqual(str(path),'a+b+c')
1646 # path = Path(p.a)*p.b+p.c #This leads to problems with sequences
1647 # self.assertEqual(str(path),'((a*b)+c)')
1648  path = Path(p.a+ p.b*p.c)
1649  self.assertEqual(str(path),'a+b+c')
1650  path = Path(p.a*(p.b+p.c))
1651  self.assertEqual(str(path),'a+b+c')
1652  path = Path(p.a*(p.b+~p.c))
1653  self.assertEqual(str(path),'a+b+~c')
1654  p.es = ESProducer("AnESProducer")
1655  self.assertRaises(TypeError,Path,p.es)
def Config.TestModuleCommand.testPrefers (   self)

Definition at line 1801 of file Config.py.

1801 
1802  def testPrefers(self):
1803  p = Process("Test")
1804  p.add_(ESSource("ForceSource"))
1805  p.juicer = ESProducer("JuicerProducer")
1806  p.prefer("ForceSource")
1807  p.prefer("juicer")
1808  self.assertEqual(p.dumpConfig(),
1809 """process Test = {
1810  es_module juicer = JuicerProducer {
1811  }
1812  es_source = ForceSource {
1813  }
1814  es_prefer = ForceSource {
1815  }
1816  es_prefer juicer = JuicerProducer {
1817  }
1818 }
1819 """)
1820  p.prefer("juicer",fooRcd=vstring("Foo"))
1821  self.assertEqual(p.dumpConfig(),
1822 """process Test = {
1823  es_module juicer = JuicerProducer {
1824  }
1825  es_source = ForceSource {
1826  }
1827  es_prefer = ForceSource {
1828  }
1829  es_prefer juicer = JuicerProducer {
1830  vstring fooRcd = {
1831  'Foo'
1832  }
1833 
1834  }
1835 }
1836 """)
1837  self.assertEqual(p.dumpPython(),
1838 """import FWCore.ParameterSet.Config as cms
1839 
1840 process = cms.Process("Test")
1841 
1842 process.juicer = cms.ESProducer("JuicerProducer")
1843 
1844 
1845 process.ForceSource = cms.ESSource("ForceSource")
1846 
1847 
1848 process.prefer("ForceSource")
1849 
1850 process.prefer("juicer",
1851  fooRcd = cms.vstring('Foo')
1852 )
1853 
1854 """)
def Config.TestModuleCommand.testProcessDumpPython (   self)

Definition at line 1457 of file Config.py.

1457 
1458  def testProcessDumpPython(self):
1459  p = Process("test")
1460  p.a = EDAnalyzer("MyAnalyzer")
1461  p.p = Path(p.a)
1462  p.s = Sequence(p.a)
1463  p.r = Sequence(p.s)
1464  p.p2 = Path(p.s)
1465  p.schedule = Schedule(p.p2,p.p)
1466  d=p.dumpPython()
1467  self.assertEqual(d,
1468 """import FWCore.ParameterSet.Config as cms
1469 
1470 process = cms.Process("test")
1471 
1472 process.a = cms.EDAnalyzer("MyAnalyzer")
1473 
1474 
1475 process.s = cms.Sequence(process.a)
1476 
1477 
1478 process.r = cms.Sequence(process.s)
1479 
1480 
1481 process.p = cms.Path(process.a)
1482 
1483 
1484 process.p2 = cms.Path(process.s)
1485 
1486 
1487 process.schedule = cms.Schedule(*[ process.p2, process.p ])
1488 """)
1489  #Reverse order of 'r' and 's'
1490  p = Process("test")
1491  p.a = EDAnalyzer("MyAnalyzer")
1492  p.p = Path(p.a)
1493  p.r = Sequence(p.a)
1494  p.s = Sequence(p.r)
1495  p.p2 = Path(p.r)
1496  p.schedule = Schedule(p.p2,p.p)
1497  p.b = EDAnalyzer("YourAnalyzer")
1498  d=p.dumpPython()
1499  self.assertEqual(d,
1500 """import FWCore.ParameterSet.Config as cms
1501 
1502 process = cms.Process("test")
1503 
1504 process.a = cms.EDAnalyzer("MyAnalyzer")
1505 
1506 
1507 process.b = cms.EDAnalyzer("YourAnalyzer")
1508 
1509 
1510 process.r = cms.Sequence(process.a)
1511 
1512 
1513 process.s = cms.Sequence(process.r)
1514 
1515 
1516 process.p = cms.Path(process.a)
1517 
1518 
1519 process.p2 = cms.Path(process.r)
1520 
1521 
1522 process.schedule = cms.Schedule(*[ process.p2, process.p ])
""")
def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 1387 of file Config.py.

1387 
1388  def testProcessExtend(self):
1389  class FromArg(object):
1390  def __init__(self,*arg,**args):
1391  for name in args.iterkeys():
1392  self.__dict__[name]=args[name]
1393 
1394  a=EDAnalyzer("MyAnalyzer")
1395  t=EDAnalyzer("MyAnalyzer")
1396  t.setLabel("foo")
1397  s1 = Sequence(a)
1398  s2 = Sequence(s1)
1399  s3 = Sequence(s2)
1400  d = FromArg(
1401  a=a,
1402  b=Service("Full"),
1403  c=Path(a),
1404  d=s2,
1405  e=s1,
1406  f=s3,
1407  g=Sequence(s1+s2+s3)
1408  )
1409  p = Process("Test")
1410  p.extend(d)
1411  self.assertEqual(p.a.type_(),"MyAnalyzer")
1412  self.assertEqual(p.a.label_(),"a")
1413  self.assertRaises(AttributeError,getattr,p,'b')
1414  self.assertEqual(p.Full.type_(),"Full")
1415  self.assertEqual(str(p.c),'a')
1416  self.assertEqual(str(p.d),'a')
1417 
1418  z1 = FromArg(
1419  a=a,
1420  b=Service("Full"),
1421  c=Path(a),
1422  d=s2,
1423  e=s1,
1424  f=s3,
1425  s4=s3,
1426  g=Sequence(s1+s2+s3)
1427  )
1428 
1429  p1 = Process("Test")
1430  #p1.extend(z1)
1431  self.assertRaises(ValueError, p1.extend, z1)
1432 
1433  z2 = FromArg(
1434  a=a,
1435  b=Service("Full"),
1436  c=Path(a),
1437  d=s2,
1438  e=s1,
1439  f=s3,
1440  aaa=copy.deepcopy(a),
1441  s4=copy.deepcopy(s3),
1442  g=Sequence(s1+s2+s3),
1443  t=t
1444  )
1445  p2 = Process("Test")
1446  p2.extend(z2)
1447  #self.assertRaises(ValueError, p2.extend, z2)
1448  self.assertEqual(p2.s4.label_(),"s4")
1449  #p2.s4.setLabel("foo")
1450  self.assertRaises(ValueError, p2.s4.setLabel, "foo")
1451  p2.s4.setLabel("s4")
1452  p2.s4.setLabel(None)
1453  p2.s4.setLabel("foo")
1454  p2._Process__setObjectLabel(p2.s4, "foo")
1455  p2._Process__setObjectLabel(p2.s4, None)
1456  p2._Process__setObjectLabel(p2.s4, "bar")
def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 1362 of file Config.py.

1362 
1363  def testProcessInsertion(self):
1364  p = Process("test")
1365  p.a = EDAnalyzer("MyAnalyzer")
1366  self.assert_( 'a' in p.analyzers_() )
1367  self.assert_( 'a' in p.analyzers)
1368  p.add_(Service("MessageLogger"))
1369  self.assert_('MessageLogger' in p.services_())
1370  self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
1371  p.Tracer = Service("Tracer")
1372  self.assert_('Tracer' in p.services_())
1373  self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
1374  self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
1375  self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
1376  p.out = OutputModule("Outer")
1377  self.assertEqual(p.out.type_(), 'Outer')
1378  self.assert_( 'out' in p.outputModules_() )
1379 
1380  p.geom = ESSource("GeomProd")
1381  self.assert_('geom' in p.es_sources_())
1382  p.add_(ESSource("ConfigDB"))
1383  self.assert_('ConfigDB' in p.es_sources_())
1384 
1385  p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
1386  self.assert_('aliasfoo1' in p.aliases_())
def Config.TestModuleCommand.testPrune (   self)

Definition at line 1929 of file Config.py.

1929 
1930  def testPrune(self):
1931  p = Process("test")
1932  p.a = EDAnalyzer("MyAnalyzer")
1933  p.b = EDAnalyzer("YourAnalyzer")
1934  p.c = EDAnalyzer("OurAnalyzer")
1935  p.d = EDAnalyzer("OurAnalyzer")
1936  p.s = Sequence(p.d)
1937  p.path1 = Path(p.a)
1938  p.path2 = Path(p.b)
1939  self.assert_(p.schedule is None)
1940  pths = p.paths
1941  keys = pths.keys()
1942  self.assertEqual(pths[keys[0]],p.path1)
1943  self.assertEqual(pths[keys[1]],p.path2)
1944  p.pset1 = PSet(parA = string("pset1"))
1945  p.pset2 = untracked.PSet(parA = string("pset2"))
1946  p.vpset1 = VPSet()
1947  p.vpset2 = untracked.VPSet()
1948  p.prune()
1949  self.assert_(hasattr(p, 'a'))
1950  self.assert_(hasattr(p, 'b'))
1951  self.assert_(not hasattr(p, 'c'))
1952  self.assert_(not hasattr(p, 'd'))
1953  self.assert_(not hasattr(p, 's'))
1954  self.assert_(hasattr(p, 'path1'))
1955  self.assert_(hasattr(p, 'path2'))
1956 # self.assert_(not hasattr(p, 'pset1'))
1957 # self.assert_(hasattr(p, 'pset2'))
1958 # self.assert_(not hasattr(p, 'vpset1'))
1959 # self.assert_(not hasattr(p, 'vpset2'))
1960 
1961  p = Process("test")
1962  p.a = EDAnalyzer("MyAnalyzer")
1963  p.b = EDAnalyzer("YourAnalyzer")
1964  p.c = EDAnalyzer("OurAnalyzer")
1965  p.d = EDAnalyzer("OurAnalyzer")
1966  p.e = EDAnalyzer("OurAnalyzer")
1967  p.s = Sequence(p.d)
1968  p.s2 = Sequence(p.b)
1969  p.s3 = Sequence(p.e)
1970  p.path1 = Path(p.a)
1971  p.path2 = Path(p.b)
1972  p.path3 = Path(p.b+p.s2)
1973  p.path4 = Path(p.b+p.s3)
1974  p.schedule = Schedule(p.path1,p.path2,p.path3)
1975  pths = p.paths
1976  keys = pths.keys()
1977  self.assertEqual(pths[keys[0]],p.path1)
1978  self.assertEqual(pths[keys[1]],p.path2)
1979  p.prune()
1980  self.assert_(hasattr(p, 'a'))
1981  self.assert_(hasattr(p, 'b'))
1982  self.assert_(not hasattr(p, 'c'))
1983  self.assert_(not hasattr(p, 'd'))
1984  self.assert_(not hasattr(p, 'e'))
1985  self.assert_(not hasattr(p, 's'))
1986  self.assert_(hasattr(p, 's2'))
1987  self.assert_(not hasattr(p, 's3'))
1988  self.assert_(hasattr(p, 'path1'))
1989  self.assert_(hasattr(p, 'path2'))
1990  self.assert_(hasattr(p, 'path3'))
1991  self.assert_(not hasattr(p, 'path4'))
1992  #test SequencePlaceholder
1993  p = Process("test")
1994  p.a = EDAnalyzer("MyAnalyzer")
1995  p.b = EDAnalyzer("YourAnalyzer")
1996  p.s = Sequence(SequencePlaceholder("a")+p.b)
1997  p.pth = Path(p.s)
1998  p.prune()
1999  self.assert_(hasattr(p, 'a'))
2000  self.assert_(hasattr(p, 'b'))
2001  self.assert_(hasattr(p, 's'))
2002  self.assert_(hasattr(p, 'pth'))
2003  #test unresolved SequencePlaceholder
2004  p = Process("test")
2005  p.b = EDAnalyzer("YourAnalyzer")
2006  p.s = Sequence(SequencePlaceholder("a")+p.b)
2007  p.pth = Path(p.s)
2008  p.prune(keepUnresolvedSequencePlaceholders=True)
2009  self.assert_(hasattr(p, 'b'))
2010  self.assert_(hasattr(p, 's'))
2011  self.assert_(hasattr(p, 'pth'))
self.assertEqual(p.s.dumpPython(''),'cms.Sequence(cms.SequencePlaceholder("a")+process.b)\n')
def Config.TestModuleCommand.testRefToPSet (   self)

Definition at line 1913 of file Config.py.

1913 
1914  def testRefToPSet(self):
1915  proc = Process("test")
1916  proc.top = PSet(a = int32(1))
1917  proc.ref = PSet(refToPSet_ = string("top"))
1918  proc.ref2 = PSet( a = int32(1), b = PSet( refToPSet_ = string("top")))
1919  proc.ref3 = PSet(refToPSet_ = string("ref"))
1920  proc.ref4 = VPSet(PSet(refToPSet_ = string("top")),
1921  PSet(refToPSet_ = string("ref2")))
1922  p = TestMakePSet()
1923  proc.fillProcessDesc(p)
1924  self.assertEqual((True,1),p.values["ref"][1].values["a"])
1925  self.assertEqual((True,1),p.values["ref3"][1].values["a"])
1926  self.assertEqual((True,1),p.values["ref2"][1].values["a"])
1927  self.assertEqual((True,1),p.values["ref2"][1].values["b"][1].values["a"])
1928  self.assertEqual((True,1),p.values["ref4"][1][0].values["a"])
self.assertEqual((True,1),p.values["ref4"][1][1].values["a"])
def Config.TestModuleCommand.testSchedule (   self)

Definition at line 1672 of file Config.py.

1672 
1673  def testSchedule(self):
1674  p = Process("test")
1675  p.a = EDAnalyzer("MyAnalyzer")
1676  p.b = EDAnalyzer("YourAnalyzer")
1677  p.c = EDAnalyzer("OurAnalyzer")
1678  p.d = EDAnalyzer("OurAnalyzer")
1679  p.path1 = Path(p.a)
1680  p.path2 = Path(p.b)
1681  p.path3 = Path(p.d)
1682 
1683  s = Schedule(p.path1,p.path2)
1684  self.assertEqual(s[0],p.path1)
1685  self.assertEqual(s[1],p.path2)
1686  p.schedule = s
1687  self.assert_('b' in p.schedule.moduleNames())
1688  self.assert_(hasattr(p, 'b'))
1689  self.assert_(hasattr(p, 'c'))
1690  self.assert_(hasattr(p, 'd'))
1691  self.assert_(hasattr(p, 'path1'))
1692  self.assert_(hasattr(p, 'path2'))
1693  self.assert_(hasattr(p, 'path3'))
1694  p.prune()
1695  self.assert_('b' in p.schedule.moduleNames())
1696  self.assert_(hasattr(p, 'b'))
1697  self.assert_(not hasattr(p, 'c'))
1698  self.assert_(not hasattr(p, 'd'))
1699  self.assert_(hasattr(p, 'path1'))
1700  self.assert_(hasattr(p, 'path2'))
1701  self.assert_(not hasattr(p, 'path3'))
1702 
1703  #adding a path not attached to the Process should cause an exception
1704  p = Process("test")
1705  p.a = EDAnalyzer("MyAnalyzer")
1706  path1 = Path(p.a)
1707  s = Schedule(path1)
1708  self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
1709 
1710  #make sure anonymous sequences work
1711  p = Process("test")
1712  p.a = EDAnalyzer("MyAnalyzer")
1713  p.b = EDAnalyzer("MyOtherAnalyzer")
1714  p.c = EDProducer("MyProd")
1715  path1 = Path(p.c*Sequence(p.a+p.b))
1716  s = Schedule(path1)
1717  self.assert_('a' in s.moduleNames())
1718  self.assert_('b' in s.moduleNames())
1719  self.assert_('c' in s.moduleNames())
1720  p.path1 = path1
1721  p.schedule = s
1722  p.prune()
1723  self.assert_('a' in s.moduleNames())
1724  self.assert_('b' in s.moduleNames())
1725  self.assert_('c' in s.moduleNames())
def Config.TestModuleCommand.testSecSource (   self)

Definition at line 1594 of file Config.py.

References python.rootplot.root2matplotlib.replace().

1594 
1595  def testSecSource(self):
1596  p = Process('test')
1597  p.a = SecSource("MySecSource")
1598  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 1609 of file Config.py.

1609 
1610  def testSequence(self):
1611  p = Process('test')
1612  p.a = EDAnalyzer("MyAnalyzer")
1613  p.b = EDAnalyzer("YourAnalyzer")
1614  p.c = EDAnalyzer("OurAnalyzer")
1615  p.s = Sequence(p.a*p.b)
1616  self.assertEqual(str(p.s),'a+b')
1617  self.assertEqual(p.s.label_(),'s')
1618  path = Path(p.c+p.s)
1619  self.assertEqual(str(path),'c+a+b')
1620  p._validateSequence(path, 'p1')
1621  notInProcess = EDAnalyzer('NotInProcess')
1622  p2 = Path(p.c+p.s*notInProcess)
1623  self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
def Config.TestModuleCommand.testSequence2 (   self)

Definition at line 1624 of file Config.py.

1624 
1625  def testSequence2(self):
1626  p = Process('test')
1627  p.a = EDAnalyzer("MyAnalyzer")
1628  p.b = EDAnalyzer("YourAnalyzer")
1629  p.c = EDAnalyzer("OurAnalyzer")
1630  testseq = Sequence(p.a*p.b)
1631  p.s = testseq
1632  #p.y = testseq
1633  self.assertRaises(ValueError, p.__setattr__, "y", testseq)
def Config.TestModuleCommand.testSubProcess (   self)

Definition at line 1873 of file Config.py.

References cond.hash.

1873 
1874  def testSubProcess(self):
1875  process = Process("Parent")
1876  subProcess = Process("Child")
1877  subProcess.a = EDProducer("A")
1878  subProcess.p = Path(subProcess.a)
1879  subProcess.add_(Service("Foo"))
1880  process.addSubProcess(SubProcess(subProcess))
1881  d = process.dumpPython()
1882  equalD ="""import FWCore.ParameterSet.Config as cms
1883 
1884 process = cms.Process("Parent")
1885 
1886 parentProcess = process
1887 import FWCore.ParameterSet.Config as cms
1888 
1889 process = cms.Process("Child")
1890 
1891 process.a = cms.EDProducer("A")
1892 
1893 
1894 process.p = cms.Path(process.a)
1895 
1896 
1897 process.Foo = cms.Service("Foo")
1898 
1899 
1900 childProcess = process
1901 process = parentProcess
1902 process.addSubProcess(cms.SubProcess(process = childProcess, SelectEvents = cms.untracked.PSet(
1903 
1904 ), outputCommands = cms.untracked.vstring()))
1905 
1906 """
1907  equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcesses_()[0])))
1908  self.assertEqual(d,equalD)
1909  p = TestMakePSet()
1910  process.fillProcessDesc(p)
1911  self.assertEqual((True,['a']),p.values["subProcesses"][1][0].values["process"][1].values['@all_modules'])
1912  self.assertEqual((True,['p']),p.values["subProcesses"][1][0].values["process"][1].values['@paths'])
self.assertEqual({'@service_type':(True,'Foo')}, p.values["subProcesses"][1][0].values["process"][1].values["services"][1][0].values)
def Config.TestModuleCommand.testTypedParameterizable (   self)

Definition at line 1355 of file Config.py.

1355 
1356  def testTypedParameterizable(self):
1357  p = _TypedParameterizable("blah", b=int32(1))
1358  #see if copy works deeply
1359  other = p.copy()
1360  other.b = 2
1361  self.assertNotEqual(p.b,other.b)
Mixins._TypedParameterizable
Definition: Mixins.py:306
def Config.TestModuleCommand.testUsing (   self)

Definition at line 1759 of file Config.py.

1759 
1760  def testUsing(self):
1761  p = Process('test')
1762  p.block = PSet(a = int32(1))
1763  p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
1764  self.assertEqual(p.modu.a.value(),1)
1765  self.assertEqual(p.modu.b.value(),2)

Member Data Documentation

tuple Config.TestModuleCommand.a = EDProducer("A")
static

Definition at line 1553 of file Config.py.

Config.TestModuleCommand.a

Definition at line 2071 of file Config.py.

tuple Config.TestModuleCommand.d = p.dumpPython()
static

Definition at line 1531 of file Config.py.

tuple Config.TestModuleCommand.p = Process("test")
static

Definition at line 1524 of file Config.py.

Referenced by Electron.Electron.ptErr().

Config.TestModuleCommand.proc_mod_

Definition at line 2068 of file Config.py.

tuple Config.TestModuleCommand.process = Process("DUMP")
static

Definition at line 1556 of file Config.py.

Referenced by ConfigBuilder.ConfigBuilder.addExtraStream(), ConfigBuilder.ConfigBuilder.completeInputCommand(), ConfigBuilder.ConfigBuilder.doNotInlineEventContent(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.dumpPython(), ConfigBuilder.ConfigBuilder.PrintAllModules.leave(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.open(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.outputEventContent(), ConfigBuilder.ConfigBuilder.prepare_HLT(), ConfigBuilder.ConfigBuilder.prepare_LHE(), ConfigBuilder.ConfigBuilder.prepare_PATFILTER(), ConfigBuilder.ConfigBuilder.prepare_VALIDATION(), ConfigBuilder.ConfigBuilder.renameHLTprocessInSequence(), ConfigBuilder.ConfigBuilder.renameInputTagsInSequence(), ConfigBuilder.ConfigBuilder.scheduleSequence(), Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.setProcess(), and Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.setProperty().

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

Definition at line 1527 of file Config.py.

tuple Config.TestModuleCommand.s1 = Sequence(s)
static

Definition at line 1573 of file Config.py.

tuple Config.TestModuleCommand.s2 = Sequence(a)
static

Definition at line 1554 of file Config.py.

Generated for CMSSW Reference Manual by doxygen 1.8.5