CMS 3D CMS Logo
Public Member Functions | Private Attributes

SequenceTypes::TestModuleCommand Class Reference

List of all members.

Public Member Functions

def setUp
def testAdd
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 737 of file SequenceTypes.py.

Member Function Documentation

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

Definition at line 738 of file SequenceTypes.py.

00739                        :
00740             """Nothing to do """
            pass
def SequenceTypes::TestModuleCommand::testAdd (   self)

Definition at line 951 of file SequenceTypes.py.

00952                          :
00953             m1 = DummyModule("m1")
00954             m2 = DummyModule("m2")
00955             m3 = DummyModule("m3")
00956             m4 = DummyModule("m4")
00957             s1 = Sequence(m1)
00958             s3 = Sequence(m3+ignore(m4))
00959             p = Path(s1)
00960             p += ~m2
00961             p *= s3
00962 
00963             l = []
00964             namesVisitor = DecoratedNodeNameVisitor(l)
00965             p.visit(namesVisitor)
00966             self.assertEqual(l, ['m1', '!m2', 'm3', '-m4'])
00967             
00968             s4 = Sequence()
00969             s4 +=m1
00970             print s1._seq.dumpSequencePython()
00971             l[:]=[]; s1.visit(namesVisitor); self.assertEqual(l,['m1'])
00972             self.assertEqual(s4.dumpPython(None),"cms.Sequence(process.m1)\n")
00973             s4 = Sequence()
00974             s4 *=m1
00975             l[:]=[]; s1.visit(namesVisitor); self.assertEqual(l,['m1'])
00976             self.assertEqual(s4.dumpPython(None),"cms.Sequence(process.m1)\n")
00977
def SequenceTypes::TestModuleCommand::testCopy (   self)

Definition at line 1118 of file SequenceTypes.py.

01119                           :
01120             a = DummyModule("a")
01121             b = DummyModule("b")
01122             c = DummyModule("c")
01123             p1 = Path(a+b+c)
01124             p2 = p1.copy()
01125             e = DummyModule("e")
01126             p2.replace(b,e)
01127             self.assertEqual(p1.dumpPython(None),"cms.Path(process.a+process.b+process.c)\n")
            self.assertEqual(p2.dumpPython(None),"cms.Path(process.a+process.e+process.c)\n")
def SequenceTypes::TestModuleCommand::testCopyAndExclude (   self)

Definition at line 1036 of file SequenceTypes.py.

01037                                     :
01038             a = DummyModule("a")
01039             b = DummyModule("b")
01040             c = DummyModule("c")
01041             d = DummyModule("d")
01042             s = Sequence(a+b+c)
01043             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
01044             s = Sequence(a+b+c+d)
01045             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
01046             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
01047             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
01048             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
01049             s=Sequence(a*b+c+d)
01050             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
01051             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
01052             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
01053             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
01054             s = Sequence(a+b*c+d)
01055             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
01056             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
01057             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
01058             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
01059             s2 = Sequence(a+b)
01060             s = Sequence(c+s2+d)
01061             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.c+process.b+process.d)\n")
01062             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.c+process.a+process.d)\n")
01063             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence((process.a+process.b)+process.d)\n")
01064             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.c+(process.a+process.b))\n")
01065             self.assertEqual(s.copyAndExclude([a,b]).dumpPython(None),"cms.Sequence(process.c+process.d)\n")
01066             s2 = Sequence(a+b+c)
01067             s = Sequence(s2+d)
01068             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
01069             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
01070             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
01071             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence((process.a+process.b+process.c))\n")
01072             s2 = Sequence(a+b+c)
01073             s = Sequence(s2*d)
01074             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
01075             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
01076             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+process.d)\n")
01077             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence((process.a+process.b+process.c))\n")
01078             self.assertEqual(s.copyAndExclude([a,b,c]).dumpPython(None),"cms.Sequence(process.d)\n")
01079             s = Sequence(ignore(a)+b+c+d)
01080             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
01081             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(cms.ignore(process.a)+process.c+process.d)\n")
01082             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(cms.ignore(process.a)+process.b+process.d)\n")
01083             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(cms.ignore(process.a)+process.b+process.c)\n")
01084             s = Sequence(a+ignore(b)+c+d)
01085             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(cms.ignore(process.b)+process.c+process.d)\n")
01086             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
01087             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+cms.ignore(process.b)+process.d)\n")
01088             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+cms.ignore(process.b)+process.c)\n")
01089             s = Sequence(a+b+c+ignore(d))
01090             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+cms.ignore(process.d))\n")
01091             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+cms.ignore(process.d))\n")
01092             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+process.b+cms.ignore(process.d))\n")
01093             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+process.b+process.c)\n")
01094             s = Sequence(~a+b+c+d)
01095             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+process.d)\n")
01096             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(~process.a+process.c+process.d)\n")
01097             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(~process.a+process.b+process.d)\n")
01098             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(~process.a+process.b+process.c)\n")
01099             s = Sequence(a+~b+c+d)
01100             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(~process.b+process.c+process.d)\n")
01101             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+process.d)\n")
01102             self.assertEqual(s.copyAndExclude([c]).dumpPython(None),"cms.Sequence(process.a+~process.b+process.d)\n")
01103             self.assertEqual(s.copyAndExclude([d]).dumpPython(None),"cms.Sequence(process.a+~process.b+process.c)\n")
01104             s = Sequence(a+b+c+~d)
01105             self.assertEqual(s.copyAndExclude([a]).dumpPython(None),"cms.Sequence(process.b+process.c+~process.d)\n")
01106             self.assertEqual(s.copyAndExclude([b]).dumpPython(None),"cms.Sequence(process.a+process.c+~process.d)\n")
01107             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 782 of file SequenceTypes.py.

00783                                 :
00784             a = DummyModule("a")
00785             b = DummyModule('b')
00786             p = Path((a*b))
00787             #print p.dumpConfig('')
00788             self.assertEqual(p.dumpConfig(None),"{a&b}\n")
00789             p2 = Path((b+a))
00790             #print p2.dumpConfig('')
00791             self.assertEqual(p2.dumpConfig(None),"{b&a}\n")
00792             c = DummyModule('c')
00793             p3 = Path(c*(a+b))
00794             #print p3.dumpConfig('')
00795             self.assertEqual(p3.dumpConfig(None),"{c&a&b}\n")
00796             p4 = Path(c*a+b)
00797             #print p4.dumpConfig('')
00798             self.assertEqual(p4.dumpConfig(None),"{c&a&b}\n")
00799             p5 = Path(a+ignore(b))
00800             #print p5.dumpConfig('')
00801             self.assertEqual(p5.dumpConfig(None),"{a&-b}\n")
00802             p6 = Path(c+a*b)
00803             #print p6.dumpConfig('')
00804             self.assertEqual(p6.dumpConfig(None),"{c&a&b}\n")
00805             p7 = Path(a+~b)
00806             self.assertEqual(p7.dumpConfig(None),"{a&!b}\n")
00807             p8 = Path((a+b)*c)
            self.assertEqual(p8.dumpConfig(None),"{a&b&c}\n")
def SequenceTypes::TestModuleCommand::testDumpPython (   self)

Definition at line 741 of file SequenceTypes.py.

00742                                 :
00743             a = DummyModule("a")
00744             b = DummyModule('b')
00745             p = Path((a*b))
00746             #print p.dumpConfig('')
00747             self.assertEqual(p.dumpPython(None),"cms.Path(process.a+process.b)\n")
00748             p2 = Path((b+a))
00749             #print p2.dumpConfig('')
00750             self.assertEqual(p2.dumpPython(None),"cms.Path(process.b+process.a)\n")
00751             c = DummyModule('c')
00752             p3 = Path(c*(a+b))
00753             #print p3.dumpConfig('')
00754             self.assertEqual(p3.dumpPython(None),"cms.Path(process.c+process.a+process.b)\n")
00755             p4 = Path(c*a+b)
00756             #print p4.dumpConfig('')
00757             self.assertEqual(p4.dumpPython(None),"cms.Path(process.c+process.a+process.b)\n")
00758             p5 = Path(a+ignore(b))
00759             #print p5.dumpConfig('')
00760             self.assertEqual(p5.dumpPython(None),"cms.Path(process.a+cms.ignore(process.b))\n")
00761             p6 = Path(c+a*b)
00762             #print p6.dumpConfig('')
00763             self.assertEqual(p6.dumpPython(None),"cms.Path(process.c+process.a+process.b)\n")
00764             p7 = Path(a+~b)
00765             self.assertEqual(p7.dumpPython(None),"cms.Path(process.a+~process.b)\n")
00766             p8 = Path((a+b)*c)
00767             self.assertEqual(p8.dumpPython(None),"cms.Path(process.a+process.b+process.c)\n")
00768             l = list()
00769             namesVisitor = DecoratedNodeNameVisitor(l)
00770             p.visit(namesVisitor)
00771             self.assertEqual(l, ['a', 'b'])
00772             l[:] = []
00773             p5.visit(namesVisitor)
00774             self.assertEqual(l, ['a', '-b'])
00775             l[:] = []
00776             p7.visit(namesVisitor)
00777             self.assertEqual(l, ['a', '!b'])
00778             l[:] = []
00779             moduleVisitor = ModuleNodeVisitor(l)
00780             p8.visit(moduleVisitor)
00781             names = [m.label_() for m in l]
            self.assertEqual(names, ['a', 'b', 'c'])
def SequenceTypes::TestModuleCommand::testExpandAndClone (   self)

Definition at line 933 of file SequenceTypes.py.

00934                                     :
00935             m1 = DummyModule("m1")
00936             m2 = DummyModule("m2")
00937             m3 = DummyModule("m3")
00938             m4 = DummyModule("m4")
00939             m5 = DummyModule("m5")
00940 
00941             s1 = Sequence(m1*~m2*m1*m2*ignore(m2))
00942             s2 = Sequence(m1*m2)
00943             s3 = Sequence(~m1*s2)
00944 
00945             p = Path(s1+s3)
00946             p2 = p.expandAndClone()
00947             l = []
00948             namesVisitor = DecoratedNodeNameVisitor(l)
00949             p2.visit(namesVisitor)
00950             self.assertEqual(l, ['m1', '!m2', 'm1', 'm2', '-m2', '!m1', 'm1', 'm2'])
def SequenceTypes::TestModuleCommand::testIndex (   self)

Definition at line 912 of file SequenceTypes.py.

00913                            :
00914             m1 = DummyModule("a")
00915             m2 = DummyModule("b")
00916             m3 = DummyModule("c")
00917         
00918             s = Sequence(m1+m2+m3)
00919             self.assertEqual(s.index(m1),0)
00920             self.assertEqual(s.index(m2),1)        
00921             self.assertEqual(s.index(m3),2)
def SequenceTypes::TestModuleCommand::testInsert (   self)

Definition at line 922 of file SequenceTypes.py.

00923                             :
00924             m1 = DummyModule("a")
00925             m2 = DummyModule("b")
00926             m3 = DummyModule("c")
00927             s = Sequence(m1+m3)
00928             s.insert(1,m2)
00929             self.assertEqual(s.index(m1),0)
00930             self.assertEqual(s.index(m2),1)        
00931             self.assertEqual(s.index(m3),2)
00932
def SequenceTypes::TestModuleCommand::testInsertInto (   self)

Definition at line 1128 of file SequenceTypes.py.

01129                                 :
01130             from FWCore.ParameterSet.Types import vstring
01131             class TestPSet(object):
01132                 def __init__(self):
01133                     self._dict = dict()
01134                 def addVString(self,isTracked,label,value):
01135                     self._dict[label]=value
01136             a = DummyModule("a")
01137             b = DummyModule("b")
01138             c = DummyModule("c")
01139             d = DummyModule("d")
01140             p = Path(a+b+c+d)
01141             ps = TestPSet()
01142             p.insertInto(ps,"p",dict())
01143             self.assertEqual(ps._dict, {"p":vstring("a","b","c","d")})
01144             s = Sequence(b+c)
01145             p = Path(a+s+d)
01146             ps = TestPSet()
01147             p.insertInto(ps,"p",dict())
01148             self.assertEqual(ps._dict, {"p":vstring("a","b","c","d")})
01149                         
    unittest.main()
def SequenceTypes::TestModuleCommand::testRemove (   self)

Definition at line 978 of file SequenceTypes.py.

00979                             :
00980             m1 = DummyModule("m1")
00981             m2 = DummyModule("m2")
00982             m3 = DummyModule("m3")
00983             s1 = Sequence(m1*m2+~m3)
00984             s2 = Sequence(m1*s1)
00985             l = []
00986             namesVisitor = DecoratedNodeNameVisitor(l)
00987             d = {'m1':m1 ,'m2':m2, 'm3':m3,'s1':s1, 's2':s2}  
00988             l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', 'm2', '!m3'])
00989             l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m1', 'm1', 'm2', '!m3'])
00990             s1.remove(m2)
00991             l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', '!m3'])
00992             l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m1', 'm1', '!m3'])
00993             s2.remove(m3)
00994             l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', '!m3'])
00995             l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m1', 'm1'])
00996             s1 = Sequence( m1 + m2 + m1 + m2 )
00997             l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', 'm2', 'm1', 'm2'])
00998             s1.remove(m2) 
00999             l[:] = []; s1.visit(namesVisitor); self.assertEqual(l,['m1', 'm1', 'm2'])
01000             s1 = Sequence( m1 + m3 )
01001             s2 = Sequence( m2 + ignore(m3) + s1 + m3 )
01002             l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m2', '-m3', 'm1', 'm3', 'm3'])
01003             s2.remove(s1)
01004             l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m2', '-m3', 'm3'])
01005             s2.remove(m3)
01006             l[:] = []; s2.visit(namesVisitor); self.assertEqual(l,['m2','m3'])
01007             s1 = Sequence(m1*m2*m3)
01008             self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
01009             s1.remove(m2)
01010             self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
01011             s1 = Sequence(m1+m2+m3)
01012             self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
01013             s1.remove(m2)
01014             self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
01015             s1 = Sequence(m1*m2+m3)
01016             self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
01017             s1.remove(m2)
01018             self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
01019             s1 = Sequence(m1+m2*m3)
01020             self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m2+process.m3)\n")
01021             s1.remove(m2)
01022             self.assertEqual(s1.dumpPython(None), "cms.Sequence(process.m1+process.m3)\n")
01023             s1.remove(m1)
01024             s1.remove(m3)
01025             l[:]=[]; s1.visit(namesVisitor); self.assertEqual(l,[])
01026             self.assertEqual(s1.dumpPython(None), "cms.Sequence()\n")
01027             s3 = Sequence(m1)
01028             s3.remove(m1)
01029             l[:]=[]; s3.visit(namesVisitor); self.assertEqual(l,[])
01030             self.assertEqual(s3.dumpPython(None), "cms.Sequence()\n")
01031             s3 = Sequence(m1)
01032             s4 = Sequence(s3)
01033             s4.remove(m1)
01034             l[:]=[]; s4.visit(namesVisitor); self.assertEqual(l,[])
01035             self.assertEqual(s4.dumpPython(None), "cms.Sequence()\n")
def SequenceTypes::TestModuleCommand::testReplace (   self)

Definition at line 871 of file SequenceTypes.py.

00872                              :
00873             m1 = DummyModule("m1")
00874             m2 = DummyModule("m2")
00875             m3 = DummyModule("m3")
00876             m4 = DummyModule("m4")
00877             m5 = DummyModule("m5")
00878  
00879             s1 = Sequence(m1*~m2*m1*m2*ignore(m2))
00880             s2 = Sequence(m1*m2)
00881             l = []
00882             namesVisitor = DecoratedNodeNameVisitor(l)
00883             s1.visit(namesVisitor)
00884             self.assertEqual(l,['m1', '!m2', 'm1', 'm2', '-m2'])
00885 
00886             s3 = Sequence(~m1*s2)
00887             s3.replace(~m1, m2)
00888             l[:] = []
00889             s3.visit(namesVisitor)
00890             self.assertEqual(l, ['m2', 'm1', 'm2'])
00891 
00892             s1.replace(m2,m3)
00893             l[:] = []
00894             s1.visit(namesVisitor)
00895             self.assertEqual(l,['m1', '!m3', 'm1', 'm3', '-m3'])
00896             s2 = Sequence(m1*m2)
00897             s3 = Sequence(~m1*s2)
00898             l[:] = []
00899             s3.visit(namesVisitor)
00900             self.assertEqual(l,['!m1', 'm1', 'm2'])
00901             l[:] = []
00902             s3.replace(s2,m1)
00903             s3.visit(namesVisitor)
00904             self.assertEqual(l,['!m1', 'm1'])
00905             
00906             s1 = Sequence(m1+m2)
00907             s2 = Sequence(m3+m4)
00908             s3 = Sequence(s1+s2)
00909             s3.replace(m3,m5)
00910             l[:] = []
00911             s3.visit(namesVisitor)
            self.assertEqual(l,['m1','m2','m5','m4'])
def SequenceTypes::TestModuleCommand::testResolve (   self)

Definition at line 850 of file SequenceTypes.py.

00851                              :
00852             m1 = DummyModule("m1")
00853             m2 = DummyModule("m2")
00854             s1 = Sequence(m1)
00855             s2 = SequencePlaceholder("s3")
00856             s3 = Sequence(m2)
00857             p = Path(s1*s2)
00858             l = list()
00859             d = dict()
00860             d['s1'] = s1
00861             d['s2'] = s2
00862             d['s3'] = s3
00863             #resolver = ResolveVisitor(d)
00864             #p.visit(resolver)
00865             namesVisitor = DecoratedNodeNameVisitor(l)
00866             p.visit(namesVisitor)
00867             self.assertEqual(l, ['m1'])
00868             p.resolve(d)
00869             l[:] = []
00870             p.visit(namesVisitor)
            self.assertEqual(l, ['m1', 'm2'])
def SequenceTypes::TestModuleCommand::testSequenceTypeChecks (   self)

Definition at line 1108 of file SequenceTypes.py.

01109                                         :
01110             m1 = DummyModule("m1")
01111             m2 = DummyModule("m2")
01112             s1 = Sequence(m1*m2)
01113             def testRaise():
01114                 s1.something = 1
01115             self.assertRaises(AttributeError,testRaise)
01116             def testRaise2():
01117                 s2 = Sequence(m1*None)
            self.assertRaises(TypeError,testRaise2)
def SequenceTypes::TestModuleCommand::testVisitor (   self)

Definition at line 808 of file SequenceTypes.py.

00809                              :
00810             class TestVisitor(object):
00811                 def __init__(self, enters, leaves):
00812                     self._enters = enters
00813                     self._leaves = leaves
00814                 def enter(self,visitee):
00815                     #print visitee.dumpSequencePython()
00816                     if self._enters[0] != visitee:
00817                         raise RuntimeError("wrong node ("+str(visitee)+") on 'enter'")
00818                     else:
00819                         self._enters = self._enters[1:]
00820                 def leave(self,visitee):
00821                     if self._leaves[0] != visitee:
00822                         raise RuntimeError("wrong node ("+str(visitee)+") on 'leave'\n expected ("+str(self._leaves[0])+")")
00823                     else:
00824                         self._leaves = self._leaves[1:]
00825             a = DummyModule("a")
00826             b = DummyModule('b')
00827             multAB = a*b
00828             p = Path(multAB)
00829             t = TestVisitor(enters=[a,b],
00830                             leaves=[a,b])
00831             p.visit(t)
00832 
00833             plusAB = a+b
00834             p = Path(plusAB)
00835             t = TestVisitor(enters=[a,b],
00836                             leaves=[a,b])
00837             p.visit(t)
00838             
00839             s=Sequence(plusAB)
00840             c=DummyModule("c")
00841             multSC = s*c
00842             p=Path(multSC)
00843             t=TestVisitor(enters=[s,a,b,c],
00844                           leaves=[a,b,s,c])
00845             p.visit(t)
00846             
00847             notA= ~a
00848             p=Path(notA)
00849             t=TestVisitor(enters=[notA,a],leaves=[a,notA])
            p.visit(t)

Member Data Documentation

SequenceTypes::TestModuleCommand::_dict [private]

Definition at line 1128 of file SequenceTypes.py.

SequenceTypes::TestModuleCommand::_enters [private]

Definition at line 808 of file SequenceTypes.py.

SequenceTypes::TestModuleCommand::_leaves [private]

Definition at line 808 of file SequenceTypes.py.

Generated for CMSSW Reference Manual by doxygen 1.7.3