CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions
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 testProcessDumpConfig
 
def testProcessExtend
 
def testProcessInsertion
 
def testSchedule
 
def testSecSource
 
def testSequence
 
def testSubProcess
 
def testTypedParameterizable
 
def testUsing
 

Detailed Description

Definition at line 961 of file Config.py.

Member Function Documentation

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

Definition at line 962 of file Config.py.

962 
963  def setUp(self):
964  """Nothing to do """
None
def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 1172 of file Config.py.

1172 
1173  def testCloneSequence(self):
1174  p = Process("test")
1175  a = EDAnalyzer("MyAnalyzer")
1176  p.a = a
1177  a.setLabel("a")
1178  b = EDAnalyzer("YOurAnalyzer")
1179  p.b = b
1180  b.setLabel("b")
1181  path = Path(a * b)
1182  p.path = Path(p.a*p.b)
1183  lookuptable = {id(a): p.a, id(b): p.b}
1184  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1185  #lookuptable = p._cloneToObjectDict
1186  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1187  self.assertEqual(str(path),str(p.path))
def Config.TestModuleCommand.testExamples (   self)

Definition at line 1283 of file Config.py.

References Types.untracked.

1283 
1284  def testExamples(self):
1285  p = Process("Test")
1286  p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
1287  p.foos = EDProducer("FooProducer")
1288  p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
1289  p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
1290  p.bars.foos = 'Foosball'
1291  self.assertEqual(p.bars.foos, InputTag('Foosball'))
1292  p.p = Path(p.foos*p.bars)
1293  p.e = EndPath(p.out)
1294  p.add_(Service("MessageLogger"))
Types.untracked
tuple untracked
Definition: Types.py:29
def Config.TestModuleCommand.testFreeze (   self)

Definition at line 1349 of file Config.py.

1349 
1350  def testFreeze(self):
1351  process = Process("Freeze")
1352  m = EDProducer("M", p=PSet(i = int32(1)))
1353  m.p.i = 2
1354  process.m = m
1355  # should be frozen
1356  #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
1357  #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
1358  #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
1359  #self.assertRaises(ValueError, setattr, m, 'j', 1)
1360  # But OK to change through the process
1361  process.m.p.i = 4
1362  self.assertEqual(process.m.p.i.value(), 4)
1363  process.m.p = PSet(j=int32(1))
1364  # should work to clone it, though
1365  m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
1366  m2.p.i = 6
m2.j = 8
def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 1125 of file Config.py.

1125 
1126  def testGlobalReplace(self):
1127  p = Process('test')
1128  p.a = EDAnalyzer("MyAnalyzer")
1129  p.b = EDAnalyzer("YourAnalyzer")
1130  p.c = EDAnalyzer("OurAnalyzer")
1131  p.s = Sequence(p.a*p.b)
1132  p.p = Path(p.c+p.s+p.a)
1133  new = EDAnalyzer("NewAnalyzer")
1134  p.globalReplace("a",new)
def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 1227 of file Config.py.

1227 
1228  def testImplicitSchedule(self):
1229  p = Process("test")
1230  p.a = EDAnalyzer("MyAnalyzer")
1231  p.b = EDAnalyzer("YourAnalyzer")
1232  p.c = EDAnalyzer("OurAnalyzer")
1233  p.path1 = Path(p.a)
1234  p.path2 = Path(p.b)
1235  self.assert_(p.schedule is None)
1236  pths = p.paths
1237  keys = pths.keys()
1238  self.assertEqual(pths[keys[0]],p.path1)
1239  self.assertEqual(pths[keys[1]],p.path2)
1240 
1241  p = Process("test")
1242  p.a = EDAnalyzer("MyAnalyzer")
1243  p.b = EDAnalyzer("YourAnalyzer")
1244  p.c = EDAnalyzer("OurAnalyzer")
1245  p.path2 = Path(p.b)
1246  p.path1 = Path(p.a)
1247  self.assert_(p.schedule is None)
1248  pths = p.paths
1249  keys = pths.keys()
1250  self.assertEqual(pths[keys[1]],p.path1)
1251  self.assertEqual(pths[keys[0]],p.path2)
1252 
def Config.TestModuleCommand.testOverride (   self)

Definition at line 1260 of file Config.py.

1260 
1261  def testOverride(self):
1262  p = Process('test')
1263  a = EDProducer("A", a1=int32(0))
1264  self.assert_(not a.isModified())
1265  a.a1 = 1
1266  self.assert_(a.isModified())
1267  p.a = a
1268  self.assertEqual(p.a.a1.value(), 1)
1269  # try adding an unmodified module.
1270  # should accept it
1271  p.a = EDProducer("A", a1=int32(2))
1272  self.assertEqual(p.a.a1.value(), 2)
1273  # try adding a modified module. Should throw
1274  # no longer, since the same (modified) say, geometry
1275  # could come from more than one cff
1276  b = EDProducer("A", a1=int32(3))
1277  b.a1 = 4
1278  #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
1279  ps1 = PSet(a = int32(1))
1280  ps2 = PSet(a = int32(2))
1281  self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
1282  self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 965 of file Config.py.

965 
966  def testParameterizable(self):
967  p = _Parameterizable()
968  self.assertEqual(len(p.parameterNames_()),0)
969  p.a = int32(1)
970  self.assert_('a' in p.parameterNames_())
971  self.assertEqual(p.a.value(), 1)
972  p.a = 10
973  self.assertEqual(p.a.value(), 10)
974  p.a = untracked(int32(1))
975  self.assertEqual(p.a.value(), 1)
976  self.failIf(p.a.isTracked())
977  p.a = untracked.int32(1)
978  self.assertEqual(p.a.value(), 1)
979  self.failIf(p.a.isTracked())
980  p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
981  self.assertEqual(p.foo.value(), 10)
982  self.assertEqual(p.bar.value(),1.0)
983  self.failIf(p.bar.isTracked())
984  self.assertRaises(TypeError,setattr,(p,'c',1))
985  p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
986  self.assertEqual(p.a.foo.value(),10)
987  self.assertEqual(p.a.bar.value(),1.0)
988  p.b = untracked(PSet(fii = int32(1)))
989  self.assertEqual(p.b.fii.value(),1)
990  self.failIf(p.b.isTracked())
991  #test the fact that values can be shared
992  v = int32(10)
993  p=_Parameterizable(a=v)
994  v.setValue(11)
995  self.assertEqual(p.a.value(),11)
996  p.a = 12
997  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 1150 of file Config.py.

1150 
1151  def testPath(self):
1152  p = Process("test")
1153  p.a = EDAnalyzer("MyAnalyzer")
1154  p.b = EDAnalyzer("YourAnalyzer")
1155  p.c = EDAnalyzer("OurAnalyzer")
1156  path = Path(p.a)
1157  path *= p.b
1158  path += p.c
1159  self.assertEqual(str(path),'a+b+c')
1160  path = Path(p.a*p.b+p.c)
1161  self.assertEqual(str(path),'a+b+c')
1162 # path = Path(p.a)*p.b+p.c #This leads to problems with sequences
1163 # self.assertEqual(str(path),'((a*b)+c)')
1164  path = Path(p.a+ p.b*p.c)
1165  self.assertEqual(str(path),'a+b+c')
1166  path = Path(p.a*(p.b+p.c))
1167  self.assertEqual(str(path),'a+b+c')
1168  path = Path(p.a*(p.b+~p.c))
1169  self.assertEqual(str(path),'a+b+~c')
1170  p.es = ESProducer("AnESProducer")
1171  self.assertRaises(TypeError,Path,p.es)
def Config.TestModuleCommand.testPrefers (   self)

Definition at line 1295 of file Config.py.

1295 
1296  def testPrefers(self):
1297  p = Process("Test")
1298  p.add_(ESSource("ForceSource"))
1299  p.juicer = ESProducer("JuicerProducer")
1300  p.prefer("ForceSource")
1301  p.prefer("juicer")
1302  self.assertEqual(p.dumpConfig(),
1303 """process Test = {
1304  es_module juicer = JuicerProducer {
1305  }
1306  es_source = ForceSource {
1307  }
1308  es_prefer = ForceSource {
1309  }
1310  es_prefer juicer = JuicerProducer {
1311  }
1312 }
1313 """)
1314  p.prefer("juicer",fooRcd=vstring("Foo"))
1315  self.assertEqual(p.dumpConfig(),
1316 """process Test = {
1317  es_module juicer = JuicerProducer {
1318  }
1319  es_source = ForceSource {
1320  }
1321  es_prefer = ForceSource {
1322  }
1323  es_prefer juicer = JuicerProducer {
1324  vstring fooRcd = {
1325  'Foo'
1326  }
1327 
1328  }
1329 }
1330 """)
1331  self.assertEqual(p.dumpPython(),
1332 """import FWCore.ParameterSet.Config as cms
1333 
1334 process = cms.Process("Test")
1335 
1336 process.juicer = cms.ESProducer("JuicerProducer")
1337 
1338 
1339 process.ForceSource = cms.ESSource("ForceSource")
1340 
1341 
1342 process.prefer("ForceSource")
1343 
1344 process.prefer("juicer",
1345  fooRcd = cms.vstring('Foo')
1346 )
1347 
1348 """)
def Config.TestModuleCommand.testProcessDumpConfig (   self)

Definition at line 1054 of file Config.py.

1054 
1055  def testProcessDumpConfig(self):
1056  p = Process("test")
1057  p.a = EDAnalyzer("MyAnalyzer")
1058  p.p = Path(p.a)
1059  p.s = Sequence(p.a)
1060  p.r = Sequence(p.s)
1061  p.p2 = Path(p.s)
1062  p.schedule = Schedule(p.p2,p.p)
1063  d=p.dumpPython()
1064  self.assertEqual(d,
1065 """import FWCore.ParameterSet.Config as cms
1066 
1067 process = cms.Process("test")
1068 
1069 process.a = cms.EDAnalyzer("MyAnalyzer")
1070 
1071 
1072 process.s = cms.Sequence(process.a)
1073 
1074 
1075 process.r = cms.Sequence(process.s)
1076 
1077 
1078 process.p = cms.Path(process.a)
1079 
1080 
1081 process.p2 = cms.Path(process.s)
1082 
1083 
1084 process.schedule = cms.Schedule(process.p2,process.p)
1085 """)
1086  #Reverse order of 'r' and 's'
1087  p = Process("test")
1088  p.a = EDAnalyzer("MyAnalyzer")
1089  p.p = Path(p.a)
1090  p.r = Sequence(p.a)
1091  p.s = Sequence(p.r)
1092  p.p2 = Path(p.r)
1093  p.schedule = Schedule(p.p2,p.p)
1094  p.b = EDAnalyzer("YourAnalyzer")
1095  d=p.dumpPython()
1096  self.assertEqual(d,
1097 """import FWCore.ParameterSet.Config as cms
1098 
1099 process = cms.Process("test")
1100 
1101 process.a = cms.EDAnalyzer("MyAnalyzer")
1102 
1103 
1104 process.b = cms.EDAnalyzer("YourAnalyzer")
1105 
1106 
1107 process.r = cms.Sequence(process.a)
1108 
1109 
1110 process.s = cms.Sequence(process.r)
1111 
1112 
1113 process.p = cms.Path(process.a)
1114 
1115 
1116 process.p2 = cms.Path(process.r)
1117 
1118 
1119 process.schedule = cms.Schedule(process.p2,process.p)
""")
def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 1027 of file Config.py.

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

1027 
1028  def testProcessExtend(self):
1029  class FromArg(object):
1030  def __init__(self,*arg,**args):
1031  for name in args.iterkeys():
1032  self.__dict__[name]=args[name]
1033 
1034  a=EDAnalyzer("MyAnalyzer")
1035  s1 = Sequence(a)
1036  s2 = Sequence(s1)
1037  s3 = Sequence(s2)
1038  d = FromArg(
1039  a=a,
1040  b=Service("Full"),
1041  c=Path(a),
1042  d=s2,
1043  e=s1,
1044  f=s3,
1045  g=Sequence(s1+s2+s3)
1046  )
1047  p = Process("Test")
1048  p.extend(d)
1049  self.assertEqual(p.a.type_(),"MyAnalyzer")
1050  self.assertRaises(AttributeError,getattr,p,'b')
1051  self.assertEqual(p.Full.type_(),"Full")
1052  self.assertEqual(str(p.c),'a')
1053  self.assertEqual(str(p.d),'a')
dbtoconf.object
list object
Definition: dbtoconf.py:77
def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 1005 of file Config.py.

1005 
1006  def testProcessInsertion(self):
1007  p = Process("test")
1008  p.a = EDAnalyzer("MyAnalyzer")
1009  self.assert_( 'a' in p.analyzers_() )
1010  self.assert_( 'a' in p.analyzers)
1011  p.add_(Service("MessageLogger"))
1012  self.assert_('MessageLogger' in p.services_())
1013  self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
1014  p.Tracer = Service("Tracer")
1015  self.assert_('Tracer' in p.services_())
1016  self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
1017  self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
1018  self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
1019  p.out = OutputModule("Outer")
1020  self.assertEqual(p.out.type_(), 'Outer')
1021  self.assert_( 'out' in p.outputModules_() )
1022 
1023  p.geom = ESSource("GeomProd")
1024  self.assert_('geom' in p.es_sources_())
1025  p.add_(ESSource("ConfigDB"))
1026  self.assert_('ConfigDB' in p.es_sources_())
def Config.TestModuleCommand.testSchedule (   self)

Definition at line 1188 of file Config.py.

1188 
1189  def testSchedule(self):
1190  p = Process("test")
1191  p.a = EDAnalyzer("MyAnalyzer")
1192  p.b = EDAnalyzer("YourAnalyzer")
1193  p.c = EDAnalyzer("OurAnalyzer")
1194  p.path1 = Path(p.a)
1195  p.path2 = Path(p.b)
1196 
1197  s = Schedule(p.path1,p.path2)
1198  self.assertEqual(s[0],p.path1)
1199  self.assertEqual(s[1],p.path2)
1200  p.schedule = s
1201  self.assert_('b' in p.schedule.moduleNames())
1202  self.assert_(hasattr(p, 'b'))
1203  self.assert_(hasattr(p, 'c'))
1204  p.prune()
1205  self.assert_('b' in p.schedule.moduleNames())
1206  self.assert_(hasattr(p, 'b'))
1207  self.assert_(not hasattr(p, 'c'))
1208 
1209  #adding a path not attached to the Process should cause an exception
1210  p = Process("test")
1211  p.a = EDAnalyzer("MyAnalyzer")
1212  path1 = Path(p.a)
1213  s = Schedule(path1)
1214  self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
1215 
1216  #make sure anonymous sequences work
1217  p = Process("test")
1218  p.a = EDAnalyzer("MyAnalyzer")
1219  p.b = EDAnalyzer("MyOtherAnalyzer")
1220  p.c = EDProducer("MyProd")
1221  path1 = Path(p.c*Sequence(p.a+p.b))
1222  s = Schedule(path1)
1223  self.assert_('a' in s.moduleNames())
1224  self.assert_('b' in s.moduleNames())
1225  self.assert_('c' in s.moduleNames())
1226 
def Config.TestModuleCommand.testSecSource (   self)

Definition at line 1120 of file Config.py.

References python.rootplot.root2matplotlib.replace().

1120 
1121  def testSecSource(self):
1122  p = Process('test')
1123  p.a = SecSource("MySecSource")
1124  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 1135 of file Config.py.

1135 
1136  def testSequence(self):
1137  p = Process('test')
1138  p.a = EDAnalyzer("MyAnalyzer")
1139  p.b = EDAnalyzer("YourAnalyzer")
1140  p.c = EDAnalyzer("OurAnalyzer")
1141  p.s = Sequence(p.a*p.b)
1142  self.assertEqual(str(p.s),'a+b')
1143  self.assertEqual(p.s.label_(),'s')
1144  path = Path(p.c+p.s)
1145  self.assertEqual(str(path),'c+a+b')
1146  p._validateSequence(path, 'p1')
1147  notInProcess = EDAnalyzer('NotInProcess')
1148  p2 = Path(p.c+p.s*notInProcess)
1149  self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
def Config.TestModuleCommand.testSubProcess (   self)

Definition at line 1367 of file Config.py.

References cond.hash.

1367 
1368  def testSubProcess(self):
1369  process = Process("Parent")
1370  subProcess = Process("Child")
1371  subProcess.a = EDProducer("A")
1372  subProcess.p = Path(subProcess.a)
1373  subProcess.add_(Service("Foo"))
1374  process.add_( SubProcess(subProcess) )
1375  d = process.dumpPython()
1376  equalD ="""import FWCore.ParameterSet.Config as cms
1377 
1378 process = cms.Process("Parent")
1379 
1380 parentProcess = process
1381 import FWCore.ParameterSet.Config as cms
1382 
1383 process = cms.Process("Child")
1384 
1385 process.a = cms.EDProducer("A")
1386 
1387 
1388 process.p = cms.Path(process.a)
1389 
1390 
1391 process.Foo = cms.Service("Foo")
1392 
1393 
1394 childProcess = process
1395 process = parentProcess
1396 process.subProcess = cms.SubProcess( process = childProcess, SelectEvents = cms.untracked.PSet(
1397 
1398 ), outputCommands = cms.untracked.vstring())
1399 """
1400  equalD = equalD.replace("parentProcess","parentProcess"+str(hash(process.subProcess)))
1401  self.assertEqual(d,equalD)
1402  p = TestMakePSet()
1403  process.subProcess.insertInto(p,"dummy")
1404  self.assertEqual((True,['a']),p.values["@sub_process"][1].values["process"][1].values['@all_modules'])
1405  self.assertEqual((True,['p']),p.values["@sub_process"][1].values["process"][1].values['@paths'])
1406  self.assertEqual({'@service_type':(True,'Foo')}, p.values["@sub_process"][1].values["process"][1].values["services"][1][0].values)
1407 
unittest.main()
def Config.TestModuleCommand.testTypedParameterizable (   self)

Definition at line 998 of file Config.py.

998 
999  def testTypedParameterizable(self):
1000  p = _TypedParameterizable("blah", b=int32(1))
1001  #see if copy works deeply
1002  other = p.copy()
1003  other.b = 2
1004  self.assertNotEqual(p.b,other.b)
Mixins._TypedParameterizable
Definition: Mixins.py:257
def Config.TestModuleCommand.testUsing (   self)

Definition at line 1253 of file Config.py.

1253 
1254  def testUsing(self):
1255  p = Process('test')
1256  p.block = PSet(a = int32(1))
1257  p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
1258  self.assertEqual(p.modu.a.value(),1)
1259  self.assertEqual(p.modu.b.value(),2)
Generated for CMSSW Reference Manual by doxygen 1.8.5