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 testOverride
 
def testParameterizable
 
def testPath
 
def testPrefers
 
def testProcessDumpPython
 
def testProcessExtend
 
def testProcessInsertion
 
def testPrune
 
def testSchedule
 
def testSecSource
 
def testSequence
 
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 991 of file Config.py.

Member Function Documentation

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

Definition at line 992 of file Config.py.

992 
993  def setUp(self):
994  """Nothing to do """
None
def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 1231 of file Config.py.

References errorMatrix2Lands_multiChannel.id.

1231 
1232  def testCloneSequence(self):
1233  p = Process("test")
1234  a = EDAnalyzer("MyAnalyzer")
1235  p.a = a
1236  a.setLabel("a")
1237  b = EDAnalyzer("YOurAnalyzer")
1238  p.b = b
1239  b.setLabel("b")
1240  path = Path(a * b)
1241  p.path = Path(p.a*p.b)
1242  lookuptable = {id(a): p.a, id(b): p.b}
1243  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1244  #lookuptable = p._cloneToObjectDict
1245  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1246  self.assertEqual(str(path),str(p.path))
errorMatrix2Lands_multiChannel.id
tuple id
Definition: errorMatrix2Lands_multiChannel.py:151
def Config.TestModuleCommand.testExamples (   self)

Definition at line 1364 of file Config.py.

References Types.untracked.

1364 
1365  def testExamples(self):
1366  p = Process("Test")
1367  p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
1368  p.foos = EDProducer("FooProducer")
1369  p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
1370  p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
1371  p.bars.foos = 'Foosball'
1372  self.assertEqual(p.bars.foos, InputTag('Foosball'))
1373  p.p = Path(p.foos*p.bars)
1374  p.e = EndPath(p.out)
1375  p.add_(Service("MessageLogger"))
Types.untracked
tuple untracked
Definition: Types.py:29
def Config.TestModuleCommand.testFreeze (   self)

Definition at line 1430 of file Config.py.

1430 
1431  def testFreeze(self):
1432  process = Process("Freeze")
1433  m = EDProducer("M", p=PSet(i = int32(1)))
1434  m.p.i = 2
1435  process.m = m
1436  # should be frozen
1437  #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
1438  #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
1439  #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
1440  #self.assertRaises(ValueError, setattr, m, 'j', 1)
1441  # But OK to change through the process
1442  process.m.p.i = 4
1443  self.assertEqual(process.m.p.i.value(), 4)
1444  process.m.p = PSet(j=int32(1))
1445  # should work to clone it, though
1446  m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
1447  m2.p.i = 6
m2.j = 8
def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 1184 of file Config.py.

1184 
1185  def testGlobalReplace(self):
1186  p = Process('test')
1187  p.a = EDAnalyzer("MyAnalyzer")
1188  p.b = EDAnalyzer("YourAnalyzer")
1189  p.c = EDAnalyzer("OurAnalyzer")
1190  p.s = Sequence(p.a*p.b)
1191  p.p = Path(p.c+p.s+p.a)
1192  new = EDAnalyzer("NewAnalyzer")
1193  p.globalReplace("a",new)
def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 1301 of file Config.py.

1301 
1302  def testImplicitSchedule(self):
1303  p = Process("test")
1304  p.a = EDAnalyzer("MyAnalyzer")
1305  p.b = EDAnalyzer("YourAnalyzer")
1306  p.c = EDAnalyzer("OurAnalyzer")
1307  p.path1 = Path(p.a)
1308  p.path2 = Path(p.b)
1309  self.assert_(p.schedule is None)
1310  pths = p.paths
1311  keys = pths.keys()
1312  self.assertEqual(pths[keys[0]],p.path1)
1313  self.assertEqual(pths[keys[1]],p.path2)
1314  p.prune()
1315  self.assert_(hasattr(p, 'a'))
1316  self.assert_(hasattr(p, 'b'))
1317  self.assert_(not hasattr(p, 'c'))
1318  self.assert_(hasattr(p, 'path1'))
1319  self.assert_(hasattr(p, 'path2'))
1320 
1321 
1322  p = Process("test")
1323  p.a = EDAnalyzer("MyAnalyzer")
1324  p.b = EDAnalyzer("YourAnalyzer")
1325  p.c = EDAnalyzer("OurAnalyzer")
1326  p.path2 = Path(p.b)
1327  p.path1 = Path(p.a)
1328  self.assert_(p.schedule is None)
1329  pths = p.paths
1330  keys = pths.keys()
1331  self.assertEqual(pths[keys[1]],p.path1)
1332  self.assertEqual(pths[keys[0]],p.path2)
1333 
def Config.TestModuleCommand.testOverride (   self)

Definition at line 1341 of file Config.py.

1341 
1342  def testOverride(self):
1343  p = Process('test')
1344  a = EDProducer("A", a1=int32(0))
1345  self.assert_(not a.isModified())
1346  a.a1 = 1
1347  self.assert_(a.isModified())
1348  p.a = a
1349  self.assertEqual(p.a.a1.value(), 1)
1350  # try adding an unmodified module.
1351  # should accept it
1352  p.a = EDProducer("A", a1=int32(2))
1353  self.assertEqual(p.a.a1.value(), 2)
1354  # try adding a modified module. Should throw
1355  # no longer, since the same (modified) say, geometry
1356  # could come from more than one cff
1357  b = EDProducer("A", a1=int32(3))
1358  b.a1 = 4
1359  #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
1360  ps1 = PSet(a = int32(1))
1361  ps2 = PSet(a = int32(2))
1362  self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
1363  self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 995 of file Config.py.

995 
996  def testParameterizable(self):
997  p = _Parameterizable()
998  self.assertEqual(len(p.parameterNames_()),0)
999  p.a = int32(1)
1000  self.assert_('a' in p.parameterNames_())
1001  self.assertEqual(p.a.value(), 1)
1002  p.a = 10
1003  self.assertEqual(p.a.value(), 10)
1004  p.a = untracked(int32(1))
1005  self.assertEqual(p.a.value(), 1)
1006  self.failIf(p.a.isTracked())
1007  p.a = untracked.int32(1)
1008  self.assertEqual(p.a.value(), 1)
1009  self.failIf(p.a.isTracked())
1010  p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
1011  self.assertEqual(p.foo.value(), 10)
1012  self.assertEqual(p.bar.value(),1.0)
1013  self.failIf(p.bar.isTracked())
1014  self.assertRaises(TypeError,setattr,(p,'c',1))
1015  p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
1016  self.assertEqual(p.a.foo.value(),10)
1017  self.assertEqual(p.a.bar.value(),1.0)
1018  p.b = untracked(PSet(fii = int32(1)))
1019  self.assertEqual(p.b.fii.value(),1)
1020  self.failIf(p.b.isTracked())
1021  #test the fact that values can be shared
1022  v = int32(10)
1023  p=_Parameterizable(a=v)
1024  v.setValue(11)
1025  self.assertEqual(p.a.value(),11)
1026  p.a = 12
1027  self.assertEqual(p.a.value(),12)
self.assertEqual(v.value(),12)
Mixins._Parameterizable
Definition: Mixins.py:108
Types.untracked
tuple untracked
Definition: Types.py:29
def Config.TestModuleCommand.testPath (   self)

Definition at line 1209 of file Config.py.

1209 
1210  def testPath(self):
1211  p = Process("test")
1212  p.a = EDAnalyzer("MyAnalyzer")
1213  p.b = EDAnalyzer("YourAnalyzer")
1214  p.c = EDAnalyzer("OurAnalyzer")
1215  path = Path(p.a)
1216  path *= p.b
1217  path += p.c
1218  self.assertEqual(str(path),'a+b+c')
1219  path = Path(p.a*p.b+p.c)
1220  self.assertEqual(str(path),'a+b+c')
1221 # path = Path(p.a)*p.b+p.c #This leads to problems with sequences
1222 # self.assertEqual(str(path),'((a*b)+c)')
1223  path = Path(p.a+ p.b*p.c)
1224  self.assertEqual(str(path),'a+b+c')
1225  path = Path(p.a*(p.b+p.c))
1226  self.assertEqual(str(path),'a+b+c')
1227  path = Path(p.a*(p.b+~p.c))
1228  self.assertEqual(str(path),'a+b+~c')
1229  p.es = ESProducer("AnESProducer")
1230  self.assertRaises(TypeError,Path,p.es)
def Config.TestModuleCommand.testPrefers (   self)

Definition at line 1376 of file Config.py.

1376 
1377  def testPrefers(self):
1378  p = Process("Test")
1379  p.add_(ESSource("ForceSource"))
1380  p.juicer = ESProducer("JuicerProducer")
1381  p.prefer("ForceSource")
1382  p.prefer("juicer")
1383  self.assertEqual(p.dumpConfig(),
1384 """process Test = {
1385  es_module juicer = JuicerProducer {
1386  }
1387  es_source = ForceSource {
1388  }
1389  es_prefer = ForceSource {
1390  }
1391  es_prefer juicer = JuicerProducer {
1392  }
1393 }
1394 """)
1395  p.prefer("juicer",fooRcd=vstring("Foo"))
1396  self.assertEqual(p.dumpConfig(),
1397 """process Test = {
1398  es_module juicer = JuicerProducer {
1399  }
1400  es_source = ForceSource {
1401  }
1402  es_prefer = ForceSource {
1403  }
1404  es_prefer juicer = JuicerProducer {
1405  vstring fooRcd = {
1406  'Foo'
1407  }
1408 
1409  }
1410 }
1411 """)
1412  self.assertEqual(p.dumpPython(),
1413 """import FWCore.ParameterSet.Config as cms
1414 
1415 process = cms.Process("Test")
1416 
1417 process.juicer = cms.ESProducer("JuicerProducer")
1418 
1419 
1420 process.ForceSource = cms.ESSource("ForceSource")
1421 
1422 
1423 process.prefer("ForceSource")
1424 
1425 process.prefer("juicer",
1426  fooRcd = cms.vstring('Foo')
1427 )
1428 
1429 """)
def Config.TestModuleCommand.testProcessDumpPython (   self)

Definition at line 1084 of file Config.py.

1084 
1085  def testProcessDumpPython(self):
1086  p = Process("test")
1087  p.a = EDAnalyzer("MyAnalyzer")
1088  p.p = Path(p.a)
1089  p.s = Sequence(p.a)
1090  p.r = Sequence(p.s)
1091  p.p2 = Path(p.s)
1092  p.schedule = Schedule(p.p2,p.p)
1093  d=p.dumpPython()
1094  self.assertEqual(d,
1095 """import FWCore.ParameterSet.Config as cms
1096 
1097 process = cms.Process("test")
1098 
1099 process.a = cms.EDAnalyzer("MyAnalyzer")
1100 
1101 
1102 process.s = cms.Sequence(process.a)
1103 
1104 
1105 process.r = cms.Sequence(process.s)
1106 
1107 
1108 process.p = cms.Path(process.a)
1109 
1110 
1111 process.p2 = cms.Path(process.s)
1112 
1113 
1114 process.schedule = cms.Schedule(*[ process.p2, process.p ])
1115 """)
1116  #Reverse order of 'r' and 's'
1117  p = Process("test")
1118  p.a = EDAnalyzer("MyAnalyzer")
1119  p.p = Path(p.a)
1120  p.r = Sequence(p.a)
1121  p.s = Sequence(p.r)
1122  p.p2 = Path(p.r)
1123  p.schedule = Schedule(p.p2,p.p)
1124  p.b = EDAnalyzer("YourAnalyzer")
1125  d=p.dumpPython()
1126  self.assertEqual(d,
1127 """import FWCore.ParameterSet.Config as cms
1128 
1129 process = cms.Process("test")
1130 
1131 process.a = cms.EDAnalyzer("MyAnalyzer")
1132 
1133 
1134 process.b = cms.EDAnalyzer("YourAnalyzer")
1135 
1136 
1137 process.r = cms.Sequence(process.a)
1138 
1139 
1140 process.s = cms.Sequence(process.r)
1141 
1142 
1143 process.p = cms.Path(process.a)
1144 
1145 
1146 process.p2 = cms.Path(process.r)
1147 
1148 
1149 process.schedule = cms.Schedule(*[ process.p2, process.p ])
""")
def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 1057 of file Config.py.

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

1057 
1058  def testProcessExtend(self):
1059  class FromArg(object):
1060  def __init__(self,*arg,**args):
1061  for name in args.iterkeys():
1062  self.__dict__[name]=args[name]
1063 
1064  a=EDAnalyzer("MyAnalyzer")
1065  s1 = Sequence(a)
1066  s2 = Sequence(s1)
1067  s3 = Sequence(s2)
1068  d = FromArg(
1069  a=a,
1070  b=Service("Full"),
1071  c=Path(a),
1072  d=s2,
1073  e=s1,
1074  f=s3,
1075  g=Sequence(s1+s2+s3)
1076  )
1077  p = Process("Test")
1078  p.extend(d)
1079  self.assertEqual(p.a.type_(),"MyAnalyzer")
1080  self.assertRaises(AttributeError,getattr,p,'b')
1081  self.assertEqual(p.Full.type_(),"Full")
1082  self.assertEqual(str(p.c),'a')
1083  self.assertEqual(str(p.d),'a')
dbtoconf.object
list object
Definition: dbtoconf.py:77
def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 1035 of file Config.py.

1035 
1036  def testProcessInsertion(self):
1037  p = Process("test")
1038  p.a = EDAnalyzer("MyAnalyzer")
1039  self.assert_( 'a' in p.analyzers_() )
1040  self.assert_( 'a' in p.analyzers)
1041  p.add_(Service("MessageLogger"))
1042  self.assert_('MessageLogger' in p.services_())
1043  self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
1044  p.Tracer = Service("Tracer")
1045  self.assert_('Tracer' in p.services_())
1046  self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
1047  self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
1048  self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
1049  p.out = OutputModule("Outer")
1050  self.assertEqual(p.out.type_(), 'Outer')
1051  self.assert_( 'out' in p.outputModules_() )
1052 
1053  p.geom = ESSource("GeomProd")
1054  self.assert_('geom' in p.es_sources_())
1055  p.add_(ESSource("ConfigDB"))
1056  self.assert_('ConfigDB' in p.es_sources_())
def Config.TestModuleCommand.testPrune (   self)

Definition at line 1487 of file Config.py.

1487 
1488  def testPrune(self):
1489  p = Process("test")
1490  p.a = EDAnalyzer("MyAnalyzer")
1491  p.b = EDAnalyzer("YourAnalyzer")
1492  p.c = EDAnalyzer("OurAnalyzer")
1493  p.d = EDAnalyzer("OurAnalyzer")
1494  p.s = Sequence(p.d)
1495  p.path1 = Path(p.a)
1496  p.path2 = Path(p.b)
1497  self.assert_(p.schedule is None)
1498  pths = p.paths
1499  keys = pths.keys()
1500  self.assertEqual(pths[keys[0]],p.path1)
1501  self.assertEqual(pths[keys[1]],p.path2)
1502  p.prune()
1503  self.assert_(hasattr(p, 'a'))
1504  self.assert_(hasattr(p, 'b'))
1505  self.assert_(not hasattr(p, 'c'))
1506  self.assert_(not hasattr(p, 'd'))
1507  self.assert_(not hasattr(p, 's'))
1508  self.assert_(hasattr(p, 'path1'))
1509  self.assert_(hasattr(p, 'path2'))
1510 
1511  p = Process("test")
1512  p.a = EDAnalyzer("MyAnalyzer")
1513  p.b = EDAnalyzer("YourAnalyzer")
1514  p.c = EDAnalyzer("OurAnalyzer")
1515  p.d = EDAnalyzer("OurAnalyzer")
1516  p.e = EDAnalyzer("OurAnalyzer")
1517  p.s = Sequence(p.d)
1518  p.s2 = Sequence(p.b)
1519  p.s3 = Sequence(p.e)
1520  p.path1 = Path(p.a)
1521  p.path2 = Path(p.b)
1522  p.path3 = Path(p.b+p.s2)
1523  p.path4 = Path(p.b+p.s3)
1524  p.schedule = Schedule(p.path1,p.path2,p.path3)
1525  pths = p.paths
1526  keys = pths.keys()
1527  self.assertEqual(pths[keys[0]],p.path1)
1528  self.assertEqual(pths[keys[1]],p.path2)
1529  p.prune()
1530  self.assert_(hasattr(p, 'a'))
1531  self.assert_(hasattr(p, 'b'))
1532  self.assert_(not hasattr(p, 'c'))
1533  self.assert_(not hasattr(p, 'd'))
1534  self.assert_(not hasattr(p, 'e'))
1535  self.assert_(not hasattr(p, 's'))
1536  self.assert_(hasattr(p, 's2'))
1537  self.assert_(not hasattr(p, 's3'))
1538  self.assert_(hasattr(p, 'path1'))
1539  self.assert_(hasattr(p, 'path2'))
1540  self.assert_(hasattr(p, 'path3'))
1541  self.assert_(not hasattr(p, 'path4'))
1542  #test SequencePlaceholder
1543  p = Process("test")
1544  p.a = EDAnalyzer("MyAnalyzer")
1545  p.b = EDAnalyzer("YourAnalyzer")
1546  p.s = Sequence(SequencePlaceholder("a")+p.b)
1547  p.pth = Path(p.s)
1548  p.prune()
1549  self.assert_(hasattr(p, 'a'))
1550  self.assert_(hasattr(p, 'b'))
1551  self.assert_(hasattr(p, 's'))
1552  self.assert_(hasattr(p, 'pth'))
1553 
unittest.main()
def Config.TestModuleCommand.testSchedule (   self)

Definition at line 1247 of file Config.py.

1247 
1248  def testSchedule(self):
1249  p = Process("test")
1250  p.a = EDAnalyzer("MyAnalyzer")
1251  p.b = EDAnalyzer("YourAnalyzer")
1252  p.c = EDAnalyzer("OurAnalyzer")
1253  p.d = EDAnalyzer("OurAnalyzer")
1254  p.path1 = Path(p.a)
1255  p.path2 = Path(p.b)
1256  p.path3 = Path(p.d)
1257 
1258  s = Schedule(p.path1,p.path2)
1259  self.assertEqual(s[0],p.path1)
1260  self.assertEqual(s[1],p.path2)
1261  p.schedule = s
1262  self.assert_('b' in p.schedule.moduleNames())
1263  self.assert_(hasattr(p, 'b'))
1264  self.assert_(hasattr(p, 'c'))
1265  self.assert_(hasattr(p, 'd'))
1266  self.assert_(hasattr(p, 'path1'))
1267  self.assert_(hasattr(p, 'path2'))
1268  self.assert_(hasattr(p, 'path3'))
1269  p.prune()
1270  self.assert_('b' in p.schedule.moduleNames())
1271  self.assert_(hasattr(p, 'b'))
1272  self.assert_(not hasattr(p, 'c'))
1273  self.assert_(not hasattr(p, 'd'))
1274  self.assert_(hasattr(p, 'path1'))
1275  self.assert_(hasattr(p, 'path2'))
1276  self.assert_(not hasattr(p, 'path3'))
1277 
1278  #adding a path not attached to the Process should cause an exception
1279  p = Process("test")
1280  p.a = EDAnalyzer("MyAnalyzer")
1281  path1 = Path(p.a)
1282  s = Schedule(path1)
1283  self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
1284 
1285  #make sure anonymous sequences work
1286  p = Process("test")
1287  p.a = EDAnalyzer("MyAnalyzer")
1288  p.b = EDAnalyzer("MyOtherAnalyzer")
1289  p.c = EDProducer("MyProd")
1290  path1 = Path(p.c*Sequence(p.a+p.b))
1291  s = Schedule(path1)
1292  self.assert_('a' in s.moduleNames())
1293  self.assert_('b' in s.moduleNames())
1294  self.assert_('c' in s.moduleNames())
1295  p.path1 = path1
1296  p.schedule = s
1297  p.prune()
1298  self.assert_('a' in s.moduleNames())
1299  self.assert_('b' in s.moduleNames())
1300  self.assert_('c' in s.moduleNames())
def Config.TestModuleCommand.testSecSource (   self)

Definition at line 1179 of file Config.py.

References python.rootplot.root2matplotlib.replace().

1179 
1180  def testSecSource(self):
1181  p = Process('test')
1182  p.a = SecSource("MySecSource")
1183  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 1194 of file Config.py.

1194 
1195  def testSequence(self):
1196  p = Process('test')
1197  p.a = EDAnalyzer("MyAnalyzer")
1198  p.b = EDAnalyzer("YourAnalyzer")
1199  p.c = EDAnalyzer("OurAnalyzer")
1200  p.s = Sequence(p.a*p.b)
1201  self.assertEqual(str(p.s),'a+b')
1202  self.assertEqual(p.s.label_(),'s')
1203  path = Path(p.c+p.s)
1204  self.assertEqual(str(path),'c+a+b')
1205  p._validateSequence(path, 'p1')
1206  notInProcess = EDAnalyzer('NotInProcess')
1207  p2 = Path(p.c+p.s*notInProcess)
1208  self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
def Config.TestModuleCommand.testSubProcess (   self)

Definition at line 1448 of file Config.py.

References cond.hash.

1448 
1449  def testSubProcess(self):
1450  process = Process("Parent")
1451  subProcess = Process("Child")
1452  subProcess.a = EDProducer("A")
1453  subProcess.p = Path(subProcess.a)
1454  subProcess.add_(Service("Foo"))
1455  process.add_( SubProcess(subProcess) )
1456  d = process.dumpPython()
1457  equalD ="""import FWCore.ParameterSet.Config as cms
1458 
1459 process = cms.Process("Parent")
1460 
1461 parentProcess = process
1462 import FWCore.ParameterSet.Config as cms
1463 
1464 process = cms.Process("Child")
1465 
1466 process.a = cms.EDProducer("A")
1467 
1468 
1469 process.p = cms.Path(process.a)
1470 
1471 
1472 process.Foo = cms.Service("Foo")
1473 
1474 
1475 childProcess = process
1476 process = parentProcess
1477 process.subProcess = cms.SubProcess( process = childProcess, SelectEvents = cms.untracked.PSet(
1478 
1479 ), outputCommands = cms.untracked.vstring())
1480 """
1481  equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcess)))
1482  self.assertEqual(d,equalD)
1483  p = TestMakePSet()
1484  process.subProcess.insertInto(p,"dummy")
1485  self.assertEqual((True,['a']),p.values["@sub_process"][1].values["process"][1].values['@all_modules'])
1486  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 1028 of file Config.py.

1028 
1029  def testTypedParameterizable(self):
1030  p = _TypedParameterizable("blah", b=int32(1))
1031  #see if copy works deeply
1032  other = p.copy()
1033  other.b = 2
1034  self.assertNotEqual(p.b,other.b)
Mixins._TypedParameterizable
Definition: Mixins.py:257
def Config.TestModuleCommand.testUsing (   self)

Definition at line 1334 of file Config.py.

1334 
1335  def testUsing(self):
1336  p = Process('test')
1337  p.block = PSet(a = int32(1))
1338  p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
1339  self.assertEqual(p.modu.a.value(),1)
1340  self.assertEqual(p.modu.b.value(),2)

Member Data Documentation

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

Definition at line 1158 of file Config.py.

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

Definition at line 1151 of file Config.py.

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

Definition at line 1154 of file Config.py.

Generated for CMSSW Reference Manual by doxygen 1.8.5