CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | 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
 

Static Public Attributes

tuple d = p.dumpPython()
 
tuple p = Process("test")
 
tuple s = Sequence(p.a)
 

Detailed Description

Definition at line 1157 of file Config.py.

Member Function Documentation

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

Definition at line 1158 of file Config.py.

1158 
1159  def setUp(self):
1160  """Nothing to do """
None
def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 1453 of file Config.py.

1453 
1454  def testCloneSequence(self):
1455  p = Process("test")
1456  a = EDAnalyzer("MyAnalyzer")
1457  p.a = a
1458  a.setLabel("a")
1459  b = EDAnalyzer("YOurAnalyzer")
1460  p.b = b
1461  b.setLabel("b")
1462  path = Path(a * b)
1463  p.path = Path(p.a*p.b)
1464  lookuptable = {id(a): p.a, id(b): p.b}
1465  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1466  #lookuptable = p._cloneToObjectDict
1467  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1468  self.assertEqual(str(path),str(p.path))
def Config.TestModuleCommand.testExamples (   self)

Definition at line 1586 of file Config.py.

References Types.untracked.

1586 
1587  def testExamples(self):
1588  p = Process("Test")
1589  p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
1590  p.foos = EDProducer("FooProducer")
1591  p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
1592  p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
1593  p.bars.foos = 'Foosball'
1594  self.assertEqual(p.bars.foos, InputTag('Foosball'))
1595  p.p = Path(p.foos*p.bars)
1596  p.e = EndPath(p.out)
1597  p.add_(Service("MessageLogger"))
Types.untracked
tuple untracked
Definition: Types.py:27
def Config.TestModuleCommand.testFreeze (   self)

Definition at line 1652 of file Config.py.

1652 
1653  def testFreeze(self):
1654  process = Process("Freeze")
1655  m = EDProducer("M", p=PSet(i = int32(1)))
1656  m.p.i = 2
1657  process.m = m
1658  # should be frozen
1659  #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
1660  #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
1661  #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
1662  #self.assertRaises(ValueError, setattr, m, 'j', 1)
1663  # But OK to change through the process
1664  process.m.p.i = 4
1665  self.assertEqual(process.m.p.i.value(), 4)
1666  process.m.p = PSet(j=int32(1))
1667  # should work to clone it, though
1668  m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
1669  m2.p.i = 6
m2.j = 8
def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 1396 of file Config.py.

1396 
1397  def testGlobalReplace(self):
1398  p = Process('test')
1399  p.a = EDAnalyzer("MyAnalyzer")
1400  p.b = EDAnalyzer("YourAnalyzer")
1401  p.c = EDAnalyzer("OurAnalyzer")
1402  p.s = Sequence(p.a*p.b)
1403  p.p = Path(p.c+p.s+p.a)
1404  new = EDAnalyzer("NewAnalyzer")
1405  p.globalReplace("a",new)
def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 1523 of file Config.py.

1523 
1524  def testImplicitSchedule(self):
1525  p = Process("test")
1526  p.a = EDAnalyzer("MyAnalyzer")
1527  p.b = EDAnalyzer("YourAnalyzer")
1528  p.c = EDAnalyzer("OurAnalyzer")
1529  p.path1 = Path(p.a)
1530  p.path2 = Path(p.b)
1531  self.assert_(p.schedule is None)
1532  pths = p.paths
1533  keys = pths.keys()
1534  self.assertEqual(pths[keys[0]],p.path1)
1535  self.assertEqual(pths[keys[1]],p.path2)
1536  p.prune()
1537  self.assert_(hasattr(p, 'a'))
1538  self.assert_(hasattr(p, 'b'))
1539  self.assert_(not hasattr(p, 'c'))
1540  self.assert_(hasattr(p, 'path1'))
1541  self.assert_(hasattr(p, 'path2'))
1542 
1543 
1544  p = Process("test")
1545  p.a = EDAnalyzer("MyAnalyzer")
1546  p.b = EDAnalyzer("YourAnalyzer")
1547  p.c = EDAnalyzer("OurAnalyzer")
1548  p.path2 = Path(p.b)
1549  p.path1 = Path(p.a)
1550  self.assert_(p.schedule is None)
1551  pths = p.paths
1552  keys = pths.keys()
1553  self.assertEqual(pths[keys[1]],p.path1)
1554  self.assertEqual(pths[keys[0]],p.path2)
1555 
def Config.TestModuleCommand.testModifier (   self)

Definition at line 1798 of file Config.py.

1798 
1799  def testModifier(self):
1800  m1 = Modifier()
1801  p = Process("test")
1802  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
1803  def _mod_fred(obj):
1804  obj.fred = 2
1805  m1.toModify(p.a,_mod_fred)
1806  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
1807  m1.toModify(p.b, wilma = 2)
1808  self.assertEqual(p.a.fred.value(),1)
1809  self.assertEqual(p.b.wilma.value(),1)
1810  m1.modify(p)
1811  self.assertEqual(p.a.fred.value(),2)
1812  self.assertEqual(p.b.wilma.value(),2)
1813  #check that items not attached to process are unchanged
1814  m1 = Modifier()
1815  p = Process("test")
1816  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
1817  m1.toModify(p.a,_mod_fred)
1818  b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
1819  m1.toModify(b, wilma = 2)
1820  self.assertEqual(p.a.fred.value(),1)
1821  self.assertEqual(b.wilma.value(),1)
1822  m1.modify(p)
1823  self.assertEqual(p.a.fred.value(),2)
1824  self.assertEqual(b.wilma.value(),1)
1825  #make sure chains of modifiers work
1826  m1 = Modifier()
1827  m2 = Modifier()
1828  m2.toModifyProcess(m1)
1829  p = Process("test")
1830  p.a = EDAnalyzer("MyAnalyzer", fred = int32(1))
1831  m1.toModify(p.a,_mod_fred)
1832  p.b = EDAnalyzer("YourAnalyzer", wilma = int32(1))
1833  m1.toModify(p.b, wilma = 2)
1834  m2.toModify(p.b, wilma = 3)
1835  m2.modify(p)
1836  self.assertEqual(p.a.fred.value(),2)
1837  self.assertEqual(p.b.wilma.value(),3)
1838 
unittest.main()
def Config.TestModuleCommand.testOverride (   self)

Definition at line 1563 of file Config.py.

1563 
1564  def testOverride(self):
1565  p = Process('test')
1566  a = EDProducer("A", a1=int32(0))
1567  self.assert_(not a.isModified())
1568  a.a1 = 1
1569  self.assert_(a.isModified())
1570  p.a = a
1571  self.assertEqual(p.a.a1.value(), 1)
1572  # try adding an unmodified module.
1573  # should accept it
1574  p.a = EDProducer("A", a1=int32(2))
1575  self.assertEqual(p.a.a1.value(), 2)
1576  # try adding a modified module. Should throw
1577  # no longer, since the same (modified) say, geometry
1578  # could come from more than one cff
1579  b = EDProducer("A", a1=int32(3))
1580  b.a1 = 4
1581  #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
1582  ps1 = PSet(a = int32(1))
1583  ps2 = PSet(a = int32(2))
1584  self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
1585  self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 1161 of file Config.py.

1161 
1162  def testParameterizable(self):
1163  p = _Parameterizable()
1164  self.assertEqual(len(p.parameterNames_()),0)
1165  p.a = int32(1)
1166  self.assert_('a' in p.parameterNames_())
1167  self.assertEqual(p.a.value(), 1)
1168  p.a = 10
1169  self.assertEqual(p.a.value(), 10)
1170  p.a = untracked(int32(1))
1171  self.assertEqual(p.a.value(), 1)
1172  self.failIf(p.a.isTracked())
1173  p.a = untracked.int32(1)
1174  self.assertEqual(p.a.value(), 1)
1175  self.failIf(p.a.isTracked())
1176  p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
1177  self.assertEqual(p.foo.value(), 10)
1178  self.assertEqual(p.bar.value(),1.0)
1179  self.failIf(p.bar.isTracked())
1180  self.assertRaises(TypeError,setattr,(p,'c',1))
1181  p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
1182  self.assertEqual(p.a.foo.value(),10)
1183  self.assertEqual(p.a.bar.value(),1.0)
1184  p.b = untracked(PSet(fii = int32(1)))
1185  self.assertEqual(p.b.fii.value(),1)
1186  self.failIf(p.b.isTracked())
1187  #test the fact that values can be shared
1188  v = int32(10)
1189  p=_Parameterizable(a=v)
1190  v.setValue(11)
1191  self.assertEqual(p.a.value(),11)
1192  p.a = 12
1193  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 1431 of file Config.py.

1431 
1432  def testPath(self):
1433  p = Process("test")
1434  p.a = EDAnalyzer("MyAnalyzer")
1435  p.b = EDAnalyzer("YourAnalyzer")
1436  p.c = EDAnalyzer("OurAnalyzer")
1437  path = Path(p.a)
1438  path *= p.b
1439  path += p.c
1440  self.assertEqual(str(path),'a+b+c')
1441  path = Path(p.a*p.b+p.c)
1442  self.assertEqual(str(path),'a+b+c')
1443 # path = Path(p.a)*p.b+p.c #This leads to problems with sequences
1444 # self.assertEqual(str(path),'((a*b)+c)')
1445  path = Path(p.a+ p.b*p.c)
1446  self.assertEqual(str(path),'a+b+c')
1447  path = Path(p.a*(p.b+p.c))
1448  self.assertEqual(str(path),'a+b+c')
1449  path = Path(p.a*(p.b+~p.c))
1450  self.assertEqual(str(path),'a+b+~c')
1451  p.es = ESProducer("AnESProducer")
1452  self.assertRaises(TypeError,Path,p.es)
def Config.TestModuleCommand.testPrefers (   self)

Definition at line 1598 of file Config.py.

1598 
1599  def testPrefers(self):
1600  p = Process("Test")
1601  p.add_(ESSource("ForceSource"))
1602  p.juicer = ESProducer("JuicerProducer")
1603  p.prefer("ForceSource")
1604  p.prefer("juicer")
1605  self.assertEqual(p.dumpConfig(),
1606 """process Test = {
1607  es_module juicer = JuicerProducer {
1608  }
1609  es_source = ForceSource {
1610  }
1611  es_prefer = ForceSource {
1612  }
1613  es_prefer juicer = JuicerProducer {
1614  }
1615 }
1616 """)
1617  p.prefer("juicer",fooRcd=vstring("Foo"))
1618  self.assertEqual(p.dumpConfig(),
1619 """process Test = {
1620  es_module juicer = JuicerProducer {
1621  }
1622  es_source = ForceSource {
1623  }
1624  es_prefer = ForceSource {
1625  }
1626  es_prefer juicer = JuicerProducer {
1627  vstring fooRcd = {
1628  'Foo'
1629  }
1630 
1631  }
1632 }
1633 """)
1634  self.assertEqual(p.dumpPython(),
1635 """import FWCore.ParameterSet.Config as cms
1636 
1637 process = cms.Process("Test")
1638 
1639 process.juicer = cms.ESProducer("JuicerProducer")
1640 
1641 
1642 process.ForceSource = cms.ESSource("ForceSource")
1643 
1644 
1645 process.prefer("ForceSource")
1646 
1647 process.prefer("juicer",
1648  fooRcd = cms.vstring('Foo')
1649 )
1650 
1651 """)
def Config.TestModuleCommand.testProcessDumpPython (   self)

Definition at line 1296 of file Config.py.

1296 
1297  def testProcessDumpPython(self):
1298  p = Process("test")
1299  p.a = EDAnalyzer("MyAnalyzer")
1300  p.p = Path(p.a)
1301  p.s = Sequence(p.a)
1302  p.r = Sequence(p.s)
1303  p.p2 = Path(p.s)
1304  p.schedule = Schedule(p.p2,p.p)
1305  d=p.dumpPython()
1306  self.assertEqual(d,
1307 """import FWCore.ParameterSet.Config as cms
1308 
1309 process = cms.Process("test")
1310 
1311 process.a = cms.EDAnalyzer("MyAnalyzer")
1312 
1313 
1314 process.s = cms.Sequence(process.a)
1315 
1316 
1317 process.r = cms.Sequence(process.s)
1318 
1319 
1320 process.p = cms.Path(process.a)
1321 
1322 
1323 process.p2 = cms.Path(process.s)
1324 
1325 
1326 process.schedule = cms.Schedule(*[ process.p2, process.p ])
1327 """)
1328  #Reverse order of 'r' and 's'
1329  p = Process("test")
1330  p.a = EDAnalyzer("MyAnalyzer")
1331  p.p = Path(p.a)
1332  p.r = Sequence(p.a)
1333  p.s = Sequence(p.r)
1334  p.p2 = Path(p.r)
1335  p.schedule = Schedule(p.p2,p.p)
1336  p.b = EDAnalyzer("YourAnalyzer")
1337  d=p.dumpPython()
1338  self.assertEqual(d,
1339 """import FWCore.ParameterSet.Config as cms
1340 
1341 process = cms.Process("test")
1342 
1343 process.a = cms.EDAnalyzer("MyAnalyzer")
1344 
1345 
1346 process.b = cms.EDAnalyzer("YourAnalyzer")
1347 
1348 
1349 process.r = cms.Sequence(process.a)
1350 
1351 
1352 process.s = cms.Sequence(process.r)
1353 
1354 
1355 process.p = cms.Path(process.a)
1356 
1357 
1358 process.p2 = cms.Path(process.r)
1359 
1360 
1361 process.schedule = cms.Schedule(*[ process.p2, process.p ])
""")
def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 1226 of file Config.py.

References python.multivaluedict.__init__(), and dbtoconf.object.

1226 
1227  def testProcessExtend(self):
1228  class FromArg(object):
1229  def __init__(self,*arg,**args):
1230  for name in args.iterkeys():
1231  self.__dict__[name]=args[name]
1232 
1233  a=EDAnalyzer("MyAnalyzer")
1234  t=EDAnalyzer("MyAnalyzer")
1235  t.setLabel("foo")
1236  s1 = Sequence(a)
1237  s2 = Sequence(s1)
1238  s3 = Sequence(s2)
1239  d = FromArg(
1240  a=a,
1241  b=Service("Full"),
1242  c=Path(a),
1243  d=s2,
1244  e=s1,
1245  f=s3,
1246  g=Sequence(s1+s2+s3)
1247  )
1248  p = Process("Test")
1249  p.extend(d)
1250  self.assertEqual(p.a.type_(),"MyAnalyzer")
1251  self.assertEqual(p.a.label_(),"a")
1252  self.assertRaises(AttributeError,getattr,p,'b')
1253  self.assertEqual(p.Full.type_(),"Full")
1254  self.assertEqual(str(p.c),'a')
1255  self.assertEqual(str(p.d),'a')
1256 
1257  z1 = FromArg(
1258  a=a,
1259  b=Service("Full"),
1260  c=Path(a),
1261  d=s2,
1262  e=s1,
1263  f=s3,
1264  s4=s3,
1265  g=Sequence(s1+s2+s3)
1266  )
1267 
1268  p1 = Process("Test")
1269  #p1.extend(z1)
1270  self.assertRaises(ValueError, p1.extend, z1)
1271 
1272  z2 = FromArg(
1273  a=a,
1274  b=Service("Full"),
1275  c=Path(a),
1276  d=s2,
1277  e=s1,
1278  f=s3,
1279  aaa=copy.deepcopy(a),
1280  s4=copy.deepcopy(s3),
1281  g=Sequence(s1+s2+s3),
1282  t=t
1283  )
1284  p2 = Process("Test")
1285  p2.extend(z2)
1286  #self.assertRaises(ValueError, p2.extend, z2)
1287  self.assertEqual(p2.s4.label_(),"s4")
1288  #p2.s4.setLabel("foo")
1289  self.assertRaises(ValueError, p2.s4.setLabel, "foo")
1290  p2.s4.setLabel("s4")
1291  p2.s4.setLabel(None)
1292  p2.s4.setLabel("foo")
1293  p2._Process__setObjectLabel(p2.s4, "foo")
1294  p2._Process__setObjectLabel(p2.s4, None)
1295  p2._Process__setObjectLabel(p2.s4, "bar")
dbtoconf.object
list object
Definition: dbtoconf.py:77
def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 1201 of file Config.py.

1201 
1202  def testProcessInsertion(self):
1203  p = Process("test")
1204  p.a = EDAnalyzer("MyAnalyzer")
1205  self.assert_( 'a' in p.analyzers_() )
1206  self.assert_( 'a' in p.analyzers)
1207  p.add_(Service("MessageLogger"))
1208  self.assert_('MessageLogger' in p.services_())
1209  self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
1210  p.Tracer = Service("Tracer")
1211  self.assert_('Tracer' in p.services_())
1212  self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
1213  self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
1214  self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
1215  p.out = OutputModule("Outer")
1216  self.assertEqual(p.out.type_(), 'Outer')
1217  self.assert_( 'out' in p.outputModules_() )
1218 
1219  p.geom = ESSource("GeomProd")
1220  self.assert_('geom' in p.es_sources_())
1221  p.add_(ESSource("ConfigDB"))
1222  self.assert_('ConfigDB' in p.es_sources_())
1223 
1224  p.aliasfoo1 = EDAlias(foo1 = VPSet(PSet(type = string("Foo1"))))
1225  self.assert_('aliasfoo1' in p.aliases_())
def Config.TestModuleCommand.testPrune (   self)

Definition at line 1725 of file Config.py.

1725 
1726  def testPrune(self):
1727  p = Process("test")
1728  p.a = EDAnalyzer("MyAnalyzer")
1729  p.b = EDAnalyzer("YourAnalyzer")
1730  p.c = EDAnalyzer("OurAnalyzer")
1731  p.d = EDAnalyzer("OurAnalyzer")
1732  p.s = Sequence(p.d)
1733  p.path1 = Path(p.a)
1734  p.path2 = Path(p.b)
1735  self.assert_(p.schedule is None)
1736  pths = p.paths
1737  keys = pths.keys()
1738  self.assertEqual(pths[keys[0]],p.path1)
1739  self.assertEqual(pths[keys[1]],p.path2)
1740  p.pset1 = PSet(parA = string("pset1"))
1741  p.pset2 = untracked.PSet(parA = string("pset2"))
1742  p.vpset1 = VPSet()
1743  p.vpset2 = untracked.VPSet()
1744  p.prune()
1745  self.assert_(hasattr(p, 'a'))
1746  self.assert_(hasattr(p, 'b'))
1747  self.assert_(not hasattr(p, 'c'))
1748  self.assert_(not hasattr(p, 'd'))
1749  self.assert_(not hasattr(p, 's'))
1750  self.assert_(hasattr(p, 'path1'))
1751  self.assert_(hasattr(p, 'path2'))
1752 # self.assert_(not hasattr(p, 'pset1'))
1753 # self.assert_(hasattr(p, 'pset2'))
1754 # self.assert_(not hasattr(p, 'vpset1'))
1755 # self.assert_(not hasattr(p, 'vpset2'))
1756 
1757  p = Process("test")
1758  p.a = EDAnalyzer("MyAnalyzer")
1759  p.b = EDAnalyzer("YourAnalyzer")
1760  p.c = EDAnalyzer("OurAnalyzer")
1761  p.d = EDAnalyzer("OurAnalyzer")
1762  p.e = EDAnalyzer("OurAnalyzer")
1763  p.s = Sequence(p.d)
1764  p.s2 = Sequence(p.b)
1765  p.s3 = Sequence(p.e)
1766  p.path1 = Path(p.a)
1767  p.path2 = Path(p.b)
1768  p.path3 = Path(p.b+p.s2)
1769  p.path4 = Path(p.b+p.s3)
1770  p.schedule = Schedule(p.path1,p.path2,p.path3)
1771  pths = p.paths
1772  keys = pths.keys()
1773  self.assertEqual(pths[keys[0]],p.path1)
1774  self.assertEqual(pths[keys[1]],p.path2)
1775  p.prune()
1776  self.assert_(hasattr(p, 'a'))
1777  self.assert_(hasattr(p, 'b'))
1778  self.assert_(not hasattr(p, 'c'))
1779  self.assert_(not hasattr(p, 'd'))
1780  self.assert_(not hasattr(p, 'e'))
1781  self.assert_(not hasattr(p, 's'))
1782  self.assert_(hasattr(p, 's2'))
1783  self.assert_(not hasattr(p, 's3'))
1784  self.assert_(hasattr(p, 'path1'))
1785  self.assert_(hasattr(p, 'path2'))
1786  self.assert_(hasattr(p, 'path3'))
1787  self.assert_(not hasattr(p, 'path4'))
1788  #test SequencePlaceholder
1789  p = Process("test")
1790  p.a = EDAnalyzer("MyAnalyzer")
1791  p.b = EDAnalyzer("YourAnalyzer")
1792  p.s = Sequence(SequencePlaceholder("a")+p.b)
1793  p.pth = Path(p.s)
1794  p.prune()
1795  self.assert_(hasattr(p, 'a'))
1796  self.assert_(hasattr(p, 'b'))
1797  self.assert_(hasattr(p, 's'))
self.assert_(hasattr(p, 'pth'))
def Config.TestModuleCommand.testRefToPSet (   self)

Definition at line 1709 of file Config.py.

1709 
1710  def testRefToPSet(self):
1711  proc = Process("test")
1712  proc.top = PSet(a = int32(1))
1713  proc.ref = PSet(refToPSet_ = string("top"))
1714  proc.ref2 = PSet( a = int32(1), b = PSet( refToPSet_ = string("top")))
1715  proc.ref3 = PSet(refToPSet_ = string("ref"))
1716  proc.ref4 = VPSet(PSet(refToPSet_ = string("top")),
1717  PSet(refToPSet_ = string("ref2")))
1718  p = TestMakePSet()
1719  proc.fillProcessDesc(p)
1720  self.assertEqual((True,1),p.values["ref"][1].values["a"])
1721  self.assertEqual((True,1),p.values["ref3"][1].values["a"])
1722  self.assertEqual((True,1),p.values["ref2"][1].values["a"])
1723  self.assertEqual((True,1),p.values["ref2"][1].values["b"][1].values["a"])
1724  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 1469 of file Config.py.

1469 
1470  def testSchedule(self):
1471  p = Process("test")
1472  p.a = EDAnalyzer("MyAnalyzer")
1473  p.b = EDAnalyzer("YourAnalyzer")
1474  p.c = EDAnalyzer("OurAnalyzer")
1475  p.d = EDAnalyzer("OurAnalyzer")
1476  p.path1 = Path(p.a)
1477  p.path2 = Path(p.b)
1478  p.path3 = Path(p.d)
1479 
1480  s = Schedule(p.path1,p.path2)
1481  self.assertEqual(s[0],p.path1)
1482  self.assertEqual(s[1],p.path2)
1483  p.schedule = s
1484  self.assert_('b' in p.schedule.moduleNames())
1485  self.assert_(hasattr(p, 'b'))
1486  self.assert_(hasattr(p, 'c'))
1487  self.assert_(hasattr(p, 'd'))
1488  self.assert_(hasattr(p, 'path1'))
1489  self.assert_(hasattr(p, 'path2'))
1490  self.assert_(hasattr(p, 'path3'))
1491  p.prune()
1492  self.assert_('b' in p.schedule.moduleNames())
1493  self.assert_(hasattr(p, 'b'))
1494  self.assert_(not hasattr(p, 'c'))
1495  self.assert_(not hasattr(p, 'd'))
1496  self.assert_(hasattr(p, 'path1'))
1497  self.assert_(hasattr(p, 'path2'))
1498  self.assert_(not hasattr(p, 'path3'))
1499 
1500  #adding a path not attached to the Process should cause an exception
1501  p = Process("test")
1502  p.a = EDAnalyzer("MyAnalyzer")
1503  path1 = Path(p.a)
1504  s = Schedule(path1)
1505  self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
1506 
1507  #make sure anonymous sequences work
1508  p = Process("test")
1509  p.a = EDAnalyzer("MyAnalyzer")
1510  p.b = EDAnalyzer("MyOtherAnalyzer")
1511  p.c = EDProducer("MyProd")
1512  path1 = Path(p.c*Sequence(p.a+p.b))
1513  s = Schedule(path1)
1514  self.assert_('a' in s.moduleNames())
1515  self.assert_('b' in s.moduleNames())
1516  self.assert_('c' in s.moduleNames())
1517  p.path1 = path1
1518  p.schedule = s
1519  p.prune()
1520  self.assert_('a' in s.moduleNames())
1521  self.assert_('b' in s.moduleNames())
1522  self.assert_('c' in s.moduleNames())
def Config.TestModuleCommand.testSecSource (   self)

Definition at line 1391 of file Config.py.

References python.rootplot.root2matplotlib.replace().

1391 
1392  def testSecSource(self):
1393  p = Process('test')
1394  p.a = SecSource("MySecSource")
1395  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 1406 of file Config.py.

1406 
1407  def testSequence(self):
1408  p = Process('test')
1409  p.a = EDAnalyzer("MyAnalyzer")
1410  p.b = EDAnalyzer("YourAnalyzer")
1411  p.c = EDAnalyzer("OurAnalyzer")
1412  p.s = Sequence(p.a*p.b)
1413  self.assertEqual(str(p.s),'a+b')
1414  self.assertEqual(p.s.label_(),'s')
1415  path = Path(p.c+p.s)
1416  self.assertEqual(str(path),'c+a+b')
1417  p._validateSequence(path, 'p1')
1418  notInProcess = EDAnalyzer('NotInProcess')
1419  p2 = Path(p.c+p.s*notInProcess)
1420  self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
def Config.TestModuleCommand.testSequence2 (   self)

Definition at line 1421 of file Config.py.

1421 
1422  def testSequence2(self):
1423  p = Process('test')
1424  p.a = EDAnalyzer("MyAnalyzer")
1425  p.b = EDAnalyzer("YourAnalyzer")
1426  p.c = EDAnalyzer("OurAnalyzer")
1427  testseq = Sequence(p.a*p.b)
1428  p.s = testseq
1429  #p.y = testseq
1430  self.assertRaises(ValueError, p.__setattr__, "y", testseq)
def Config.TestModuleCommand.testSubProcess (   self)

Definition at line 1670 of file Config.py.

References cond.hash.

1670 
1671  def testSubProcess(self):
1672  process = Process("Parent")
1673  subProcess = Process("Child")
1674  subProcess.a = EDProducer("A")
1675  subProcess.p = Path(subProcess.a)
1676  subProcess.add_(Service("Foo"))
1677  process.add_( SubProcess(subProcess) )
1678  d = process.dumpPython()
1679  equalD ="""import FWCore.ParameterSet.Config as cms
1680 
1681 process = cms.Process("Parent")
1682 
1683 parentProcess = process
1684 import FWCore.ParameterSet.Config as cms
1685 
1686 process = cms.Process("Child")
1687 
1688 process.a = cms.EDProducer("A")
1689 
1690 
1691 process.p = cms.Path(process.a)
1692 
1693 
1694 process.Foo = cms.Service("Foo")
1695 
1696 
1697 childProcess = process
1698 process = parentProcess
1699 process.subProcess = cms.SubProcess( process = childProcess, SelectEvents = cms.untracked.PSet(
1700 
1701 ), outputCommands = cms.untracked.vstring())
1702 """
1703  equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcess)))
1704  self.assertEqual(d,equalD)
1705  p = TestMakePSet()
1706  process.subProcess.insertInto(p,"dummy")
1707  self.assertEqual((True,['a']),p.values["@sub_process"][1].values["process"][1].values['@all_modules'])
1708  self.assertEqual((True,['p']),p.values["@sub_process"][1].values["process"][1].values['@paths'])
self.assertEqual({'@service_type':(True,'Foo')}, p.values["@sub_process"][1].values["process"][1].values["services"][1][0].values)
def Config.TestModuleCommand.testTypedParameterizable (   self)

Definition at line 1194 of file Config.py.

1194 
1195  def testTypedParameterizable(self):
1196  p = _TypedParameterizable("blah", b=int32(1))
1197  #see if copy works deeply
1198  other = p.copy()
1199  other.b = 2
1200  self.assertNotEqual(p.b,other.b)
Mixins._TypedParameterizable
Definition: Mixins.py:257
def Config.TestModuleCommand.testUsing (   self)

Definition at line 1556 of file Config.py.

1556 
1557  def testUsing(self):
1558  p = Process('test')
1559  p.block = PSet(a = int32(1))
1560  p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
1561  self.assertEqual(p.modu.a.value(),1)
1562  self.assertEqual(p.modu.b.value(),2)

Member Data Documentation

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

Definition at line 1370 of file Config.py.

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

Definition at line 1363 of file Config.py.

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

Definition at line 1366 of file Config.py.

Generated for CMSSW Reference Manual by doxygen 1.8.5