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)
 
tuple s3 = Sequence(a+a)
 

Detailed Description

Definition at line 1334 of file Config.py.

Member Function Documentation

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

Definition at line 1335 of file Config.py.

1335 
1336  def setUp(self):
1337  """Nothing to do """
None
def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 1673 of file Config.py.

1673 
1674  def testCloneSequence(self):
1675  p = Process("test")
1676  a = EDAnalyzer("MyAnalyzer")
1677  p.a = a
1678  a.setLabel("a")
1679  b = EDAnalyzer("YOurAnalyzer")
1680  p.b = b
1681  b.setLabel("b")
1682  path = Path(a * b)
1683  p.path = Path(p.a*p.b)
1684  lookuptable = {id(a): p.a, id(b): p.b}
1685  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1686  #lookuptable = p._cloneToObjectDict
1687  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1688  self.assertEqual(str(path),str(p.path))
def Config.TestModuleCommand.testExamples (   self)

Definition at line 1806 of file Config.py.

References Types.untracked.

1806 
1807  def testExamples(self):
1808  p = Process("Test")
1809  p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
1810  p.foos = EDProducer("FooProducer")
1811  p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
1812  p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
1813  p.bars.foos = 'Foosball'
1814  self.assertEqual(p.bars.foos, InputTag('Foosball'))
1815  p.p = Path(p.foos*p.bars)
1816  p.e = EndPath(p.out)
1817  p.add_(Service("MessageLogger"))
Types.untracked
tuple untracked
Definition: Types.py:27
def Config.TestModuleCommand.testFreeze (   self)

Definition at line 1872 of file Config.py.

1872 
1873  def testFreeze(self):
1874  process = Process("Freeze")
1875  m = EDProducer("M", p=PSet(i = int32(1)))
1876  m.p.i = 2
1877  process.m = m
1878  # should be frozen
1879  #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
1880  #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
1881  #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
1882  #self.assertRaises(ValueError, setattr, m, 'j', 1)
1883  # But OK to change through the process
1884  process.m.p.i = 4
1885  self.assertEqual(process.m.p.i.value(), 4)
1886  process.m.p = PSet(j=int32(1))
1887  # should work to clone it, though
1888  m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
1889  m2.p.i = 6
m2.j = 8
def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 1616 of file Config.py.

1616 
1617  def testGlobalReplace(self):
1618  p = Process('test')
1619  p.a = EDAnalyzer("MyAnalyzer")
1620  p.b = EDAnalyzer("YourAnalyzer")
1621  p.c = EDAnalyzer("OurAnalyzer")
1622  p.s = Sequence(p.a*p.b)
1623  p.p = Path(p.c+p.s+p.a)
1624  new = EDAnalyzer("NewAnalyzer")
1625  p.globalReplace("a",new)
def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 1743 of file Config.py.

1743 
1744  def testImplicitSchedule(self):
1745  p = Process("test")
1746  p.a = EDAnalyzer("MyAnalyzer")
1747  p.b = EDAnalyzer("YourAnalyzer")
1748  p.c = EDAnalyzer("OurAnalyzer")
1749  p.path1 = Path(p.a)
1750  p.path2 = Path(p.b)
1751  self.assert_(p.schedule is None)
1752  pths = p.paths
1753  keys = pths.keys()
1754  self.assertEqual(pths[keys[0]],p.path1)
1755  self.assertEqual(pths[keys[1]],p.path2)
1756  p.prune()
1757  self.assert_(hasattr(p, 'a'))
1758  self.assert_(hasattr(p, 'b'))
1759  self.assert_(not hasattr(p, 'c'))
1760  self.assert_(hasattr(p, 'path1'))
1761  self.assert_(hasattr(p, 'path2'))
1762 
1763 
1764  p = Process("test")
1765  p.a = EDAnalyzer("MyAnalyzer")
1766  p.b = EDAnalyzer("YourAnalyzer")
1767  p.c = EDAnalyzer("OurAnalyzer")
1768  p.path2 = Path(p.b)
1769  p.path1 = Path(p.a)
1770  self.assert_(p.schedule is None)
1771  pths = p.paths
1772  keys = pths.keys()
1773  self.assertEqual(pths[keys[1]],p.path1)
1774  self.assertEqual(pths[keys[0]],p.path2)
1775 
def Config.TestModuleCommand.testModifier (   self)

Definition at line 2029 of file Config.py.

References cmsPerfStripChart.dict.

2029 
2030  def testModifier(self):
2031  m1 = Modifier()
2032  p = Process("test",m1)
2033  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
2034  def _mod_fred(obj):
2035  obj.fred = 2
2036  m1.toModify(p.a,_mod_fred)
2037  self.assertEqual(p.a.fred.value(),2)
2038  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
2039  m1.toModify(p.b, wilma = 2)
2040  self.assertEqual(p.b.wilma.value(),2)
2041  self.assert_(p.isUsingModifier(m1))
2042  #check that Modifier not attached to a process doesn't run
2043  m1 = Modifier()
2044  p = Process("test")
2045  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
2046  m1.toModify(p.a,_mod_fred)
2047  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
2048  m1.toModify(p.b, wilma = 2)
2049  self.assertEqual(p.a.fred.value(),1)
2050  self.assertEqual(p.b.wilma.value(),1)
2051  self.assertEqual(p.isUsingModifier(m1),False)
2052  #make sure clones get the changes
2053  m1 = Modifier()
2054  p = Process("test",m1)
2055  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2056  m1.toModify(p.a, fred = int32(2))
2057  p.b = p.a.clone(wilma = int32(3))
2058  self.assertEqual(p.a.fred.value(),2)
2059  self.assertEqual(p.a.wilma.value(),1)
2060  self.assertEqual(p.b.fred.value(),2)
2061  self.assertEqual(p.b.wilma.value(),3)
2062  #test removal of parameter
2063  m1 = Modifier()
2064  p = Process("test",m1)
2065  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2066  m1.toModify(p.a, fred = None)
2067  self.assertEqual(hasattr(p.a, "fred"), False)
2068  self.assertEqual(p.a.wilma.value(),1)
2069  #test adding a parameter
2070  m1 = Modifier()
2071  p = Process("test",m1)
2072  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
2073  m1.toModify(p.a, wilma = int32(2))
2074  self.assertEqual(p.a.fred.value(), 1)
2075  self.assertEqual(p.a.wilma.value(),2)
2076  #test setting of value in PSet
2077  m1 = Modifier()
2078  p = Process("test",m1)
2079  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = int32(1), wilma = int32(1)))
2080  m1.toModify(p.a, flintstones = dict(fred = int32(2)))
2081  self.assertEqual(p.a.flintstones.fred.value(),2)
2082  self.assertEqual(p.a.flintstones.wilma.value(),1)
2083  #test proper exception from nonexisting parameter name
2084  m1 = Modifier()
2085  p = Process("test",m1)
2086  p.a = EDAnalyzer("MyAnalyzer", flintstones = PSet(fred = PSet(wilma = int32(1))))
2087  self.assertRaises(KeyError, lambda: m1.toModify(p.a, flintstones = dict(imnothere = dict(wilma=2))))
2088  self.assertRaises(KeyError, lambda: m1.toModify(p.a, foo = 1))
2089  #test setting a value in a VPSet
2090  m1 = Modifier()
2091  p = Process("test",m1)
2092  p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
2093  m1.toModify(p.a, flintstones = {1:dict(wilma = int32(2))})
2094  self.assertEqual(p.a.flintstones[0].fred.value(),1)
2095  self.assertEqual(p.a.flintstones[1].wilma.value(),2)
2096  #test setting a value in a list of values
2097  m1 = Modifier()
2098  p = Process("test",m1)
2099  p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
2100  m1.toModify(p.a, fred = {1:7})
2101  self.assertEqual(p.a.fred[0],1)
2102  self.assertEqual(p.a.fred[1],7)
2103  self.assertEqual(p.a.fred[2],3)
2104  #test IndexError setting a value in a list to an item key not in the list
2105  m1 = Modifier()
2106  p = Process("test",m1)
2107  p.a = EDAnalyzer("MyAnalyzer", fred = vuint32(1,2,3))
2108  raised = False
2109  try: m1.toModify(p.a, fred = {5:7})
2110  except IndexError, e: raised = True
2111  self.assertEqual(raised, True)
2112  #test TypeError setting a value in a list using a key that is not an int
2113  m1 = Modifier()
2114  p = Process("test",m1)
2115  p.a = EDAnalyzer("MyAnalyzer", flintstones = VPSet(PSet(fred = int32(1)), PSet(wilma = int32(1))))
2116  raised = False
2117  try: m1.toModify(p.a, flintstones = dict(bogus = int32(37)))
2118  except TypeError, e: raised = True
2119  self.assertEqual(raised, True)
2120  #test that load causes process wide methods to run
2121  def _rem_a(proc):
2122  del proc.a
2123  class ProcModifierMod(object):
2124  def __init__(self,modifier,func):
2125  self.proc_mod_ = modifier.makeProcessModifier(func)
2126  class DummyMod(object):
2127  def __init__(self):
2128  self.a = EDAnalyzer("Dummy")
2129  testMod = DummyMod()
2130  p.extend(testMod)
2131  self.assert_(hasattr(p,"a"))
2132  m1 = Modifier()
2133  p = Process("test",m1)
2134  testProcMod = ProcModifierMod(m1,_rem_a)
2135  p.extend(testMod)
2136  p.extend(testProcMod)
2137  self.assert_(not hasattr(p,"a"))
2138  #test ModifierChain
2139  m1 = Modifier()
2140  mc = ModifierChain(m1)
2141  p = Process("test",mc)
2142  self.assert_(p.isUsingModifier(m1))
2143  self.assert_(p.isUsingModifier(mc))
2144  testMod = DummyMod()
2145  p.b = EDAnalyzer("Dummy2", fred = int32(1))
2146  m1.toModify(p.b, fred = int32(3))
2147  p.extend(testMod)
2148  testProcMod = ProcModifierMod(m1,_rem_a)
2149  p.extend(testProcMod)
2150  self.assert_(not hasattr(p,"a"))
2151  self.assertEqual(p.b.fred.value(),3)
2152  #check combining
2153  m1 = Modifier()
2154  m2 = Modifier()
2155  p = Process("test",m1)
2156  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2157  (m1 & m2).toModify(p.a, fred = int32(2))
2158  self.assertEqual(p.a.fred, 1)
2159  m1 = Modifier()
2160  m2 = Modifier()
2161  p = Process("test",m1,m2)
2162  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2163  (m1 & m2).toModify(p.a, fred = int32(2))
2164  self.assertEqual(p.a.fred, 2)
2165  m1 = Modifier()
2166  m2 = Modifier()
2167  m3 = Modifier()
2168  p = Process("test",m1,m2,m3)
2169  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1), wilma = int32(1))
2170  (m1 & m2 & m3).toModify(p.a, fred = int32(2))
2171  self.assertEqual(p.a.fred, 2)
2172  #check toReplaceWith
2173  m1 = Modifier()
2174  p = Process("test",m1)
2175  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
2176  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
2177  p.b =EDAnalyzer("BAn")
2178  p.s = Sequence(p.a)
2179  m1.toReplaceWith(p.s, Sequence(p.a+p.b))
2180  self.assertEqual(p.a.wilma.value(),3)
2181  self.assertEqual(p.a.type_(),"YourAnalyzer")
2182  self.assertEqual(hasattr(p,"fred"),False)
2183  self.assertEqual(p.s.dumpPython(""),"cms.Sequence(process.a+process.b)\n")
2184  #check toReplaceWith doesn't activate not chosen
2185  m1 = Modifier()
2186  p = Process("test")
2187  p.a =EDAnalyzer("MyAnalyzer", fred = int32(1))
2188  m1.toReplaceWith(p.a, EDAnalyzer("YourAnalyzer", wilma = int32(3)))
2189  self.assertEqual(p.a.type_(),"MyAnalyzer")
unittest.main()
def Config.TestModuleCommand.testOverride (   self)

Definition at line 1783 of file Config.py.

1783 
1784  def testOverride(self):
1785  p = Process('test')
1786  a = EDProducer("A", a1=int32(0))
1787  self.assert_(not a.isModified())
1788  a.a1 = 1
1789  self.assert_(a.isModified())
1790  p.a = a
1791  self.assertEqual(p.a.a1.value(), 1)
1792  # try adding an unmodified module.
1793  # should accept it
1794  p.a = EDProducer("A", a1=int32(2))
1795  self.assertEqual(p.a.a1.value(), 2)
1796  # try adding a modified module. Should throw
1797  # no longer, since the same (modified) say, geometry
1798  # could come from more than one cff
1799  b = EDProducer("A", a1=int32(3))
1800  b.a1 = 4
1801  #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
1802  ps1 = PSet(a = int32(1))
1803  ps2 = PSet(a = int32(2))
1804  self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
1805  self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 1338 of file Config.py.

1338 
1339  def testParameterizable(self):
1340  p = _Parameterizable()
1341  self.assertEqual(len(p.parameterNames_()),0)
1342  p.a = int32(1)
1343  self.assert_('a' in p.parameterNames_())
1344  self.assertEqual(p.a.value(), 1)
1345  p.a = 10
1346  self.assertEqual(p.a.value(), 10)
1347  p.a = untracked(int32(1))
1348  self.assertEqual(p.a.value(), 1)
1349  self.failIf(p.a.isTracked())
1350  p.a = untracked.int32(1)
1351  self.assertEqual(p.a.value(), 1)
1352  self.failIf(p.a.isTracked())
1353  p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
1354  self.assertEqual(p.foo.value(), 10)
1355  self.assertEqual(p.bar.value(),1.0)
1356  self.failIf(p.bar.isTracked())
1357  self.assertRaises(TypeError,setattr,(p,'c',1))
1358  p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
1359  self.assertEqual(p.a.foo.value(),10)
1360  self.assertEqual(p.a.bar.value(),1.0)
1361  p.b = untracked(PSet(fii = int32(1)))
1362  self.assertEqual(p.b.fii.value(),1)
1363  self.failIf(p.b.isTracked())
1364  #test the fact that values can be shared
1365  v = int32(10)
1366  p=_Parameterizable(a=v)
1367  v.setValue(11)
1368  self.assertEqual(p.a.value(),11)
1369  p.a = 12
1370  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 1651 of file Config.py.

1651 
1652  def testPath(self):
1653  p = Process("test")
1654  p.a = EDAnalyzer("MyAnalyzer")
1655  p.b = EDAnalyzer("YourAnalyzer")
1656  p.c = EDAnalyzer("OurAnalyzer")
1657  path = Path(p.a)
1658  path *= p.b
1659  path += p.c
1660  self.assertEqual(str(path),'a+b+c')
1661  path = Path(p.a*p.b+p.c)
1662  self.assertEqual(str(path),'a+b+c')
1663 # path = Path(p.a)*p.b+p.c #This leads to problems with sequences
1664 # self.assertEqual(str(path),'((a*b)+c)')
1665  path = Path(p.a+ p.b*p.c)
1666  self.assertEqual(str(path),'a+b+c')
1667  path = Path(p.a*(p.b+p.c))
1668  self.assertEqual(str(path),'a+b+c')
1669  path = Path(p.a*(p.b+~p.c))
1670  self.assertEqual(str(path),'a+b+~c')
1671  p.es = ESProducer("AnESProducer")
1672  self.assertRaises(TypeError,Path,p.es)
def Config.TestModuleCommand.testPrefers (   self)

Definition at line 1818 of file Config.py.

1818 
1819  def testPrefers(self):
1820  p = Process("Test")
1821  p.add_(ESSource("ForceSource"))
1822  p.juicer = ESProducer("JuicerProducer")
1823  p.prefer("ForceSource")
1824  p.prefer("juicer")
1825  self.assertEqual(p.dumpConfig(),
1826 """process Test = {
1827  es_module juicer = JuicerProducer {
1828  }
1829  es_source = ForceSource {
1830  }
1831  es_prefer = ForceSource {
1832  }
1833  es_prefer juicer = JuicerProducer {
1834  }
1835 }
1836 """)
1837  p.prefer("juicer",fooRcd=vstring("Foo"))
1838  self.assertEqual(p.dumpConfig(),
1839 """process Test = {
1840  es_module juicer = JuicerProducer {
1841  }
1842  es_source = ForceSource {
1843  }
1844  es_prefer = ForceSource {
1845  }
1846  es_prefer juicer = JuicerProducer {
1847  vstring fooRcd = {
1848  'Foo'
1849  }
1850 
1851  }
1852 }
1853 """)
1854  self.assertEqual(p.dumpPython(),
1855 """import FWCore.ParameterSet.Config as cms
1856 
1857 process = cms.Process("Test")
1858 
1859 process.juicer = cms.ESProducer("JuicerProducer")
1860 
1861 
1862 process.ForceSource = cms.ESSource("ForceSource")
1863 
1864 
1865 process.prefer("ForceSource")
1866 
1867 process.prefer("juicer",
1868  fooRcd = cms.vstring('Foo')
1869 )
1870 
1871 """)
def Config.TestModuleCommand.testProcessDumpPython (   self)

Definition at line 1473 of file Config.py.

1473 
1474  def testProcessDumpPython(self):
1475  p = Process("test")
1476  p.a = EDAnalyzer("MyAnalyzer")
1477  p.p = Path(p.a)
1478  p.s = Sequence(p.a)
1479  p.r = Sequence(p.s)
1480  p.p2 = Path(p.s)
1481  p.schedule = Schedule(p.p2,p.p)
1482  d=p.dumpPython()
1483  self.assertEqual(d,
1484 """import FWCore.ParameterSet.Config as cms
1485 
1486 process = cms.Process("test")
1487 
1488 process.a = cms.EDAnalyzer("MyAnalyzer")
1489 
1490 
1491 process.s = cms.Sequence(process.a)
1492 
1493 
1494 process.r = cms.Sequence(process.s)
1495 
1496 
1497 process.p = cms.Path(process.a)
1498 
1499 
1500 process.p2 = cms.Path(process.s)
1501 
1502 
1503 process.schedule = cms.Schedule(*[ process.p2, process.p ])
1504 """)
1505  #Reverse order of 'r' and 's'
1506  p = Process("test")
1507  p.a = EDAnalyzer("MyAnalyzer")
1508  p.p = Path(p.a)
1509  p.r = Sequence(p.a)
1510  p.s = Sequence(p.r)
1511  p.p2 = Path(p.r)
1512  p.schedule = Schedule(p.p2,p.p)
1513  p.b = EDAnalyzer("YourAnalyzer")
1514  d=p.dumpPython()
1515  self.assertEqual(d,
1516 """import FWCore.ParameterSet.Config as cms
1517 
1518 process = cms.Process("test")
1519 
1520 process.a = cms.EDAnalyzer("MyAnalyzer")
1521 
1522 
1523 process.b = cms.EDAnalyzer("YourAnalyzer")
1524 
1525 
1526 process.r = cms.Sequence(process.a)
1527 
1528 
1529 process.s = cms.Sequence(process.r)
1530 
1531 
1532 process.p = cms.Path(process.a)
1533 
1534 
1535 process.p2 = cms.Path(process.r)
1536 
1537 
1538 process.schedule = cms.Schedule(*[ process.p2, process.p ])
""")
def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 1403 of file Config.py.

1403 
1404  def testProcessExtend(self):
1405  class FromArg(object):
1406  def __init__(self,*arg,**args):
1407  for name in args.iterkeys():
1408  self.__dict__[name]=args[name]
1409 
1410  a=EDAnalyzer("MyAnalyzer")
1411  t=EDAnalyzer("MyAnalyzer")
1412  t.setLabel("foo")
1413  s1 = Sequence(a)
1414  s2 = Sequence(s1)
1415  s3 = Sequence(s2)
1416  d = FromArg(
1417  a=a,
1418  b=Service("Full"),
1419  c=Path(a),
1420  d=s2,
1421  e=s1,
1422  f=s3,
1423  g=Sequence(s1+s2+s3)
1424  )
1425  p = Process("Test")
1426  p.extend(d)
1427  self.assertEqual(p.a.type_(),"MyAnalyzer")
1428  self.assertEqual(p.a.label_(),"a")
1429  self.assertRaises(AttributeError,getattr,p,'b')
1430  self.assertEqual(p.Full.type_(),"Full")
1431  self.assertEqual(str(p.c),'a')
1432  self.assertEqual(str(p.d),'a')
1433 
1434  z1 = FromArg(
1435  a=a,
1436  b=Service("Full"),
1437  c=Path(a),
1438  d=s2,
1439  e=s1,
1440  f=s3,
1441  s4=s3,
1442  g=Sequence(s1+s2+s3)
1443  )
1444 
1445  p1 = Process("Test")
1446  #p1.extend(z1)
1447  self.assertRaises(ValueError, p1.extend, z1)
1448 
1449  z2 = FromArg(
1450  a=a,
1451  b=Service("Full"),
1452  c=Path(a),
1453  d=s2,
1454  e=s1,
1455  f=s3,
1456  aaa=copy.deepcopy(a),
1457  s4=copy.deepcopy(s3),
1458  g=Sequence(s1+s2+s3),
1459  t=t
1460  )
1461  p2 = Process("Test")
1462  p2.extend(z2)
1463  #self.assertRaises(ValueError, p2.extend, z2)
1464  self.assertEqual(p2.s4.label_(),"s4")
1465  #p2.s4.setLabel("foo")
1466  self.assertRaises(ValueError, p2.s4.setLabel, "foo")
1467  p2.s4.setLabel("s4")
1468  p2.s4.setLabel(None)
1469  p2.s4.setLabel("foo")
1470  p2._Process__setObjectLabel(p2.s4, "foo")
1471  p2._Process__setObjectLabel(p2.s4, None)
1472  p2._Process__setObjectLabel(p2.s4, "bar")
def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 1378 of file Config.py.

1378 
1379  def testProcessInsertion(self):
1380  p = Process("test")
1381  p.a = EDAnalyzer("MyAnalyzer")
1382  self.assert_( 'a' in p.analyzers_() )
1383  self.assert_( 'a' in p.analyzers)
1384  p.add_(Service("MessageLogger"))
1385  self.assert_('MessageLogger' in p.services_())
1386  self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
1387  p.Tracer = Service("Tracer")
1388  self.assert_('Tracer' in p.services_())
1389  self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
1390  self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
1391  self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
1392  p.out = OutputModule("Outer")
1393  self.assertEqual(p.out.type_(), 'Outer')
1394  self.assert_( 'out' in p.outputModules_() )
1395 
1396  p.geom = ESSource("GeomProd")
1397  self.assert_('geom' in p.es_sources_())
1398  p.add_(ESSource("ConfigDB"))
1399  self.assert_('ConfigDB' in p.es_sources_())
1400 
1401  p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
1402  self.assert_('aliasfoo1' in p.aliases_())
def Config.TestModuleCommand.testPrune (   self)

Definition at line 1946 of file Config.py.

1946 
1947  def testPrune(self):
1948  p = Process("test")
1949  p.a = EDAnalyzer("MyAnalyzer")
1950  p.b = EDAnalyzer("YourAnalyzer")
1951  p.c = EDAnalyzer("OurAnalyzer")
1952  p.d = EDAnalyzer("OurAnalyzer")
1953  p.s = Sequence(p.d)
1954  p.path1 = Path(p.a)
1955  p.path2 = Path(p.b)
1956  self.assert_(p.schedule is None)
1957  pths = p.paths
1958  keys = pths.keys()
1959  self.assertEqual(pths[keys[0]],p.path1)
1960  self.assertEqual(pths[keys[1]],p.path2)
1961  p.pset1 = PSet(parA = string("pset1"))
1962  p.pset2 = untracked.PSet(parA = string("pset2"))
1963  p.vpset1 = VPSet()
1964  p.vpset2 = untracked.VPSet()
1965  p.prune()
1966  self.assert_(hasattr(p, 'a'))
1967  self.assert_(hasattr(p, 'b'))
1968  self.assert_(not hasattr(p, 'c'))
1969  self.assert_(not hasattr(p, 'd'))
1970  self.assert_(not hasattr(p, 's'))
1971  self.assert_(hasattr(p, 'path1'))
1972  self.assert_(hasattr(p, 'path2'))
1973 # self.assert_(not hasattr(p, 'pset1'))
1974 # self.assert_(hasattr(p, 'pset2'))
1975 # self.assert_(not hasattr(p, 'vpset1'))
1976 # self.assert_(not hasattr(p, 'vpset2'))
1977 
1978  p = Process("test")
1979  p.a = EDAnalyzer("MyAnalyzer")
1980  p.b = EDAnalyzer("YourAnalyzer")
1981  p.c = EDAnalyzer("OurAnalyzer")
1982  p.d = EDAnalyzer("OurAnalyzer")
1983  p.e = EDAnalyzer("OurAnalyzer")
1984  p.s = Sequence(p.d)
1985  p.s2 = Sequence(p.b)
1986  p.s3 = Sequence(p.e)
1987  p.path1 = Path(p.a)
1988  p.path2 = Path(p.b)
1989  p.path3 = Path(p.b+p.s2)
1990  p.path4 = Path(p.b+p.s3)
1991  p.schedule = Schedule(p.path1,p.path2,p.path3)
1992  pths = p.paths
1993  keys = pths.keys()
1994  self.assertEqual(pths[keys[0]],p.path1)
1995  self.assertEqual(pths[keys[1]],p.path2)
1996  p.prune()
1997  self.assert_(hasattr(p, 'a'))
1998  self.assert_(hasattr(p, 'b'))
1999  self.assert_(not hasattr(p, 'c'))
2000  self.assert_(not hasattr(p, 'd'))
2001  self.assert_(not hasattr(p, 'e'))
2002  self.assert_(not hasattr(p, 's'))
2003  self.assert_(hasattr(p, 's2'))
2004  self.assert_(not hasattr(p, 's3'))
2005  self.assert_(hasattr(p, 'path1'))
2006  self.assert_(hasattr(p, 'path2'))
2007  self.assert_(hasattr(p, 'path3'))
2008  self.assert_(not hasattr(p, 'path4'))
2009  #test SequencePlaceholder
2010  p = Process("test")
2011  p.a = EDAnalyzer("MyAnalyzer")
2012  p.b = EDAnalyzer("YourAnalyzer")
2013  p.s = Sequence(SequencePlaceholder("a")+p.b)
2014  p.pth = Path(p.s)
2015  p.prune()
2016  self.assert_(hasattr(p, 'a'))
2017  self.assert_(hasattr(p, 'b'))
2018  self.assert_(hasattr(p, 's'))
2019  self.assert_(hasattr(p, 'pth'))
2020  #test unresolved SequencePlaceholder
2021  p = Process("test")
2022  p.b = EDAnalyzer("YourAnalyzer")
2023  p.s = Sequence(SequencePlaceholder("a")+p.b)
2024  p.pth = Path(p.s)
2025  p.prune(keepUnresolvedSequencePlaceholders=True)
2026  self.assert_(hasattr(p, 'b'))
2027  self.assert_(hasattr(p, 's'))
2028  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 1930 of file Config.py.

1930 
1931  def testRefToPSet(self):
1932  proc = Process("test")
1933  proc.top = PSet(a = int32(1))
1934  proc.ref = PSet(refToPSet_ = string("top"))
1935  proc.ref2 = PSet( a = int32(1), b = PSet( refToPSet_ = string("top")))
1936  proc.ref3 = PSet(refToPSet_ = string("ref"))
1937  proc.ref4 = VPSet(PSet(refToPSet_ = string("top")),
1938  PSet(refToPSet_ = string("ref2")))
1939  p = TestMakePSet()
1940  proc.fillProcessDesc(p)
1941  self.assertEqual((True,1),p.values["ref"][1].values["a"])
1942  self.assertEqual((True,1),p.values["ref3"][1].values["a"])
1943  self.assertEqual((True,1),p.values["ref2"][1].values["a"])
1944  self.assertEqual((True,1),p.values["ref2"][1].values["b"][1].values["a"])
1945  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 1689 of file Config.py.

1689 
1690  def testSchedule(self):
1691  p = Process("test")
1692  p.a = EDAnalyzer("MyAnalyzer")
1693  p.b = EDAnalyzer("YourAnalyzer")
1694  p.c = EDAnalyzer("OurAnalyzer")
1695  p.d = EDAnalyzer("OurAnalyzer")
1696  p.path1 = Path(p.a)
1697  p.path2 = Path(p.b)
1698  p.path3 = Path(p.d)
1699 
1700  s = Schedule(p.path1,p.path2)
1701  self.assertEqual(s[0],p.path1)
1702  self.assertEqual(s[1],p.path2)
1703  p.schedule = s
1704  self.assert_('b' in p.schedule.moduleNames())
1705  self.assert_(hasattr(p, 'b'))
1706  self.assert_(hasattr(p, 'c'))
1707  self.assert_(hasattr(p, 'd'))
1708  self.assert_(hasattr(p, 'path1'))
1709  self.assert_(hasattr(p, 'path2'))
1710  self.assert_(hasattr(p, 'path3'))
1711  p.prune()
1712  self.assert_('b' in p.schedule.moduleNames())
1713  self.assert_(hasattr(p, 'b'))
1714  self.assert_(not hasattr(p, 'c'))
1715  self.assert_(not hasattr(p, 'd'))
1716  self.assert_(hasattr(p, 'path1'))
1717  self.assert_(hasattr(p, 'path2'))
1718  self.assert_(not hasattr(p, 'path3'))
1719 
1720  #adding a path not attached to the Process should cause an exception
1721  p = Process("test")
1722  p.a = EDAnalyzer("MyAnalyzer")
1723  path1 = Path(p.a)
1724  s = Schedule(path1)
1725  self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
1726 
1727  #make sure anonymous sequences work
1728  p = Process("test")
1729  p.a = EDAnalyzer("MyAnalyzer")
1730  p.b = EDAnalyzer("MyOtherAnalyzer")
1731  p.c = EDProducer("MyProd")
1732  path1 = Path(p.c*Sequence(p.a+p.b))
1733  s = Schedule(path1)
1734  self.assert_('a' in s.moduleNames())
1735  self.assert_('b' in s.moduleNames())
1736  self.assert_('c' in s.moduleNames())
1737  p.path1 = path1
1738  p.schedule = s
1739  p.prune()
1740  self.assert_('a' in s.moduleNames())
1741  self.assert_('b' in s.moduleNames())
1742  self.assert_('c' in s.moduleNames())
def Config.TestModuleCommand.testSecSource (   self)

Definition at line 1611 of file Config.py.

References python.rootplot.root2matplotlib.replace().

1611 
1612  def testSecSource(self):
1613  p = Process('test')
1614  p.a = SecSource("MySecSource")
1615  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 1626 of file Config.py.

1626 
1627  def testSequence(self):
1628  p = Process('test')
1629  p.a = EDAnalyzer("MyAnalyzer")
1630  p.b = EDAnalyzer("YourAnalyzer")
1631  p.c = EDAnalyzer("OurAnalyzer")
1632  p.s = Sequence(p.a*p.b)
1633  self.assertEqual(str(p.s),'a+b')
1634  self.assertEqual(p.s.label_(),'s')
1635  path = Path(p.c+p.s)
1636  self.assertEqual(str(path),'c+a+b')
1637  p._validateSequence(path, 'p1')
1638  notInProcess = EDAnalyzer('NotInProcess')
1639  p2 = Path(p.c+p.s*notInProcess)
1640  self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
def Config.TestModuleCommand.testSequence2 (   self)

Definition at line 1641 of file Config.py.

1641 
1642  def testSequence2(self):
1643  p = Process('test')
1644  p.a = EDAnalyzer("MyAnalyzer")
1645  p.b = EDAnalyzer("YourAnalyzer")
1646  p.c = EDAnalyzer("OurAnalyzer")
1647  testseq = Sequence(p.a*p.b)
1648  p.s = testseq
1649  #p.y = testseq
1650  self.assertRaises(ValueError, p.__setattr__, "y", testseq)
def Config.TestModuleCommand.testSubProcess (   self)

Definition at line 1890 of file Config.py.

References cond.hash.

1890 
1891  def testSubProcess(self):
1892  process = Process("Parent")
1893  subProcess = Process("Child")
1894  subProcess.a = EDProducer("A")
1895  subProcess.p = Path(subProcess.a)
1896  subProcess.add_(Service("Foo"))
1897  process.addSubProcess(SubProcess(subProcess))
1898  d = process.dumpPython()
1899  equalD ="""import FWCore.ParameterSet.Config as cms
1900 
1901 process = cms.Process("Parent")
1902 
1903 parentProcess = process
1904 import FWCore.ParameterSet.Config as cms
1905 
1906 process = cms.Process("Child")
1907 
1908 process.a = cms.EDProducer("A")
1909 
1910 
1911 process.p = cms.Path(process.a)
1912 
1913 
1914 process.Foo = cms.Service("Foo")
1915 
1916 
1917 childProcess = process
1918 process = parentProcess
1919 process.addSubProcess(cms.SubProcess(process = childProcess, SelectEvents = cms.untracked.PSet(
1920 
1921 ), outputCommands = cms.untracked.vstring()))
1922 
1923 """
1924  equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcesses_()[0])))
1925  self.assertEqual(d,equalD)
1926  p = TestMakePSet()
1927  process.fillProcessDesc(p)
1928  self.assertEqual((True,['a']),p.values["subProcesses"][1][0].values["process"][1].values['@all_modules'])
1929  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 1371 of file Config.py.

1371 
1372  def testTypedParameterizable(self):
1373  p = _TypedParameterizable("blah", b=int32(1))
1374  #see if copy works deeply
1375  other = p.copy()
1376  other.b = 2
1377  self.assertNotEqual(p.b,other.b)
Mixins._TypedParameterizable
Definition: Mixins.py:306
def Config.TestModuleCommand.testUsing (   self)

Definition at line 1776 of file Config.py.

1776 
1777  def testUsing(self):
1778  p = Process('test')
1779  p.block = PSet(a = int32(1))
1780  p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
1781  self.assertEqual(p.modu.a.value(),1)
1782  self.assertEqual(p.modu.b.value(),2)

Member Data Documentation

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

Definition at line 1569 of file Config.py.

Config.TestModuleCommand.a

Definition at line 2127 of file Config.py.

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

Definition at line 1547 of file Config.py.

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

Definition at line 1540 of file Config.py.

Referenced by Electron.Electron.ptErr().

Config.TestModuleCommand.proc_mod_

Definition at line 2124 of file Config.py.

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

Definition at line 1572 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 1543 of file Config.py.

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

Definition at line 1589 of file Config.py.

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

Definition at line 1570 of file Config.py.

tuple Config.TestModuleCommand.s3 = Sequence(a+a)
static

Definition at line 1591 of file Config.py.

Generated for CMSSW Reference Manual by doxygen 1.8.5