CMS 3D CMS Logo

List of all members | Public Member Functions | Private Attributes
SequenceTypes.TestModuleCommand Class Reference
Inheritance diagram for SequenceTypes.TestModuleCommand:

Public Member Functions

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

Private Attributes

 _dict
 
 _enters
 
 _leaves
 

Detailed Description

Definition at line 1508 of file SequenceTypes.py.

Member Function Documentation

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

Definition at line 1509 of file SequenceTypes.py.

Referenced by SequenceVisitors.TestModuleCommand.setUp().

1509  def setUp(self):
1510  """Nothing to do """
1511  pass
def SequenceTypes.TestModuleCommand.testAdd (   self)

Definition at line 1971 of file SequenceTypes.py.

References SequenceTypes.ignore().

1971  def testAdd(self):
1972  m1 = DummyModule("m1")
1973  m2 = DummyModule("m2")
1974  m3 = DummyModule("m3")
1975  m4 = DummyModule("m4")
1976  s1 = Sequence(m1)
1977  s3 = Sequence(m3+ignore(m4))
1978  p = Path(s1)
1979  p += ~m2
1980  p *= s3
1981 
1982  l = []
1983  namesVisitor = DecoratedNodeNameVisitor(l)
1984  p.visit(namesVisitor)
1985  self.assertEqual(l, ['m1', '!m2', 'm3', '-m4'])
1986 
1987  s4 = Sequence()
1988  s4 +=m1
1989  l[:]=[]; s1.visit(namesVisitor); self.assertEqual(l,['m1'])
1990  self.assertEqual(s4.dumpPython(None),"cms.Sequence(process.m1)\n")
1991  s4 = Sequence()
1992  s4 *=m1
1993  l[:]=[]; s1.visit(namesVisitor); self.assertEqual(l,['m1'])
1994  self.assertEqual(s4.dumpPython(None),"cms.Sequence(process.m1)\n")
1995 
1996 
def ignore(seq)
def SequenceTypes.TestModuleCommand.testBoolean (   self)

Definition at line 1512 of file SequenceTypes.py.

1512  def testBoolean(self):
1513  a = DummyBooleanModule("a")
1514  b = DummyBooleanModule("b")
1515  p = Path( a & b)
1516  self.assertEqual(p.dumpPython(None),"cms.Path(process.a&process.b)\n")
1517  l = list()
1518  namesVisitor = DecoratedNodeNameVisitor(l)
1519  p.visit(namesVisitor)
1520  self.assertEqual(l,['&','a','b','@'])
1521  p2 = Path( a | b)
1522  self.assertEqual(p2.dumpPython(None),"cms.Path(process.a|process.b)\n")
1523  l[:]=[]
1524  p2.visit(namesVisitor)
1525  self.assertEqual(l,['|','a','b','@'])
1526  c = DummyBooleanModule("c")
1527  d = DummyBooleanModule("d")
1528  p3 = Path(a & b & c & d)
1529  self.assertEqual(p3.dumpPython(None),"cms.Path(process.a&process.b&process.c&process.d)\n")
1530  l[:]=[]
1531  p3.visit(namesVisitor)
1532  self.assertEqual(l,['&','a','b','c','d','@'])
1533  p3 = Path(((a & b) & c) & d)
1534  self.assertEqual(p3.dumpPython(None),"cms.Path(process.a&process.b&process.c&process.d)\n")
1535  p3 = Path(a & (b & (c & d)))
1536  self.assertEqual(p3.dumpPython(None),"cms.Path(process.a&process.b&process.c&process.d)\n")
1537  p3 = Path((a & b) & (c & d))
1538  self.assertEqual(p3.dumpPython(None),"cms.Path(process.a&process.b&process.c&process.d)\n")
1539  p3 = Path(a & (b & c) & d)
1540  self.assertEqual(p3.dumpPython(None),"cms.Path(process.a&process.b&process.c&process.d)\n")
1541  p4 = Path(a | b | c | d)
1542  self.assertEqual(p4.dumpPython(None),"cms.Path(process.a|process.b|process.c|process.d)\n")
1543  p5 = Path(a | b & c & d )
1544  self.assertEqual(p5.dumpPython(None),"cms.Path(process.a|(process.b&process.c&process.d))\n")
1545  l[:]=[]
1546  p5.visit(namesVisitor)
1547  self.assertEqual(l,['|','a','&','b','c','d','@','@'])
1548  p5 = Path(a & b | c & d )
1549  self.assertEqual(p5.dumpPython(None),"cms.Path((process.a&process.b)|(process.c&process.d))\n")
1550  l[:]=[]
1551  p5.visit(namesVisitor)
1552  self.assertEqual(l,['|','&','a','b','@','&','c','d','@','@'])
1553  p5 = Path(a & (b | c) & d )
1554  self.assertEqual(p5.dumpPython(None),"cms.Path(process.a&(process.b|process.c)&process.d)\n")
1555  l[:]=[]
1556  p5.visit(namesVisitor)
1557  self.assertEqual(l,['&','a','|','b','c','@','d','@'])
1558  p5 = Path(a & b & c | d )
1559  self.assertEqual(p5.dumpPython(None),"cms.Path((process.a&process.b&process.c)|process.d)\n")
1560  l[:]=[]
1561  p5.visit(namesVisitor)
1562  self.assertEqual(l,['|','&','a','b','c','@','d','@'])
1563  p6 = Path( a & ~b)
1564  self.assertEqual(p6.dumpPython(None),"cms.Path(process.a&(~process.b))\n")
1565  l[:]=[]
1566  p6.visit(namesVisitor)
1567  self.assertEqual(l,['&','a','!b','@'])
1568  p6 = Path( a & ignore(b))
1569  self.assertEqual(p6.dumpPython(None),"cms.Path(process.a&(cms.ignore(process.b)))\n")
1570  l[:]=[]
1571  p6.visit(namesVisitor)
1572  self.assertEqual(l,['&','a','-b','@'])
1573  p6 = Path(~(a&b))
1574  self.assertEqual(p6.dumpPython(None),"cms.Path(~(process.a&process.b))\n")
1575  l[:]=[]
1576  p6.visit(namesVisitor)
1577  self.assertEqual(l,['!&','a','b','@'])
1578 
def ignore(seq)
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 2220 of file SequenceTypes.py.

References triggerObjects_cff.id, and list().

2220  def testCopy(self):
2221  a = DummyModule("a")
2222  b = DummyModule("b")
2223  c = DummyModule("c")
2224  p1 = Path(a+b+c)
2225  p2 = p1.copy()
2226  e = DummyModule("e")
2227  p2.replace(b,e)
2228  self.assertEqual(p1.dumpPython(None),"cms.Path(process.a+process.b+process.c)\n")
2229  self.assertEqual(p2.dumpPython(None),"cms.Path(process.a+process.e+process.c)\n")
2230  p1 = Path(a+b+c)
2231  p2 = p1.copy()
2232  p1 += e
2233  self.assertEqual(p1.dumpPython(None),"cms.Path(process.a+process.b+process.c+process.e)\n")
2234  self.assertEqual(p2.dumpPython(None),"cms.Path(process.a+process.b+process.c)\n")
2235  t1 = Task(a, b)
2236  t2 = t1.copy()
2237  self.assertTrue(t1.dumpPython(None) == t2.dumpPython(None))
2238  t1Contents = list(t1._collection)
2239  t2Contents = list(t2._collection)
2240  self.assertTrue(id(t1Contents[0]) == id(t2Contents[0]))
2241  self.assertTrue(id(t1Contents[1]) == id(t2Contents[1]))
2242  self.assertTrue(id(t1._collection) != id(t2._collection))
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.testCopyAndExclude (   self)

Definition at line 2075 of file SequenceTypes.py.

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

2076  a = DummyModule("a")
2077  b = DummyModule("b")
2078  c = DummyModule("c")
2079  d = DummyModule("d")
2080  s = Sequence(a+b+c)
2081  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
2082  s = Sequence(a+b+c+d)
2083  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
2084  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
2085  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
2086  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
2087  s=Sequence(a*b+c+d)
2088  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
2089  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
2090  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
2091  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
2092  s = Sequence(a+b*c+d)
2093  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
2094  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
2095  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
2096  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
2097  s2 = Sequence(a+b)
2098  s = Sequence(c+s2+d)
2099  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.c+process.b+process.d)\n")
2100  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.c+process.a+process.d)\n")
2101  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence((process.a+process.b)+process.d)\n")
2102  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.c+(process.a+process.b))\n")
2103  self.assertEqual(s.copyAndExclude([a,b]).dumpPython(None),"cms.Sequence(process.c+process.d)\n")
2104  s3 = s.copyAndExclude([c])
2105  s2.remove(a)
2106  self.assertEqual(s3.dumpPython(None),"cms.Sequence((process.b)+process.d)\n")
2107  s4 = s.copyAndExclude([a,b])
2108  seqs = []
2109  sequenceVisitor = SequenceVisitor(seqs)
2110  s.visit(sequenceVisitor)
2111  self.assertEqual(len(seqs),1)
2112  seqs[:] = []
2113  s4.visit(sequenceVisitor)
2114  self.assertEqual(len(seqs),0)
2115  self.assertEqual(s4.dumpPython(None),"cms.Sequence(process.c+process.d)\n")
2116  holder = SequencePlaceholder("x")
2117  s3 = Sequence(b+d,Task(a))
2118  s2 = Sequence(a+b+holder+s3)
2119  s = Sequence(c+s2+d)
2120  seqs[:] = []
2121  s.visit(sequenceVisitor)
2122  self.assertTrue(seqs == [s2,s3])
2123  s2 = Sequence(a+b+holder)
2124  s = Sequence(c+s2+d)
2125  self.assertEqual(s.copyAndExclude([holder]).dumpPython(None),"cms.Sequence(process.c+process.a+process.b+process.d)\n")
2126  s2 = Sequence(a+b+c)
2127  s = Sequence(s2+d)
2128  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
2129  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
2130  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
2131  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence((process.a+process.b+process.c))\n")
2132  self.assertEqual(s.copyAndExclude([s2]).dumpPython(None),"cms.Sequence(process.d)\n")
2133  s2 = Sequence(a+b+c)
2134  s = Sequence(s2*d)
2135  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
2136  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
2137  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
2138  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence((process.a+process.b+process.c))\n")
2139  self.assertEqual(s.copyAndExclude([a,b,c]).dumpPython(None),"cms.Sequence(process.d)\n")
2140  s = Sequence(ignore(a)+b+c+d)
2141  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
2142  self.assertEqual(s.copyAndExclude([ignore(a)]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
2143  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(cms.ignore(process.a)+process.c+process.d)\n")
2144  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(cms.ignore(process.a)+process.b+process.d)\n")
2145  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(cms.ignore(process.a)+process.b+process.c)\n")
2146  s = Sequence(a+ignore(b)+c+d)
2147  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(cms.ignore(process.b)+process.c+process.d)\n")
2148  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
2149  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+cms.ignore(process.b)+process.d)\n")
2150  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+cms.ignore(process.b)+process.c)\n")
2151  s = Sequence(a+b+c+ignore(d))
2152  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+cms.ignore(process.d))\n")
2153  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+cms.ignore(process.d))\n")
2154  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+cms.ignore(process.d))\n")
2155  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
2156  s = Sequence(~a+b+c+d)
2157  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
2158  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(~process.a+process.c+process.d)\n")
2159  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(~process.a+process.b+process.d)\n")
2160  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(~process.a+process.b+process.c)\n")
2161  s = Sequence(a+~b+c+d)
2162  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(~process.b+process.c+process.d)\n")
2163  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
2164  self.assertEqual(s.copyAndExclude([~b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
2165  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+~process.b+process.d)\n")
2166  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+~process.b+process.c)\n")
2167  s = Sequence(a+b+c+~d)
2168  self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+~process.d)\n")
2169  self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+~process.d)\n")
2170  self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+~process.d)\n")
2171  self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
2172  self.assertEqual(s.copyAndExclude([a,b,c,d]).dumpPython(None),"cms.Sequence()\n")
2173 
2174  e = DummyModule("e")
2175  f = DummyModule("f")
2176  g = DummyModule("g")
2177  h = DummyModule("h")
2178  t1 = Task(h)
2179  s = Sequence(a+b+c+~d, Task(e,f,Task(g,t1)))
2180  self.assertEqual(s.copyAndExclude([a,h]).dumpPython(None),"cms.Sequence(process.b+process.c+~process.d, cms.Task(process.e, process.f, process.g))\n")
2181  self.assertEqual(s.copyAndExclude([a,h]).dumpPython(None),"cms.Sequence(process.b+process.c+~process.d, cms.Task(process.e, process.f, process.g))\n")
2182  self.assertEqual(s.copyAndExclude([a,e,h]).dumpPython(None),"cms.Sequence(process.b+process.c+~process.d, cms.Task(process.f, process.g))\n")
2183  self.assertEqual(s.copyAndExclude([a,e,f,g,h]).dumpPython(None),"cms.Sequence(process.b+process.c+~process.d)\n")
2184  self.assertEqual(s.copyAndExclude([a,b,c,d]).dumpPython(None),"cms.Sequence(cms.Task(process.e, process.f, process.g, process.h))\n")
2185  self.assertEqual(s.copyAndExclude([t1]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c+~process.d, cms.Task(process.e, process.f, process.g))\n")
2186  taskList = []
2187  taskVisitor = TaskVisitor(taskList)
2188  s.visit(taskVisitor)
2189  self.assertEqual(len(taskList),3)
2190  s2 = s.copyAndExclude([g,h])
2191  taskList[:] = []
2192  s2.visit(taskVisitor)
2193  self.assertEqual(len(taskList),1)
2194  t2 = Task(t1)
2195  taskList[:] = []
2196  t2.visit(taskVisitor)
2197  self.assertEqual(taskList[0],t1)
2198  s3 = Sequence(s)
2199  self.assertEqual(s3.copyAndExclude([a,h]).dumpPython(None),"cms.Sequence(process.b+process.c+~process.d, cms.Task(process.e, process.f, process.g))\n")
2200  s4 = Sequence(s)
2201  self.assertEqual(s4.copyAndExclude([a,b,c,d,e,f,g,h]).dumpPython(None),"cms.Sequence()\n")
2202  t1 = Task(e,f)
2203  t11 = Task(a)
2204  t11.setLabel("t11")
2205  t2 = Task(g,t1,h,t11)
2206  t3 = t2.copyAndExclude([e,h])
2207  self.assertTrue(t3.dumpPython(None) == "cms.Task(process.f, process.g, process.t11)\n")
2208  t4 = t2.copyAndExclude([e,f,g,h,a])
2209  self.assertTrue(t4.dumpPython(None) == "cms.Task()\n")
def ignore(seq)
def dumpPython(process, name)
def SequenceTypes.TestModuleCommand.testDumpConfig (   self)

Definition at line 1642 of file SequenceTypes.py.

References SequenceTypes.ignore().

1642  def testDumpConfig(self):
1643  a = DummyModule("a")
1644  b = DummyModule('b')
1645  p = Path((a*b))
1646  #print p.dumpConfig('')
1647  self.assertEqual(p.dumpConfig(None),"{a&b}\n")
1648  p2 = Path((b+a))
1649  #print p2.dumpConfig('')
1650  self.assertEqual(p2.dumpConfig(None),"{b&a}\n")
1651  c = DummyModule('c')
1652  p3 = Path(c*(a+b))
1653  #print p3.dumpConfig('')
1654  self.assertEqual(p3.dumpConfig(None),"{c&a&b}\n")
1655  p4 = Path(c*a+b)
1656  #print p4.dumpConfig('')
1657  self.assertEqual(p4.dumpConfig(None),"{c&a&b}\n")
1658  p5 = Path(a+ignore(b))
1659  #print p5.dumpConfig('')
1660  self.assertEqual(p5.dumpConfig(None),"{a&-b}\n")
1661  p6 = Path(c+a*b)
1662  #print p6.dumpConfig('')
1663  self.assertEqual(p6.dumpConfig(None),"{c&a&b}\n")
1664  p7 = Path(a+~b)
1665  self.assertEqual(p7.dumpConfig(None),"{a&!b}\n")
1666  p8 = Path((a+b)*c)
1667  self.assertEqual(p8.dumpConfig(None),"{a&b&c}\n")
def ignore(seq)
def SequenceTypes.TestModuleCommand.testDumpPython (   self)

Definition at line 1579 of file SequenceTypes.py.

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

1579  def testDumpPython(self):
1580  a = DummyModule("a")
1581  b = DummyModule('b')
1582  p = Path((a*b))
1583  #print p.dumpConfig('')
1584  self.assertEqual(p.dumpPython(None),"cms.Path(process.a+process.b)\n")
1585  p2 = Path((b+a))
1586  #print p2.dumpConfig('')
1587  self.assertEqual(p2.dumpPython(None),"cms.Path(process.b+process.a)\n")
1588  c = DummyModule('c')
1589  p3 = Path(c*(a+b))
1590  #print p3.dumpConfig('')
1591  self.assertEqual(p3.dumpPython(None),"cms.Path(process.c+process.a+process.b)\n")
1592  p4 = Path(c*a+b)
1593  #print p4.dumpConfig('')
1594  self.assertEqual(p4.dumpPython(None),"cms.Path(process.c+process.a+process.b)\n")
1595  p5 = Path(a+ignore(b))
1596  #print p5.dumpConfig('')
1597  self.assertEqual(p5.dumpPython(None),"cms.Path(process.a+cms.ignore(process.b))\n")
1598  p6 = Path(c+a*b)
1599  #print p6.dumpConfig('')
1600  self.assertEqual(p6.dumpPython(None),"cms.Path(process.c+process.a+process.b)\n")
1601  p7 = Path(a+~b)
1602  self.assertEqual(p7.dumpPython(None),"cms.Path(process.a+~process.b)\n")
1603  p8 = Path((a+b)*c)
1604  self.assertEqual(p8.dumpPython(None),"cms.Path(process.a+process.b+process.c)\n")
1605  t1 = Task(a)
1606  t2 = Task(c, b)
1607  t3 = Task()
1608  p9 = Path((a+b)*c, t1)
1609  self.assertEqual(p9.dumpPython(None),"cms.Path(process.a+process.b+process.c, cms.Task(process.a))\n")
1610  p10 = Path((a+b)*c, t2, t1)
1611  self.assertEqual(p10.dumpPython(None),"cms.Path(process.a+process.b+process.c, cms.Task(process.a), cms.Task(process.b, process.c))\n")
1612  p11 = Path(t1, t2, t3)
1613  self.assertEqual(p11.dumpPython(None),"cms.Path(cms.Task(), cms.Task(process.a), cms.Task(process.b, process.c))\n")
1614  d = DummyModule("d")
1615  e = DummyModule('e')
1616  f = DummyModule('f')
1617  t4 = Task(d, Task(f))
1618  s = Sequence(e, t4)
1619  p12 = Path(a+b+s+c,t1)
1620  self.assertEqual(p12.dumpPython(None),"cms.Path(process.a+process.b+cms.Sequence(process.e, cms.Task(process.d, process.f))+process.c, cms.Task(process.a))\n")
1621  l = list()
1622  namesVisitor = DecoratedNodeNameVisitor(l)
1623  p.visit(namesVisitor)
1624  self.assertEqual(l, ['a', 'b'])
1625  l[:] = []
1626  p5.visit(namesVisitor)
1627  self.assertEqual(l, ['a', '-b'])
1628  l[:] = []
1629  p7.visit(namesVisitor)
1630  self.assertEqual(l, ['a', '!b'])
1631  l[:] = []
1632  p10.visit(namesVisitor)
1633  self.assertEqual(l, ['a', 'b', 'c'])
1634  l[:] = []
1635  p12.visit(namesVisitor)
1636  self.assertEqual(l, ['a', 'b', 'e', 'c'])
1637  l[:] = []
1638  moduleVisitor = ModuleNodeVisitor(l)
1639  p8.visit(moduleVisitor)
1640  names = [m.label_() for m in l]
1641  self.assertEqual(names, ['a', 'b', 'c'])
def ignore(seq)
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 1916 of file SequenceTypes.py.

References SequenceTypes.ignore().

1917  m1 = DummyModule("m1")
1918  m2 = DummyModule("m2")
1919  m3 = DummyModule("m3")
1920  m4 = DummyModule("m4")
1921  m5 = DummyModule("m5")
1922 
1923  s1 = Sequence(m1*~m2*m1*m2*ignore(m2))
1924  s2 = Sequence(m1*m2)
1925  s3 = Sequence(~m1*s2)
1926 
1927  p = Path(s1+s3)
1928  p2 = p.expandAndClone()
1929  l = []
1930  namesVisitor = DecoratedNodeNameVisitor(l)
1931  p2.visit(namesVisitor)
1932  self.assertEqual(l, ['m1', '!m2', 'm1', 'm2', '-m2', '!m1', 'm1', 'm2'])
1933 
1934  m6 = DummyModule("m6")
1935  m7 = DummyModule("m7")
1936  m8 = DummyModule("m8")
1937  m9 = DummyModule("m9")
1938  p = Path(s1+s3, Task(m6))
1939  p2 = p.expandAndClone()
1940  l[:] = []
1941  p2.visit(namesVisitor)
1942  self.assertEqual(l, ['m1', '!m2', 'm1', 'm2', '-m2', '!m1', 'm1', 'm2'])
1943  self.assertTrue(p2.dumpPython(None) == "cms.Path(process.m1+~process.m2+process.m1+process.m2+cms.ignore(process.m2)+~process.m1+process.m1+process.m2, cms.Task(process.m6))\n")
1944 
1945  s2 = Sequence(m1*m2, Task(m9))
1946  s3 = Sequence(~m1*s2)
1947  t8 = Task(m8)
1948  t8.setLabel("t8")
1949  p = Path(s1+s3, Task(m6, Task(m7, t8)))
1950  p2 = p.expandAndClone()
1951  l[:] = []
1952  p2.visit(namesVisitor)
1953  self.assertEqual(l, ['m1', '!m2', 'm1', 'm2', '-m2', '!m1', 'm1', 'm2'])
1954  self.assertTrue(p2.dumpPython(None) == "cms.Path(process.m1+~process.m2+process.m1+process.m2+cms.ignore(process.m2)+~process.m1+process.m1+process.m2, cms.Task(process.m6, process.m7, process.m8, process.m9))\n")
1955 
1956  t1 = Task(m1,m2,m3)
1957  s1 = Sequence(t1)
1958  s2 = s1.expandAndClone()
1959  l[:] = []
1960  s2.visit(namesVisitor)
1961  self.assertEqual(l, [])
1962  self.assertTrue(s2.dumpPython(None) == "cms.Sequence(cms.Task(process.m1, process.m2, process.m3))\n")
1963 
1964  t1 = Task(m1,m2)
1965  t2 = Task(m1,m3,t1)
1966  t3 = t2.expandAndClone()
1967  self.assertTrue(t3.dumpPython(None) == "cms.Task(process.m1, process.m2, process.m3)\n")
1968  t4 = Task()
1969  t5 = t4.expandAndClone()
1970  self.assertTrue(t5.dumpPython(None) == "cms.Task()\n")
def ignore(seq)
def SequenceTypes.TestModuleCommand.testIndex (   self)

Definition at line 1888 of file SequenceTypes.py.

1888  def testIndex(self):
1889  m1 = DummyModule("a")
1890  m2 = DummyModule("b")
1891  m3 = DummyModule("c")
1892 
1893  s = Sequence(m1+m2+m3)
1894  self.assertEqual(s.index(m1),0)
1895  self.assertEqual(s.index(m2),1)
1896  self.assertEqual(s.index(m3),2)
1897 
def SequenceTypes.TestModuleCommand.testInsert (   self)

Definition at line 1898 of file SequenceTypes.py.

1898  def testInsert(self):
1899  m1 = DummyModule("a")
1900  m2 = DummyModule("b")
1901  m3 = DummyModule("c")
1902  s = Sequence(m1+m3)
1903  s.insert(1,m2)
1904  self.assertEqual(s.index(m1),0)
1905  self.assertEqual(s.index(m2),1)
1906  self.assertEqual(s.index(m3),2)
1907 
1908  s = Sequence()
1909  s.insert(0, m1)
1910  self.assertEqual(s.index(m1),0)
1911 
1912  p = Path()
1913  p.insert(0, m1)
1914  self.assertEqual(s.index(m1),0)
1915 
def SequenceTypes.TestModuleCommand.testInsertInto (   self)

Definition at line 2243 of file SequenceTypes.py.

References resolutioncreator_cfi.object.

2243  def testInsertInto(self):
2244  from FWCore.ParameterSet.Types import vstring
2245  class TestPSet(object):
2246  def __init__(self):
2247  self._dict = dict()
2248  def addVString(self,isTracked,label,value):
2249  self._dict[label]=value
2250  a = DummyModule("a")
2251  b = DummyModule("b")
2252  c = DummyModule("c")
2253  d = DummyModule("d")
2254  p = Path(a+b+c+d)
2255  decoratedList = []
2256  lister = DecoratedNodeNameVisitor(decoratedList)
2257  p.visit(lister)
2258  ps = TestPSet()
2259  p.insertInto(ps,"p",decoratedList)
2260  self.assertEqual(ps._dict, {"p":vstring("a","b","c","d")})
2261  s = Sequence(b+c)
2262  p = Path(a+s+d)
2263  decoratedList[:] = []
2264  p.visit(lister)
2265  ps = TestPSet()
2266  p.insertInto(ps,"p",decoratedList)
2267  self.assertEqual(ps._dict, {"p":vstring("a","b","c","d")})
2268 
2269  unittest.main()
def SequenceTypes.TestModuleCommand.testRemove (   self)

Definition at line 1997 of file SequenceTypes.py.

References SequenceTypes.ignore().

1997  def testRemove(self):
1998  m1 = DummyModule("m1")
1999  m2 = DummyModule("m2")
2000  m3 = DummyModule("m3")
2001  m4 = DummyModule("m4")
2002  s1 = Sequence(m1*m2+~m3)
2003  s2 = Sequence(m1*s1)
2004  l = []
2005  namesVisitor = DecoratedNodeNameVisitor(l)
2006  d = {'m1':m1 ,'m2':m2, 'm3':m3,'s1':s1, 's2':s2}
2007  l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', 'm2', '!m3'])
2008  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m1', 'm1', 'm2', '!m3'])
2009  s1.remove(m2)
2010  l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', '!m3'])
2011  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m1', 'm1', '!m3'])
2012  s2.remove(m3)
2013  l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', '!m3'])
2014  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m1', 'm1'])
2015  s1 = Sequence( m1 + m2 + m1 + m2 )
2016  l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', 'm2', 'm1', 'm2'])
2017  s1.remove(m2)
2018  l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', 'm1', 'm2'])
2019  s1 = Sequence( m1 + m3 )
2020  s2 = Sequence( m2 + ignore(m3) + s1 + m3 )
2021  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m2', '-m3', 'm1', 'm3', 'm3'])
2022  s2.remove(s1)
2023  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m2', '-m3', 'm3'])
2024  s2.remove(m3)
2025  l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m2','m3'])
2026  s1 = Sequence(m1*m2*m3)
2027  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
2028  s1.remove(m2)
2029  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
2030  s1 = Sequence(m1+m2+m3)
2031  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
2032  s1.remove(m2)
2033  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
2034  s1 = Sequence(m1*m2+m3)
2035  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
2036  s1.remove(m2)
2037  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
2038  s1 = Sequence(m1+m2*m3)
2039  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
2040  s1.remove(m2)
2041  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
2042  s1.remove(m1)
2043  s1.remove(m3)
2044  l[:]=[]; s1.visit(namesVisitor); self.assertEqual(l,[])
2045  self.assertEqual(s1.dumpPython(None), "cms.Sequence()\n")
2046  s3 = Sequence(m1)
2047  s3.remove(m1)
2048  l[:]=[]; s3.visit(namesVisitor); self.assertEqual(l,[])
2049  self.assertEqual(s3.dumpPython(None), "cms.Sequence()\n")
2050  s3 = Sequence(m1)
2051  s4 = Sequence(s3)
2052  s4.remove(m1)
2053  l[:]=[]; s4.visit(namesVisitor); self.assertEqual(l,[])
2054  self.assertEqual(s4.dumpPython(None), "cms.Sequence()\n")
2055  s1 = Sequence(m1+m2, Task(m3), Task(m4))
2056  s1.remove(m4)
2057  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2, cms.Task(process.m3))\n")
2058  s1 = Sequence(m1+m2+Sequence(Task(m3,m4), Task(m3), Task(m4)))
2059  s1.remove(m4)
2060  self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2, cms.Task(process.m3), cms.Task(process.m4))\n")
2061  t1 = Task(m1)
2062  t1.setLabel("t1")
2063  t2 = Task(m2,t1)
2064  t2.setLabel("t2")
2065  t3 = Task(t1,t2,m1)
2066  t3.remove(m1)
2067  self.assertTrue(t3.dumpPython(None) == "cms.Task(process.m1, process.t2)\n")
2068  t3.remove(m1)
2069  self.assertTrue(t3.dumpPython(None) == "cms.Task(process.m1, process.m2)\n")
2070  t3.remove(m1)
2071  self.assertTrue(t3.dumpPython(None) == "cms.Task(process.m2)\n")
2072  t3.remove(m2)
2073  self.assertTrue(t3.dumpPython(None) == "cms.Task()\n")
2074 
def ignore(seq)
def SequenceTypes.TestModuleCommand.testReplace (   self)

Definition at line 1766 of file SequenceTypes.py.

References SequenceTypes.ignore().

1766  def testReplace(self):
1767  m1 = DummyModule("m1")
1768  m2 = DummyModule("m2")
1769  m3 = DummyModule("m3")
1770  m4 = DummyModule("m4")
1771  m5 = DummyModule("m5")
1772 
1773  s1 = Sequence(m1*~m2*m1*m2*ignore(m2))
1774  s2 = Sequence(m1*m2)
1775  l = []
1776  namesVisitor = DecoratedNodeNameVisitor(l)
1777  s1.visit(namesVisitor)
1778  self.assertEqual(l,['m1', '!m2', 'm1', 'm2', '-m2'])
1779 
1780  s3 = Sequence(~m1*s2)
1781  s3.replace(~m1, m2)
1782  l[:] = []
1783  s3.visit(namesVisitor)
1784  self.assertEqual(l, ['m2', 'm1', 'm2'])
1785  s3.replace(m2, ~m1)
1786  l[:] = []
1787  s3.visit(namesVisitor)
1788  self.assertEqual(l, ['!m1', 'm1', '!m1'])
1789 
1790  s3 = Sequence(ignore(m1)*s2)
1791  s3.replace(ignore(m1), m2)
1792  l[:] = []
1793  s3.visit(namesVisitor)
1794  self.assertEqual(l, ['m2', 'm1', 'm2'])
1795  s3.replace(m2, ignore(m1))
1796  l[:] = []
1797  s3.visit(namesVisitor)
1798  self.assertEqual(l, ['-m1', 'm1', '-m1'])
1799 
1800  ph = SequencePlaceholder('x')
1801  s4 = Sequence(Sequence(ph))
1802  s4.replace(ph,m2)
1803  self.assertEqual(s4.dumpPython(None), "cms.Sequence(process.m2)\n")
1804 
1805  s1.replace(m2,m3)
1806  l[:] = []
1807  s1.visit(namesVisitor)
1808  self.assertEqual(l,['m1', '!m3', 'm1', 'm3', '-m3'])
1809  s2 = Sequence(m1*m2)
1810  s3 = Sequence(~m1*s2)
1811  l[:] = []
1812  s3.visit(namesVisitor)
1813  self.assertEqual(l,['!m1', 'm1', 'm2'])
1814  l[:] = []
1815  s3.replace(s2,m1)
1816  s3.visit(namesVisitor)
1817  self.assertEqual(l,['!m1', 'm1'])
1818 
1819  s1 = Sequence(m1+m2)
1820  s2 = Sequence(m3+m4)
1821  s3 = Sequence(s1+s2)
1822  s3.replace(m3,m5)
1823  l[:] = []
1824  s3.visit(namesVisitor)
1825  self.assertEqual(l,['m1','m2','m5','m4'])
1826 
1827  m6 = DummyModule("m6")
1828  m7 = DummyModule("m7")
1829  m8 = DummyModule("m8")
1830  m9 = DummyModule("m9")
1831 
1832  t6 = Task(m6)
1833  t7 = Task(m7)
1834  t89 = Task(m8, m9)
1835 
1836  s1 = Sequence(m1+m2, t6)
1837  s2 = Sequence(m3+m4, t7)
1838  s3 = Sequence(s1+s2, t89)
1839  s3.replace(m3,m5)
1840  l[:] = []
1841  s3.visit(namesVisitor)
1842  self.assertEqual(l,['m1','m2','m5','m4'])
1843 
1844  s3.replace(m8,m1)
1845  self.assertTrue(s3.dumpPython(None) == "cms.Sequence(cms.Sequence(process.m1+process.m2, cms.Task(process.m6))+process.m5+process.m4, cms.Task(process.m1, process.m9), cms.Task(process.m7))\n")
1846 
1847  s3.replace(m1,m7)
1848  self.assertTrue(s3.dumpPython(None) == "cms.Sequence(process.m7+process.m2+process.m5+process.m4, cms.Task(process.m6), cms.Task(process.m7), cms.Task(process.m7, process.m9))\n")
1849  result = s3.replace(t7, t89)
1850  self.assertTrue(s3.dumpPython(None) == "cms.Sequence(process.m7+process.m2+process.m5+process.m4, cms.Task(process.m6), cms.Task(process.m7, process.m9), cms.Task(process.m8, process.m9))\n")
1851  self.assertTrue(result)
1852  result = s3.replace(t7, t89)
1853  self.assertFalse(result)
1854 
1855  t1 = Task()
1856  t1.replace(m1,m2)
1857  self.assertTrue(t1.dumpPython(None) == "cms.Task()\n")
1858 
1859  t1 = Task(m1)
1860  t1.replace(m1,m2)
1861  self.assertTrue(t1.dumpPython(None) == "cms.Task(process.m2)\n")
1862 
1863  t1 = Task(m1,m2, m2)
1864  t1.replace(m2,m3)
1865  self.assertTrue(t1.dumpPython(None) == "cms.Task(process.m1, process.m3)\n")
1866 
1867  t1 = Task(m1,m2)
1868  t2 = Task(m1,m3,t1)
1869  t2.replace(m1,m4)
1870  self.assertTrue(t2.dumpPython(None) == "cms.Task(process.m2, process.m3, process.m4)\n")
1871 
1872  t1 = Task(m2)
1873  t2 = Task(m1,m3,t1)
1874  t2.replace(m1,m4)
1875  self.assertTrue(t2.dumpPython(None) == "cms.Task(process.m2, process.m3, process.m4)\n")
1876 
1877  t1 = Task(m2)
1878  t2 = Task(m1,m3,t1)
1879  t2.replace(t1,m4)
1880  self.assertTrue(t2.dumpPython(None) == "cms.Task(process.m1, process.m3, process.m4)\n")
1881 
1882  t1 = Task(m2)
1883  t2 = Task(m1,m3,t1)
1884  t3 = Task(m5)
1885  t2.replace(m2,t3)
1886  self.assertTrue(t2.dumpPython(None) == "cms.Task(process.m1, process.m3, process.m5)\n")
1887 
def ignore(seq)
def SequenceTypes.TestModuleCommand.testResolve (   self)

Definition at line 1736 of file SequenceTypes.py.

References cmsPerfStripChart.dict, and list().

1736  def testResolve(self):
1737  m1 = DummyModule("m1")
1738  m2 = DummyModule("m2")
1739  s1 = Sequence(m1)
1740  s2 = SequencePlaceholder("s3")
1741  s3 = Sequence(m2)
1742  p = Path(s1*s2)
1743  l = list()
1744  d = dict()
1745  d['s1'] = s1
1746  d['s2'] = s2
1747  d['s3'] = s3
1748  #resolver = ResolveVisitor(d)
1749  #p.visit(resolver)
1750  namesVisitor = DecoratedNodeNameVisitor(l)
1751  p.visit(namesVisitor)
1752  self.assertEqual(l, ['m1'])
1753  p.resolve(d)
1754  l[:] = []
1755  p.visit(namesVisitor)
1756  self.assertEqual(l, ['m1', 'm2'])
1757  l[:]=[]
1758  s1 = Sequence(m1)
1759  s2 = SequencePlaceholder("s3")
1760  s3 = Sequence(m2)
1761  s4 = SequencePlaceholder("s2")
1762  p=Path(s1+s4)
1763  p.resolve(d)
1764  p.visit(namesVisitor)
1765  self.assertEqual(l, ['m1', 'm2'])
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 2210 of file SequenceTypes.py.

2211  m1 = DummyModule("m1")
2212  m2 = DummyModule("m2")
2213  s1 = Sequence(m1*m2)
2214  def testRaise():
2215  s1.something = 1
2216  self.assertRaises(AttributeError,testRaise)
2217  def testRaise2():
2218  s2 = Sequence(m1*None)
2219  self.assertRaises(TypeError,testRaise2)
def SequenceTypes.TestModuleCommand.testVisitor (   self)

Definition at line 1668 of file SequenceTypes.py.

References resolutioncreator_cfi.object.

1668  def testVisitor(self):
1669  class TestVisitor(object):
1670  def __init__(self, enters, leaves):
1671  self._enters = enters
1672  self._leaves = leaves
1673  def enter(self,visitee):
1674  #print visitee.dumpSequencePython()
1675  if self._enters[0] != visitee:
1676  raise RuntimeError("wrong node ("+str(visitee)+") on 'enter'")
1677  else:
1678  self._enters = self._enters[1:]
1679  def leave(self,visitee):
1680  if self._leaves[0] != visitee:
1681  raise RuntimeError("wrong node ("+str(visitee)+") on 'leave'\n expected ("+str(self._leaves[0])+")")
1682  else:
1683  self._leaves = self._leaves[1:]
1684  a = DummyModule("a")
1685  b = DummyModule('b')
1686  multAB = a*b
1687  p = Path(multAB)
1688  t = TestVisitor(enters=[a,b],
1689  leaves=[a,b])
1690  p.visit(t)
1691 
1692  plusAB = a+b
1693  p = Path(plusAB)
1694  t = TestVisitor(enters=[a,b],
1695  leaves=[a,b])
1696  p.visit(t)
1697 
1698  c=DummyModule("c")
1699  d=DummyModule("d")
1700  e=DummyModule("e")
1701  f=DummyModule("f")
1702  g=DummyModule("g")
1703  t1 = Task(d)
1704  t2 = Task(e, t1)
1705  t3 = Task(f, g, t2)
1706  s=Sequence(plusAB, t3, t2)
1707  multSC = s*c
1708  p=Path(multSC, t1, t2)
1709 
1710  l = []
1711  v = ModuleNodeVisitor(l)
1712  p.visit(v)
1713  expected = [a,b,f,g,e,d,e,d,c,d,e,d]
1714 
1715  l[:] = []
1717  p.visit(v)
1718  expected = [f,g,e,d,e,d,d,e,d]
1719  self.assertEqual(expected,l)
1720 
1721  l[:] = []
1723  p.visit(v)
1724  expected = [a,b,c]
1725  self.assertEqual(expected,l)
1726 
1727 
1728  t=TestVisitor(enters=[s,a,b,t3,f,g,t2,e,t1,d,t2,e,t1,d,c,t1,d,t2,e,t1,d],
1729  leaves=[a,b,f,g,e,d,t1,t2,t3,e,d,t1,t2,s,c,d,t1,e,d,t1,t2])
1730  p.visit(t)
1731 
1732  notA= ~a
1733  p=Path(notA)
1734  t=TestVisitor(enters=[notA,a],leaves=[a,notA])
1735  p.visit(t)
#define str(s)

Member Data Documentation

SequenceTypes.TestModuleCommand._dict
private

Definition at line 2247 of file SequenceTypes.py.

SequenceTypes.TestModuleCommand._enters
private

Definition at line 1671 of file SequenceTypes.py.

SequenceTypes.TestModuleCommand._leaves
private

Definition at line 1672 of file SequenceTypes.py.