CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
List of all members | Public Member Functions | Private Attributes
SequenceTypes.TestModuleCommand Class Reference
Inheritance diagram for SequenceTypes.TestModuleCommand:

Public Member Functions

def setUp
 
def testAdd
 
def testBoolean
 
def testCopy
 
def testCopyAndExclude
 
def testDumpConfig
 
def testDumpPython
 
def testExpandAndClone
 
def testIndex
 
def testInsert
 
def testInsertInto
 
def testRemove
 
def testReplace
 
def testResolve
 
def testSequenceTypeChecks
 
def testVisitor
 

Private Attributes

 _dict
 
 _enters
 
 _leaves
 

Detailed Description

Definition at line 836 of file SequenceTypes.py.

Member Function Documentation

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

Definition at line 837 of file SequenceTypes.py.

Referenced by SequenceVisitors.TestModuleCommand.setUp().

837 
838  def setUp(self):
839  """Nothing to do """
pass
def SequenceTypes.TestModuleCommand.testAdd (   self)

Definition at line 1126 of file SequenceTypes.py.

References SequenceTypes.ignore().

1126 
1127  def testAdd(self):
1128  m1 = DummyModule("m1")
1129  m2 = DummyModule("m2")
1130  m3 = DummyModule("m3")
1131  m4 = DummyModule("m4")
1132  s1 = Sequence(m1)
1133  s3 = Sequence(m3+ignore(m4))
1134  p = Path(s1)
1135  p += ~m2
1136  p *= s3
1137 
1138  l = []
1139  namesVisitor = DecoratedNodeNameVisitor(l)
1140  p.visit(namesVisitor)
1141  self.assertEqual(l, ['m1', '!m2', 'm3', '-m4'])
1142 
1143  s4 = Sequence()
1144  s4 +=m1
1145  print s1._seq.dumpSequencePython()
1146  l[:]=[]; s1.visit(namesVisitor); self.assertEqual(l,['m1'])
1147  self.assertEqual(s4.dumpPython(None),"cms.Sequence(process.m1)\n")
1148  s4 = Sequence()
1149  s4 *=m1
1150  l[:]=[]; s1.visit(namesVisitor); self.assertEqual(l,['m1'])
1151  self.assertEqual(s4.dumpPython(None),"cms.Sequence(process.m1)\n")
1152 
def SequenceTypes.TestModuleCommand.testBoolean (   self)

Definition at line 840 of file SequenceTypes.py.

840 
841  def testBoolean(self):
842  a = DummyBooleanModule("a")
843  b = DummyBooleanModule("b")
844  p = Path( a & b)
845  self.assertEqual(p.dumpPython(None),"cms.Path(process.a&process.b)\n")
846  l = list()
847  namesVisitor = DecoratedNodeNameVisitor(l)
848  p.visit(namesVisitor)
849  self.assertEqual(l,['&','a','b','@'])
850  p2 = Path( a | b)
851  self.assertEqual(p2.dumpPython(None),"cms.Path(process.a|process.b)\n")
852  l[:]=[]
853  p2.visit(namesVisitor)
854  self.assertEqual(l,['|','a','b','@'])
855  c = DummyBooleanModule("c")
856  d = DummyBooleanModule("d")
857  p3 = Path(a & b & c & d)
858  self.assertEqual(p3.dumpPython(None),"cms.Path(process.a&process.b&process.c&process.d)\n")
859  l[:]=[]
860  p3.visit(namesVisitor)
861  self.assertEqual(l,['&','a','b','c','d','@'])
862  p3 = Path(((a & b) & c) & d)
863  self.assertEqual(p3.dumpPython(None),"cms.Path(process.a&process.b&process.c&process.d)\n")
864  p3 = Path(a & (b & (c & d)))
865  self.assertEqual(p3.dumpPython(None),"cms.Path(process.a&process.b&process.c&process.d)\n")
866  p3 = Path((a & b) & (c & d))
867  self.assertEqual(p3.dumpPython(None),"cms.Path(process.a&process.b&process.c&process.d)\n")
868  p3 = Path(a & (b & c) & d)
869  self.assertEqual(p3.dumpPython(None),"cms.Path(process.a&process.b&process.c&process.d)\n")
870  p4 = Path(a | b | c | d)
871  self.assertEqual(p4.dumpPython(None),"cms.Path(process.a|process.b|process.c|process.d)\n")
872  p5 = Path(a | b & c & d )
873  self.assertEqual(p5.dumpPython(None),"cms.Path(process.a|(process.b&process.c&process.d))\n")
874  l[:]=[]
875  p5.visit(namesVisitor)
876  self.assertEqual(l,['|','a','&','b','c','d','@','@'])
877  p5 = Path(a & b | c & d )
878  self.assertEqual(p5.dumpPython(None),"cms.Path((process.a&process.b)|(process.c&process.d))\n")
879  l[:]=[]
880  p5.visit(namesVisitor)
881  self.assertEqual(l,['|','&','a','b','@','&','c','d','@','@'])
882  p5 = Path(a & (b | c) & d )
883  self.assertEqual(p5.dumpPython(None),"cms.Path(process.a&(process.b|process.c)&process.d)\n")
884  l[:]=[]
885  p5.visit(namesVisitor)
886  self.assertEqual(l,['&','a','|','b','c','@','d','@'])
887  p5 = Path(a & b & c | d )
888  self.assertEqual(p5.dumpPython(None),"cms.Path((process.a&process.b&process.c)|process.d)\n")
889  l[:]=[]
890  p5.visit(namesVisitor)
891  self.assertEqual(l,['|','&','a','b','c','@','d','@'])
892  p6 = Path( a & ~b)
893  self.assertEqual(p6.dumpPython(None),"cms.Path(process.a&(~process.b))\n")
894  l[:]=[]
895  p6.visit(namesVisitor)
896  self.assertEqual(l,['&','a','!b','@'])
897  p6 = Path( a & ignore(b))
898  self.assertEqual(p6.dumpPython(None),"cms.Path(process.a&(cms.ignore(process.b)))\n")
899  l[:]=[]
900  p6.visit(namesVisitor)
901  self.assertEqual(l,['&','a','-b','@'])
902  p6 = Path(~(a&b))
903  self.assertEqual(p6.dumpPython(None),"cms.Path(~(process.a&process.b))\n")
904  l[:]=[]
905  p6.visit(namesVisitor)
906  self.assertEqual(l,['!&','a','b','@'])
list
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger list("!*","!HLTx*"if it matches 2 triggers or more) will accept the event if all the matching triggers are FAIL.It will reject the event if any of the triggers are PASS or EXCEPTION(this matches the behavior of"!*"before the partial wildcard feature was incorporated).Triggers which are in the READY state are completely ignored.(READY should never be returned since the trigger paths have been run
def SequenceTypes.TestModuleCommand.testCopy (   self)

Definition at line 1293 of file SequenceTypes.py.

1293 
1294  def testCopy(self):
1295  a = DummyModule("a")
1296  b = DummyModule("b")
1297  c = DummyModule("c")
1298  p1 = Path(a+b+c)
1299  p2 = p1.copy()
1300  e = DummyModule("e")
1301  p2.replace(b,e)
1302  self.assertEqual(p1.dumpPython(None),"cms.Path(process.a+process.b+process.c)\n")
1303  self.assertEqual(p2.dumpPython(None),"cms.Path(process.a+process.e+process.c)\n")
1304  p1 = Path(a+b+c)
1305  p2 = p1.copy()
1306  p1 += e
1307  self.assertEqual(p1.dumpPython(None),"cms.Path(process.a+process.b+process.c+process.e)\n")
1308  self.assertEqual(p2.dumpPython(None),"cms.Path(process.a+process.b+process.c)\n")
def SequenceTypes.TestModuleCommand.testCopyAndExclude (   self)

Definition at line 1211 of file SequenceTypes.py.

References ConfigBuilder.dumpPython(), and SequenceTypes.ignore().

1211 
1212  def testCopyAndExclude(self):
1213  a = DummyModule("a")
1214  b = DummyModule("b")
1215  c = DummyModule("c")
1216  d = DummyModule("d")
1217  s = Sequence(a+b+c)
1218  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
1219  s = Sequence(a+b+c+d)
1220  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
1221  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
1222  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
1223  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
1224  s=Sequence(a*b+c+d)
1225  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
1226  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
1227  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
1228  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
1229  s = Sequence(a+b*c+d)
1230  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
1231  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
1232  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
1233  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
1234  s2 = Sequence(a+b)
1235  s = Sequence(c+s2+d)
1236  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.c+process.b+process.d)\n")
1237  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.c+process.a+process.d)\n")
1238  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence((process.a+process.b)+process.d)\n")
1239  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.c+(process.a+process.b))\n")
1240  self.assertEqual(s.copyAndExclude([a,b]).dumpPython(None),"cms.Sequence(process.c+process.d)\n")
1241  s2 = Sequence(a+b+c)
1242  s = Sequence(s2+d)
1243  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
1244  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
1245  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
1246  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence((process.a+process.b+process.c))\n")
1247  s2 = Sequence(a+b+c)
1248  s = Sequence(s2*d)
1249  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
1250  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
1251  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
1252  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence((process.a+process.b+process.c))\n")
1253  self.assertEqual(s.copyAndExclude([a,b,c]).dumpPython(None),"cms.Sequence(process.d)\n")
1254  s = Sequence(ignore(a)+b+c+d)
1255  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
1256  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(cms.ignore(process.a)+process.c+process.d)\n")
1257  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(cms.ignore(process.a)+process.b+process.d)\n")
1258  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(cms.ignore(process.a)+process.b+process.c)\n")
1259  s = Sequence(a+ignore(b)+c+d)
1260  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(cms.ignore(process.b)+process.c+process.d)\n")
1261  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
1262  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+cms.ignore(process.b)+process.d)\n")
1263  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+cms.ignore(process.b)+process.c)\n")
1264  s = Sequence(a+b+c+ignore(d))
1265  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+cms.ignore(process.d))\n")
1266  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+cms.ignore(process.d))\n")
1267  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+cms.ignore(process.d))\n")
1268  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
1269  s = Sequence(~a+b+c+d)
1270  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
1271  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(~process.a+process.c+process.d)\n")
1272  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(~process.a+process.b+process.d)\n")
1273  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(~process.a+process.b+process.c)\n")
1274  s = Sequence(a+~b+c+d)
1275  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(~process.b+process.c+process.d)\n")
1276  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
1277  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+~process.b+process.d)\n")
1278  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+~process.b+process.c)\n")
1279  s = Sequence(a+b+c+~d)
1280  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+~process.d)\n")
1281  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+~process.d)\n")
1282  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+~process.d)\n")
self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
def SequenceTypes.TestModuleCommand.testDumpConfig (   self)

Definition at line 948 of file SequenceTypes.py.

References SequenceTypes.ignore().

948 
949  def testDumpConfig(self):
950  a = DummyModule("a")
951  b = DummyModule('b')
952  p = Path((a*b))
953  #print p.dumpConfig('')
954  self.assertEqual(p.dumpConfig(None),"{a&b}\n")
955  p2 = Path((b+a))
956  #print p2.dumpConfig('')
957  self.assertEqual(p2.dumpConfig(None),"{b&a}\n")
958  c = DummyModule('c')
959  p3 = Path(c*(a+b))
960  #print p3.dumpConfig('')
961  self.assertEqual(p3.dumpConfig(None),"{c&a&b}\n")
962  p4 = Path(c*a+b)
963  #print p4.dumpConfig('')
964  self.assertEqual(p4.dumpConfig(None),"{c&a&b}\n")
965  p5 = Path(a+ignore(b))
966  #print p5.dumpConfig('')
967  self.assertEqual(p5.dumpConfig(None),"{a&-b}\n")
968  p6 = Path(c+a*b)
969  #print p6.dumpConfig('')
970  self.assertEqual(p6.dumpConfig(None),"{c&a&b}\n")
971  p7 = Path(a+~b)
972  self.assertEqual(p7.dumpConfig(None),"{a&!b}\n")
973  p8 = Path((a+b)*c)
self.assertEqual(p8.dumpConfig(None),"{a&b&c}\n")
def SequenceTypes.TestModuleCommand.testDumpPython (   self)

Definition at line 907 of file SequenceTypes.py.

References SequenceTypes.ignore(), and list().

907 
908  def testDumpPython(self):
909  a = DummyModule("a")
910  b = DummyModule('b')
911  p = Path((a*b))
912  #print p.dumpConfig('')
913  self.assertEqual(p.dumpPython(None),"cms.Path(process.a+process.b)\n")
914  p2 = Path((b+a))
915  #print p2.dumpConfig('')
916  self.assertEqual(p2.dumpPython(None),"cms.Path(process.b+process.a)\n")
917  c = DummyModule('c')
918  p3 = Path(c*(a+b))
919  #print p3.dumpConfig('')
920  self.assertEqual(p3.dumpPython(None),"cms.Path(process.c+process.a+process.b)\n")
921  p4 = Path(c*a+b)
922  #print p4.dumpConfig('')
923  self.assertEqual(p4.dumpPython(None),"cms.Path(process.c+process.a+process.b)\n")
924  p5 = Path(a+ignore(b))
925  #print p5.dumpConfig('')
926  self.assertEqual(p5.dumpPython(None),"cms.Path(process.a+cms.ignore(process.b))\n")
927  p6 = Path(c+a*b)
928  #print p6.dumpConfig('')
929  self.assertEqual(p6.dumpPython(None),"cms.Path(process.c+process.a+process.b)\n")
930  p7 = Path(a+~b)
931  self.assertEqual(p7.dumpPython(None),"cms.Path(process.a+~process.b)\n")
932  p8 = Path((a+b)*c)
933  self.assertEqual(p8.dumpPython(None),"cms.Path(process.a+process.b+process.c)\n")
934  l = list()
935  namesVisitor = DecoratedNodeNameVisitor(l)
936  p.visit(namesVisitor)
937  self.assertEqual(l, ['a', 'b'])
938  l[:] = []
939  p5.visit(namesVisitor)
940  self.assertEqual(l, ['a', '-b'])
941  l[:] = []
942  p7.visit(namesVisitor)
943  self.assertEqual(l, ['a', '!b'])
944  l[:] = []
945  moduleVisitor = ModuleNodeVisitor(l)
946  p8.visit(moduleVisitor)
947  names = [m.label_() for m in l]
self.assertEqual(names, ['a', 'b', 'c'])
list
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger list("!*","!HLTx*"if it matches 2 triggers or more) will accept the event if all the matching triggers are FAIL.It will reject the event if any of the triggers are PASS or EXCEPTION(this matches the behavior of"!*"before the partial wildcard feature was incorporated).Triggers which are in the READY state are completely ignored.(READY should never be returned since the trigger paths have been run
def SequenceTypes.TestModuleCommand.testExpandAndClone (   self)

Definition at line 1108 of file SequenceTypes.py.

References SequenceTypes.ignore().

1108 
1109  def testExpandAndClone(self):
1110  m1 = DummyModule("m1")
1111  m2 = DummyModule("m2")
1112  m3 = DummyModule("m3")
1113  m4 = DummyModule("m4")
1114  m5 = DummyModule("m5")
1115 
1116  s1 = Sequence(m1*~m2*m1*m2*ignore(m2))
1117  s2 = Sequence(m1*m2)
1118  s3 = Sequence(~m1*s2)
1119 
1120  p = Path(s1+s3)
1121  p2 = p.expandAndClone()
1122  l = []
1123  namesVisitor = DecoratedNodeNameVisitor(l)
1124  p2.visit(namesVisitor)
1125  self.assertEqual(l, ['m1', '!m2', 'm1', 'm2', '-m2', '!m1', 'm1', 'm2'])
def SequenceTypes.TestModuleCommand.testIndex (   self)

Definition at line 1087 of file SequenceTypes.py.

1087 
1088  def testIndex(self):
1089  m1 = DummyModule("a")
1090  m2 = DummyModule("b")
1091  m3 = DummyModule("c")
1092 
1093  s = Sequence(m1+m2+m3)
1094  self.assertEqual(s.index(m1),0)
1095  self.assertEqual(s.index(m2),1)
1096  self.assertEqual(s.index(m3),2)
def SequenceTypes.TestModuleCommand.testInsert (   self)

Definition at line 1097 of file SequenceTypes.py.

1097 
1098  def testInsert(self):
1099  m1 = DummyModule("a")
1100  m2 = DummyModule("b")
1101  m3 = DummyModule("c")
1102  s = Sequence(m1+m3)
1103  s.insert(1,m2)
1104  self.assertEqual(s.index(m1),0)
1105  self.assertEqual(s.index(m2),1)
1106  self.assertEqual(s.index(m3),2)
1107 
def SequenceTypes.TestModuleCommand.testInsertInto (   self)

Definition at line 1309 of file SequenceTypes.py.

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

1309 
1310  def testInsertInto(self):
1311  from FWCore.ParameterSet.Types import vstring
1312  class TestPSet(object):
1313  def __init__(self):
1314  self._dict = dict()
1315  def addVString(self,isTracked,label,value):
1316  self._dict[label]=value
1317  a = DummyModule("a")
1318  b = DummyModule("b")
1319  c = DummyModule("c")
1320  d = DummyModule("d")
1321  p = Path(a+b+c+d)
1322  ps = TestPSet()
1323  p.insertInto(ps,"p",dict())
1324  self.assertEqual(ps._dict, {"p":vstring("a","b","c","d")})
1325  s = Sequence(b+c)
1326  p = Path(a+s+d)
1327  ps = TestPSet()
1328  p.insertInto(ps,"p",dict())
1329  self.assertEqual(ps._dict, {"p":vstring("a","b","c","d")})
1330 
unittest.main()
dbtoconf.object
list object
Definition: dbtoconf.py:77
def SequenceTypes.TestModuleCommand.testRemove (   self)

Definition at line 1153 of file SequenceTypes.py.

References SequenceTypes.ignore().

1153 
1154  def testRemove(self):
1155  m1 = DummyModule("m1")
1156  m2 = DummyModule("m2")
1157  m3 = DummyModule("m3")
1158  s1 = Sequence(m1*m2+~m3)
1159  s2 = Sequence(m1*s1)
1160  l = []
1161  namesVisitor = DecoratedNodeNameVisitor(l)
1162  d = {'m1':m1 ,'m2':m2, 'm3':m3,'s1':s1, 's2':s2}
1163  l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', 'm2', '!m3'])
1164  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m1', 'm1', 'm2', '!m3'])
1165  s1.remove(m2)
1166  l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', '!m3'])
1167  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m1', 'm1', '!m3'])
1168  s2.remove(m3)
1169  l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', '!m3'])
1170  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m1', 'm1'])
1171  s1 = Sequence( m1 + m2 + m1 + m2 )
1172  l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', 'm2', 'm1', 'm2'])
1173  s1.remove(m2)
1174  l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', 'm1', 'm2'])
1175  s1 = Sequence( m1 + m3 )
1176  s2 = Sequence( m2 + ignore(m3) + s1 + m3 )
1177  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m2', '-m3', 'm1', 'm3', 'm3'])
1178  s2.remove(s1)
1179  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m2', '-m3', 'm3'])
1180  s2.remove(m3)
1181  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m2','m3'])
1182  s1 = Sequence(m1*m2*m3)
1183  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
1184  s1.remove(m2)
1185  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
1186  s1 = Sequence(m1+m2+m3)
1187  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
1188  s1.remove(m2)
1189  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
1190  s1 = Sequence(m1*m2+m3)
1191  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
1192  s1.remove(m2)
1193  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
1194  s1 = Sequence(m1+m2*m3)
1195  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
1196  s1.remove(m2)
1197  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
1198  s1.remove(m1)
1199  s1.remove(m3)
1200  l[:]=[]; s1.visit(namesVisitor); self.assertEqual(l,[])
1201  self.assertEqual(s1.dumpPython(None), "cms.Sequence()\n")
1202  s3 = Sequence(m1)
1203  s3.remove(m1)
1204  l[:]=[]; s3.visit(namesVisitor); self.assertEqual(l,[])
1205  self.assertEqual(s3.dumpPython(None), "cms.Sequence()\n")
1206  s3 = Sequence(m1)
1207  s4 = Sequence(s3)
1208  s4.remove(m1)
1209  l[:]=[]; s4.visit(namesVisitor); self.assertEqual(l,[])
1210  self.assertEqual(s4.dumpPython(None), "cms.Sequence()\n")
def SequenceTypes.TestModuleCommand.testReplace (   self)

Definition at line 1046 of file SequenceTypes.py.

References SequenceTypes.ignore().

1046 
1047  def testReplace(self):
1048  m1 = DummyModule("m1")
1049  m2 = DummyModule("m2")
1050  m3 = DummyModule("m3")
1051  m4 = DummyModule("m4")
1052  m5 = DummyModule("m5")
1053 
1054  s1 = Sequence(m1*~m2*m1*m2*ignore(m2))
1055  s2 = Sequence(m1*m2)
1056  l = []
1057  namesVisitor = DecoratedNodeNameVisitor(l)
1058  s1.visit(namesVisitor)
1059  self.assertEqual(l,['m1', '!m2', 'm1', 'm2', '-m2'])
1060 
1061  s3 = Sequence(~m1*s2)
1062  s3.replace(~m1, m2)
1063  l[:] = []
1064  s3.visit(namesVisitor)
1065  self.assertEqual(l, ['m2', 'm1', 'm2'])
1066 
1067  s1.replace(m2,m3)
1068  l[:] = []
1069  s1.visit(namesVisitor)
1070  self.assertEqual(l,['m1', '!m3', 'm1', 'm3', '-m3'])
1071  s2 = Sequence(m1*m2)
1072  s3 = Sequence(~m1*s2)
1073  l[:] = []
1074  s3.visit(namesVisitor)
1075  self.assertEqual(l,['!m1', 'm1', 'm2'])
1076  l[:] = []
1077  s3.replace(s2,m1)
1078  s3.visit(namesVisitor)
1079  self.assertEqual(l,['!m1', 'm1'])
1080 
1081  s1 = Sequence(m1+m2)
1082  s2 = Sequence(m3+m4)
1083  s3 = Sequence(s1+s2)
1084  s3.replace(m3,m5)
1085  l[:] = []
1086  s3.visit(namesVisitor)
self.assertEqual(l,['m1','m2','m5','m4'])
def SequenceTypes.TestModuleCommand.testResolve (   self)

Definition at line 1016 of file SequenceTypes.py.

References python.multivaluedict.dict, and list().

1016 
1017  def testResolve(self):
1018  m1 = DummyModule("m1")
1019  m2 = DummyModule("m2")
1020  s1 = Sequence(m1)
1021  s2 = SequencePlaceholder("s3")
1022  s3 = Sequence(m2)
1023  p = Path(s1*s2)
1024  l = list()
1025  d = dict()
1026  d['s1'] = s1
1027  d['s2'] = s2
1028  d['s3'] = s3
1029  #resolver = ResolveVisitor(d)
1030  #p.visit(resolver)
1031  namesVisitor = DecoratedNodeNameVisitor(l)
1032  p.visit(namesVisitor)
1033  self.assertEqual(l, ['m1'])
1034  p.resolve(d)
1035  l[:] = []
1036  p.visit(namesVisitor)
1037  self.assertEqual(l, ['m1', 'm2'])
1038  l[:]=[]
1039  s1 = Sequence(m1)
1040  s2 = SequencePlaceholder("s3")
1041  s3 = Sequence(m2)
1042  s4 = SequencePlaceholder("s2")
1043  p=Path(s1+s4)
1044  p.resolve(d)
1045  p.visit(namesVisitor)
self.assertEqual(l, ['m1', 'm2'])
list
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger list("!*","!HLTx*"if it matches 2 triggers or more) will accept the event if all the matching triggers are FAIL.It will reject the event if any of the triggers are PASS or EXCEPTION(this matches the behavior of"!*"before the partial wildcard feature was incorporated).Triggers which are in the READY state are completely ignored.(READY should never be returned since the trigger paths have been run
def SequenceTypes.TestModuleCommand.testSequenceTypeChecks (   self)

Definition at line 1283 of file SequenceTypes.py.

1283 
1284  def testSequenceTypeChecks(self):
1285  m1 = DummyModule("m1")
1286  m2 = DummyModule("m2")
1287  s1 = Sequence(m1*m2)
1288  def testRaise():
1289  s1.something = 1
1290  self.assertRaises(AttributeError,testRaise)
1291  def testRaise2():
1292  s2 = Sequence(m1*None)
self.assertRaises(TypeError,testRaise2)
def SequenceTypes.TestModuleCommand.testVisitor (   self)

Definition at line 974 of file SequenceTypes.py.

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

974 
975  def testVisitor(self):
976  class TestVisitor(object):
977  def __init__(self, enters, leaves):
978  self._enters = enters
979  self._leaves = leaves
980  def enter(self,visitee):
981  #print visitee.dumpSequencePython()
982  if self._enters[0] != visitee:
983  raise RuntimeError("wrong node ("+str(visitee)+") on 'enter'")
984  else:
985  self._enters = self._enters[1:]
986  def leave(self,visitee):
987  if self._leaves[0] != visitee:
988  raise RuntimeError("wrong node ("+str(visitee)+") on 'leave'\n expected ("+str(self._leaves[0])+")")
989  else:
990  self._leaves = self._leaves[1:]
991  a = DummyModule("a")
992  b = DummyModule('b')
993  multAB = a*b
994  p = Path(multAB)
995  t = TestVisitor(enters=[a,b],
996  leaves=[a,b])
997  p.visit(t)
998 
999  plusAB = a+b
1000  p = Path(plusAB)
1001  t = TestVisitor(enters=[a,b],
1002  leaves=[a,b])
1003  p.visit(t)
1004 
1005  s=Sequence(plusAB)
1006  c=DummyModule("c")
1007  multSC = s*c
1008  p=Path(multSC)
1009  t=TestVisitor(enters=[s,a,b,c],
1010  leaves=[a,b,s,c])
1011  p.visit(t)
1012 
1013  notA= ~a
1014  p=Path(notA)
1015  t=TestVisitor(enters=[notA,a],leaves=[a,notA])
p.visit(t)
dbtoconf.object
list object
Definition: dbtoconf.py:77

Member Data Documentation

SequenceTypes.TestModuleCommand._dict
private

Definition at line 1313 of file SequenceTypes.py.

SequenceTypes.TestModuleCommand._enters
private

Definition at line 977 of file SequenceTypes.py.

SequenceTypes.TestModuleCommand._leaves
private

Definition at line 978 of file SequenceTypes.py.

Generated for CMSSW Reference Manual by doxygen 1.8.5