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 testTypedParameterizable
 
def testUsing
 

Detailed Description

Definition at line 832 of file Config.py.

Member Function Documentation

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

Definition at line 833 of file Config.py.

833 
834  def setUp(self):
835  """Nothing to do """
None
def Config.TestModuleCommand.testCloneSequence (   self)

Definition at line 1043 of file Config.py.

References ExpressReco_HICollisions_FallBack.id.

1043 
1044  def testCloneSequence(self):
1045  p = Process("test")
1046  a = EDAnalyzer("MyAnalyzer")
1047  p.a = a
1048  a.setLabel("a")
1049  b = EDAnalyzer("YOurAnalyzer")
1050  p.b = b
1051  b.setLabel("b")
1052  path = Path(a * b)
1053  p.path = Path(p.a*p.b)
1054  lookuptable = {id(a): p.a, id(b): p.b}
1055  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1056  #lookuptable = p._cloneToObjectDict
1057  #self.assertEqual(str(path),str(path._postProcessFixup(lookuptable)))
1058  self.assertEqual(str(path),str(p.path))
ExpressReco_HICollisions_FallBack.id
tuple id
Definition: ExpressReco_HICollisions_FallBack.py:9307
def Config.TestModuleCommand.testExamples (   self)

Definition at line 1154 of file Config.py.

References Types.untracked.

1154 
1155  def testExamples(self):
1156  p = Process("Test")
1157  p.source = Source("PoolSource",fileNames = untracked(string("file:reco.root")))
1158  p.foos = EDProducer("FooProducer")
1159  p.bars = EDProducer("BarProducer", foos=InputTag("foos"))
1160  p.out = OutputModule("PoolOutputModule",fileName=untracked(string("file:foos.root")))
1161  p.bars.foos = 'Foosball'
1162  self.assertEqual(p.bars.foos, InputTag('Foosball'))
1163  p.p = Path(p.foos*p.bars)
1164  p.e = EndPath(p.out)
1165  p.add_(Service("MessageLogger"))
Types.untracked
tuple untracked
Definition: Types.py:29
def Config.TestModuleCommand.testFreeze (   self)

Definition at line 1220 of file Config.py.

1220 
1221  def testFreeze(self):
1222  process = Process("Freeze")
1223  m = EDProducer("M", p=PSet(i = int32(1)))
1224  m.p.i = 2
1225  process.m = m
1226  # should be frozen
1227  #self.assertRaises(ValueError, setattr, m.p, 'i', 3)
1228  #self.assertRaises(ValueError, setattr, m, 'p', PSet(i=int32(1)))
1229  #self.assertRaises(ValueError, setattr, m.p, 'j', 1)
1230  #self.assertRaises(ValueError, setattr, m, 'j', 1)
1231  # But OK to change through the process
1232  process.m.p.i = 4
1233  self.assertEqual(process.m.p.i.value(), 4)
1234  process.m.p = PSet(j=int32(1))
1235  # should work to clone it, though
1236  m2 = m.clone(p = PSet(i = int32(5)), j = int32(8))
1237  m2.p.i = 6
1238  m2.j = 8
1239 
1240 
unittest.main()
def Config.TestModuleCommand.testGlobalReplace (   self)

Definition at line 996 of file Config.py.

996 
997  def testGlobalReplace(self):
998  p = Process('test')
999  p.a = EDAnalyzer("MyAnalyzer")
1000  p.b = EDAnalyzer("YourAnalyzer")
1001  p.c = EDAnalyzer("OurAnalyzer")
1002  p.s = Sequence(p.a*p.b)
1003  p.p = Path(p.c+p.s+p.a)
1004  new = EDAnalyzer("NewAnalyzer")
1005  p.globalReplace("a",new)
def Config.TestModuleCommand.testImplicitSchedule (   self)

Definition at line 1098 of file Config.py.

1098 
1099  def testImplicitSchedule(self):
1100  p = Process("test")
1101  p.a = EDAnalyzer("MyAnalyzer")
1102  p.b = EDAnalyzer("YourAnalyzer")
1103  p.c = EDAnalyzer("OurAnalyzer")
1104  p.path1 = Path(p.a)
1105  p.path2 = Path(p.b)
1106  self.assert_(p.schedule is None)
1107  pths = p.paths
1108  keys = pths.keys()
1109  self.assertEqual(pths[keys[0]],p.path1)
1110  self.assertEqual(pths[keys[1]],p.path2)
1111 
1112  p = Process("test")
1113  p.a = EDAnalyzer("MyAnalyzer")
1114  p.b = EDAnalyzer("YourAnalyzer")
1115  p.c = EDAnalyzer("OurAnalyzer")
1116  p.path2 = Path(p.b)
1117  p.path1 = Path(p.a)
1118  self.assert_(p.schedule is None)
1119  pths = p.paths
1120  keys = pths.keys()
1121  self.assertEqual(pths[keys[1]],p.path1)
1122  self.assertEqual(pths[keys[0]],p.path2)
1123 
def Config.TestModuleCommand.testOverride (   self)

Definition at line 1131 of file Config.py.

1131 
1132  def testOverride(self):
1133  p = Process('test')
1134  a = EDProducer("A", a1=int32(0))
1135  self.assert_(not a.isModified())
1136  a.a1 = 1
1137  self.assert_(a.isModified())
1138  p.a = a
1139  self.assertEqual(p.a.a1.value(), 1)
1140  # try adding an unmodified module.
1141  # should accept it
1142  p.a = EDProducer("A", a1=int32(2))
1143  self.assertEqual(p.a.a1.value(), 2)
1144  # try adding a modified module. Should throw
1145  # no longer, since the same (modified) say, geometry
1146  # could come from more than one cff
1147  b = EDProducer("A", a1=int32(3))
1148  b.a1 = 4
1149  #self.assertRaises(RuntimeError, setattr, *(p,'a',b))
1150  ps1 = PSet(a = int32(1))
1151  ps2 = PSet(a = int32(2))
1152  self.assertRaises(ValueError, EDProducer, 'C', ps1, ps2)
1153  self.assertRaises(ValueError, EDProducer, 'C', ps1, a=int32(3))
def Config.TestModuleCommand.testParameterizable (   self)

Definition at line 836 of file Config.py.

836 
837  def testParameterizable(self):
838  p = _Parameterizable()
839  self.assertEqual(len(p.parameterNames_()),0)
840  p.a = int32(1)
841  self.assert_('a' in p.parameterNames_())
842  self.assertEqual(p.a.value(), 1)
843  p.a = 10
844  self.assertEqual(p.a.value(), 10)
845  p.a = untracked(int32(1))
846  self.assertEqual(p.a.value(), 1)
847  self.failIf(p.a.isTracked())
848  p.a = untracked.int32(1)
849  self.assertEqual(p.a.value(), 1)
850  self.failIf(p.a.isTracked())
851  p = _Parameterizable(foo=int32(10), bar = untracked(double(1.0)))
852  self.assertEqual(p.foo.value(), 10)
853  self.assertEqual(p.bar.value(),1.0)
854  self.failIf(p.bar.isTracked())
855  self.assertRaises(TypeError,setattr,(p,'c',1))
856  p = _Parameterizable(a=PSet(foo=int32(10), bar = untracked(double(1.0))))
857  self.assertEqual(p.a.foo.value(),10)
858  self.assertEqual(p.a.bar.value(),1.0)
859  p.b = untracked(PSet(fii = int32(1)))
860  self.assertEqual(p.b.fii.value(),1)
861  self.failIf(p.b.isTracked())
862  #test the fact that values can be shared
863  v = int32(10)
864  p=_Parameterizable(a=v)
865  v.setValue(11)
866  self.assertEqual(p.a.value(),11)
867  p.a = 12
868  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 1021 of file Config.py.

1021 
1022  def testPath(self):
1023  p = Process("test")
1024  p.a = EDAnalyzer("MyAnalyzer")
1025  p.b = EDAnalyzer("YourAnalyzer")
1026  p.c = EDAnalyzer("OurAnalyzer")
1027  path = Path(p.a)
1028  path *= p.b
1029  path += p.c
1030  self.assertEqual(str(path),'a+b+c')
1031  path = Path(p.a*p.b+p.c)
1032  self.assertEqual(str(path),'a+b+c')
1033 # path = Path(p.a)*p.b+p.c #This leads to problems with sequences
1034 # self.assertEqual(str(path),'((a*b)+c)')
1035  path = Path(p.a+ p.b*p.c)
1036  self.assertEqual(str(path),'a+b+c')
1037  path = Path(p.a*(p.b+p.c))
1038  self.assertEqual(str(path),'a+b+c')
1039  path = Path(p.a*(p.b+~p.c))
1040  self.assertEqual(str(path),'a+b+~c')
1041  p.es = ESProducer("AnESProducer")
1042  self.assertRaises(TypeError,Path,p.es)
def Config.TestModuleCommand.testPrefers (   self)

Definition at line 1166 of file Config.py.

1166 
1167  def testPrefers(self):
1168  p = Process("Test")
1169  p.add_(ESSource("ForceSource"))
1170  p.juicer = ESProducer("JuicerProducer")
1171  p.prefer("ForceSource")
1172  p.prefer("juicer")
1173  self.assertEqual(p.dumpConfig(),
1174 """process Test = {
1175  es_module juicer = JuicerProducer {
1176  }
1177  es_source = ForceSource {
1178  }
1179  es_prefer = ForceSource {
1180  }
1181  es_prefer juicer = JuicerProducer {
1182  }
1183 }
1184 """)
1185  p.prefer("juicer",fooRcd=vstring("Foo"))
1186  self.assertEqual(p.dumpConfig(),
1187 """process Test = {
1188  es_module juicer = JuicerProducer {
1189  }
1190  es_source = ForceSource {
1191  }
1192  es_prefer = ForceSource {
1193  }
1194  es_prefer juicer = JuicerProducer {
1195  vstring fooRcd = {
1196  'Foo'
1197  }
1198 
1199  }
1200 }
1201 """)
1202  self.assertEqual(p.dumpPython(),
1203 """import FWCore.ParameterSet.Config as cms
1204 
1205 process = cms.Process("Test")
1206 
1207 process.juicer = cms.ESProducer("JuicerProducer")
1208 
1209 
1210 process.ForceSource = cms.ESSource("ForceSource")
1211 
1212 
1213 process.prefer("ForceSource")
1214 
1215 process.prefer("juicer",
1216  fooRcd = cms.vstring('Foo')
1217 )
1218 
1219 """)
def Config.TestModuleCommand.testProcessDumpConfig (   self)

Definition at line 925 of file Config.py.

925 
926  def testProcessDumpConfig(self):
927  p = Process("test")
928  p.a = EDAnalyzer("MyAnalyzer")
929  p.p = Path(p.a)
930  p.s = Sequence(p.a)
931  p.r = Sequence(p.s)
932  p.p2 = Path(p.s)
933  p.schedule = Schedule(p.p2,p.p)
934  d=p.dumpPython()
935  self.assertEqual(d,
936 """import FWCore.ParameterSet.Config as cms
937 
938 process = cms.Process("test")
939 
940 process.a = cms.EDAnalyzer("MyAnalyzer")
941 
942 
943 process.s = cms.Sequence(process.a)
944 
945 
946 process.r = cms.Sequence(process.s)
947 
948 
949 process.p = cms.Path(process.a)
950 
951 
952 process.p2 = cms.Path(process.s)
953 
954 
955 process.schedule = cms.Schedule(process.p2,process.p)
956 """)
957  #Reverse order of 'r' and 's'
958  p = Process("test")
959  p.a = EDAnalyzer("MyAnalyzer")
960  p.p = Path(p.a)
961  p.r = Sequence(p.a)
962  p.s = Sequence(p.r)
963  p.p2 = Path(p.r)
964  p.schedule = Schedule(p.p2,p.p)
965  p.b = EDAnalyzer("YourAnalyzer")
966  d=p.dumpPython()
967  self.assertEqual(d,
968 """import FWCore.ParameterSet.Config as cms
969 
970 process = cms.Process("test")
971 
972 process.a = cms.EDAnalyzer("MyAnalyzer")
973 
974 
975 process.b = cms.EDAnalyzer("YourAnalyzer")
976 
977 
978 process.r = cms.Sequence(process.a)
979 
980 
981 process.s = cms.Sequence(process.r)
982 
983 
984 process.p = cms.Path(process.a)
985 
986 
987 process.p2 = cms.Path(process.r)
988 
989 
990 process.schedule = cms.Schedule(process.p2,process.p)
""")
def Config.TestModuleCommand.testProcessExtend (   self)

Definition at line 898 of file Config.py.

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

898 
899  def testProcessExtend(self):
900  class FromArg(object):
901  def __init__(self,*arg,**args):
902  for name in args.iterkeys():
903  self.__dict__[name]=args[name]
904 
905  a=EDAnalyzer("MyAnalyzer")
906  s1 = Sequence(a)
907  s2 = Sequence(s1)
908  s3 = Sequence(s2)
909  d = FromArg(
910  a=a,
911  b=Service("Full"),
912  c=Path(a),
913  d=s2,
914  e=s1,
915  f=s3,
916  g=Sequence(s1+s2+s3)
917  )
918  p = Process("Test")
919  p.extend(d)
920  self.assertEqual(p.a.type_(),"MyAnalyzer")
921  self.assertRaises(AttributeError,getattr,p,'b')
922  self.assertEqual(p.Full.type_(),"Full")
923  self.assertEqual(str(p.c),'a')
924  self.assertEqual(str(p.d),'a')
dbtoconf.object
list object
Definition: dbtoconf.py:77
def Config.TestModuleCommand.testProcessInsertion (   self)

Definition at line 876 of file Config.py.

876 
877  def testProcessInsertion(self):
878  p = Process("test")
879  p.a = EDAnalyzer("MyAnalyzer")
880  self.assert_( 'a' in p.analyzers_() )
881  self.assert_( 'a' in p.analyzers)
882  p.add_(Service("MessageLogger"))
883  self.assert_('MessageLogger' in p.services_())
884  self.assertEqual(p.MessageLogger.type_(), "MessageLogger")
885  p.Tracer = Service("Tracer")
886  self.assert_('Tracer' in p.services_())
887  self.assertRaises(TypeError, setattr, *(p,'b',"this should fail"))
888  self.assertRaises(TypeError, setattr, *(p,'bad',Service("MessageLogger")))
889  self.assertRaises(ValueError, setattr, *(p,'bad',Source("PoolSource")))
890  p.out = OutputModule("Outer")
891  self.assertEqual(p.out.type_(), 'Outer')
892  self.assert_( 'out' in p.outputModules_() )
893 
894  p.geom = ESSource("GeomProd")
895  self.assert_('geom' in p.es_sources_())
896  p.add_(ESSource("ConfigDB"))
897  self.assert_('ConfigDB' in p.es_sources_())
def Config.TestModuleCommand.testSchedule (   self)

Definition at line 1059 of file Config.py.

1059 
1060  def testSchedule(self):
1061  p = Process("test")
1062  p.a = EDAnalyzer("MyAnalyzer")
1063  p.b = EDAnalyzer("YourAnalyzer")
1064  p.c = EDAnalyzer("OurAnalyzer")
1065  p.path1 = Path(p.a)
1066  p.path2 = Path(p.b)
1067 
1068  s = Schedule(p.path1,p.path2)
1069  self.assertEqual(s[0],p.path1)
1070  self.assertEqual(s[1],p.path2)
1071  p.schedule = s
1072  self.assert_('b' in p.schedule.moduleNames())
1073  self.assert_(hasattr(p, 'b'))
1074  self.assert_(hasattr(p, 'c'))
1075  p.prune()
1076  self.assert_('b' in p.schedule.moduleNames())
1077  self.assert_(hasattr(p, 'b'))
1078  self.assert_(not hasattr(p, 'c'))
1079 
1080  #adding a path not attached to the Process should cause an exception
1081  p = Process("test")
1082  p.a = EDAnalyzer("MyAnalyzer")
1083  path1 = Path(p.a)
1084  s = Schedule(path1)
1085  self.assertRaises(RuntimeError, lambda : p.setSchedule_(s) )
1086 
1087  #make sure anonymous sequences work
1088  p = Process("test")
1089  p.a = EDAnalyzer("MyAnalyzer")
1090  p.b = EDAnalyzer("MyOtherAnalyzer")
1091  p.c = EDProducer("MyProd")
1092  path1 = Path(p.c*Sequence(p.a+p.b))
1093  s = Schedule(path1)
1094  self.assert_('a' in s.moduleNames())
1095  self.assert_('b' in s.moduleNames())
1096  self.assert_('c' in s.moduleNames())
1097 
def Config.TestModuleCommand.testSecSource (   self)

Definition at line 991 of file Config.py.

References linker.replace().

991 
992  def testSecSource(self):
993  p = Process('test')
994  p.a = SecSource("MySecSource")
995  self.assertEqual(p.dumpPython().replace('\n',''),'import FWCore.ParameterSet.Config as cmsprocess = cms.Process("test")process.a = cms.SecSource("MySecSource")')
linker.replace
def replace
Definition: linker.py:10
def Config.TestModuleCommand.testSequence (   self)

Definition at line 1006 of file Config.py.

1006 
1007  def testSequence(self):
1008  p = Process('test')
1009  p.a = EDAnalyzer("MyAnalyzer")
1010  p.b = EDAnalyzer("YourAnalyzer")
1011  p.c = EDAnalyzer("OurAnalyzer")
1012  p.s = Sequence(p.a*p.b)
1013  self.assertEqual(str(p.s),'a+b')
1014  self.assertEqual(p.s.label_(),'s')
1015  path = Path(p.c+p.s)
1016  self.assertEqual(str(path),'c+a+b')
1017  p._validateSequence(path, 'p1')
1018  notInProcess = EDAnalyzer('NotInProcess')
1019  p2 = Path(p.c+p.s*notInProcess)
1020  self.assertRaises(RuntimeError, p._validateSequence, p2, 'p2')
def Config.TestModuleCommand.testTypedParameterizable (   self)

Definition at line 869 of file Config.py.

869 
870  def testTypedParameterizable(self):
871  p = _TypedParameterizable("blah", b=int32(1))
872  #see if copy works deeply
873  other = p.copy()
874  other.b = 2
875  self.assertNotEqual(p.b,other.b)
Mixins._TypedParameterizable
Definition: Mixins.py:257
def Config.TestModuleCommand.testUsing (   self)

Definition at line 1124 of file Config.py.

1124 
1125  def testUsing(self):
1126  p = Process('test')
1127  p.block = PSet(a = int32(1))
1128  p.modu = EDAnalyzer('Analyzer', p.block, b = int32(2))
1129  self.assertEqual(p.modu.a.value(),1)
1130  self.assertEqual(p.modu.b.value(),2)
Generated for CMSSW Reference Manual by doxygen 1.8.5