|
|
|
Public Member Functions | |
| def | checkRepr |
| def | setUp |
| def | strip |
| def | testInclude |
| def | testLetterstart |
| def | testParameters |
| def | testParseCffFile |
| def | testPath |
| def | testPlaceholder |
| def | testPlugin |
| def | testProcess |
| def | testReplace |
| def | testUsing |
| def | testValidation |
Definition at line 1682 of file parseConfig.py.
| def parseConfig::TestModuleCommand::checkRepr | ( | self, | ||
| obj, | ||||
| expected | ||||
| ) |
Definition at line 2816 of file parseConfig.py.
02816 : 02817 # strip out whitespace & newlines 02818 observe = self.strip(repr(obj)) 02819 expect = self.strip(expected) 02820 self.assertEqual(observe, expect) def testReplace(self):
| def parseConfig::TestModuleCommand::setUp | ( | self | ) |
Nothing to do
Definition at line 1683 of file parseConfig.py.
01683 : 01684 """Nothing to do """ 01685 #print 'testing' def testPlaceholder(self):
| def parseConfig::TestModuleCommand::strip | ( | value | ) |
strip out whitespace & newlines
Definition at line 2813 of file parseConfig.py.
02813 : 02814 """strip out whitespace & newlines""" 02815 return value.replace(' ','').replace('\n','') def checkRepr(self, obj, expected):
| def parseConfig::TestModuleCommand::testInclude | ( | self | ) |
Definition at line 1897 of file parseConfig.py.
01897 : 01898 #for testing use a different factory 01899 import StringIO 01900 global _fileFactory 01901 oldFactory = _fileFactory 01902 try: 01903 _fileFactory = TestFactory('Sub/Pack/data/foo.cff', 'int32 blah = 1') 01904 t=onlyParameters.parseString("PSet blah = {include 'Sub/Pack/data/foo.cff'}") 01905 d=dict(iter(t)) 01906 self.assertEqual(type(d['blah']),cms.PSet) 01907 self.assertEqual(getattr(d['blah'],"blah").value(), 1) 01908 01909 _fileFactory = TestFactory('Sub/Pack/data/foo.cfi', 'module foo = TestProd {}') 01910 t=onlyProcessBody.parseString("include 'Sub/Pack/data/foo.cfi'") 01911 d=dict(iter(t)) 01912 self.assertEqual(d['Sub/Pack/data/foo.cfi'].filename, 'Sub/Pack/data/foo.cfi') 01913 t = _findAndHandleProcessBlockIncludes(t) 01914 d=dict(iter(t)) 01915 self.assertEqual(type(d['foo']),cms.EDProducer) 01916 01917 #test ending with a comment 01918 _fileFactory = TestFactory('Sub/Pack/data/foo.cfi', """module c = CProd {} 01919 #""") 01920 t=onlyProcessBody.parseString("""module b = BProd {} 01921 include 'Sub/Pack/data/foo.cfi'""") 01922 d=dict(iter(t)) 01923 self.assertEqual(d['Sub/Pack/data/foo.cfi'].filename, 'Sub/Pack/data/foo.cfi') 01924 t = _findAndHandleProcessBlockIncludes(t) 01925 01926 _fileFactory = TestFactory('Sub/Pack/data/foo.cfi', "include 'Sub/Pack/data/foo.cfi'") 01927 t=onlyProcessBody.parseString("include 'Sub/Pack/data/foo.cfi'") 01928 d=dict(iter(t)) 01929 self.assertEqual(d['Sub/Pack/data/foo.cfi'].filename, 'Sub/Pack/data/foo.cfi') 01930 self.assertRaises(RuntimeError,_findAndHandleProcessBlockIncludes,t) 01931 #t = _findAndHandleProcessBlockIncludes(t) 01932 01933 _fileFactory = TestFactory('Sub/Pack/data/foo.cff', '#an empty file') 01934 t=onlyParameters.parseString("PSet blah = {include 'Sub/Pack/data/foo.cff'}") 01935 d=dict(iter(t)) 01936 self.assertEqual(type(d['blah']),cms.PSet) 01937 01938 #test block 01939 _fileFactory = TestFactory('Sub/Pack/data/foo.cff', """block c = { ## 01940 ## 01941 double EBs25notContainment = 0.965} 01942 """) 01943 t=onlyProcessBody.parseString("""module b = BProd {using c} 01944 include 'Sub/Pack/data/foo.cff'""") 01945 d=dict(iter(t)) 01946 self.assertEqual(d['Sub/Pack/data/foo.cff'].filename, 'Sub/Pack/data/foo.cff') 01947 t = _findAndHandleProcessBlockIncludes(t) 01948 01949 _fileFactory = TestFactory('Sub/Pack/data/foo.cff', 01950 """path p = {doesNotExist}""") 01951 try: 01952 process.parseString("""process T = { include 'Sub/Pack/data/foo.cff' }""") 01953 except Exception,e: 01954 self.assertEqual(str(e), 01955 """the process contains the error 01956 path 'p' contains the error: 'Process' object has no attribute 'doesNotExist' 01957 from file Sub/Pack/data/foo.cff (at char 4), (line:1, col:5)""") 01958 else: 01959 self.fail("failed to throw exception") 01960 finally: 01961 _fileFactory = oldFactory def testParseCffFile(self):
| def parseConfig::TestModuleCommand::testLetterstart | ( | self | ) |
Definition at line 1691 of file parseConfig.py.
01691 : 01692 t = letterstart.parseString("abcd") 01693 self.assertEqual(len(t),1) 01694 self.assertEqual(t[0],"abcd") 01695 t = letterstart.parseString("a1cd") 01696 self.assertEqual(len(t),1) 01697 self.assertEqual(t[0],"a1cd") 01698 t = letterstart.parseString("a_cd") 01699 self.assertEqual(t[0],"a_cd") 01700 t = letterstart.parseString("a-cd") 01701 self.assertEqual(t[0],"a-cd") 01702 self.assertRaises(pp.ParseBaseException,letterstart.parseString,("1abc")) def testParameters(self):
| def parseConfig::TestModuleCommand::testParameters | ( | self | ) |
Definition at line 1703 of file parseConfig.py.
01703 : 01704 t=onlyParameters.parseString("bool blah = True") 01705 d =dict(iter(t)) 01706 self.assertEqual(type(d['blah']),cms.bool) 01707 self.assertEqual(d['blah'].value(),True) 01708 t=onlyParameters.parseString("bool blah = 1") 01709 d =dict(iter(t)) 01710 self.assertEqual(type(d['blah']),cms.bool) 01711 self.assertEqual(d['blah'].value(),True) 01712 t=onlyParameters.parseString("bool blah = False") 01713 d =dict(iter(t)) 01714 self.assertEqual(type(d['blah']),cms.bool) 01715 self.assertEqual(d['blah'].value(),False) 01716 t=onlyParameters.parseString("bool blah = 2") 01717 d =dict(iter(t)) 01718 self.assertEqual(type(d['blah']),cms.bool) 01719 self.assertEqual(d['blah'].value(),True) 01720 t=onlyParameters.parseString("vint32 blah = {}") 01721 d=dict(iter(t)) 01722 self.assertEqual(type(d['blah']),cms.vint32) 01723 self.assertEqual(len(d['blah']),0) 01724 t=onlyParameters.parseString("vint32 blah = {1}") 01725 d=dict(iter(t)) 01726 self.assertEqual(type(d['blah']),cms.vint32) 01727 self.assertEqual(d['blah'],[1]) 01728 t=onlyParameters.parseString("vint32 blah = {1,2}") 01729 d=dict(iter(t)) 01730 self.assertEqual(type(d['blah']),cms.vint32) 01731 self.assertEqual(d['blah'],[1,2]) 01732 t=onlyParameters.parseString("string blah = 'a string'") 01733 d=dict(iter(t)) 01734 self.assertEqual(type(d['blah']),cms.string) 01735 self.assertEqual(d['blah'].value(),'a string') 01736 t=onlyParameters.parseString('string blah = "a string"') 01737 d=dict(iter(t)) 01738 self.assertEqual(type(d['blah']),cms.string) 01739 self.assertEqual(d['blah'].value(),'a string') 01740 t=onlyParameters.parseString('string blah = "\\0"') 01741 d=dict(iter(t)) 01742 self.assertEqual(type(d['blah']),cms.string) 01743 self.assertEqual(d['blah'].value(),'\0') 01744 01745 t=onlyParameters.parseString("vstring blah = {}") 01746 d=dict(iter(t)) 01747 self.assertEqual(type(d['blah']),cms.vstring) 01748 self.assertEqual(len(d['blah']),0) 01749 t=onlyParameters.parseString("vstring blah = {'abc'}") 01750 d=dict(iter(t)) 01751 self.assertEqual(type(d['blah']),cms.vstring) 01752 self.assertEqual(d['blah'],['abc']) 01753 t=onlyParameters.parseString("vstring blah = {'abc','def'}") 01754 d=dict(iter(t)) 01755 self.assertEqual(type(d['blah']),cms.vstring) 01756 self.assertEqual(d['blah'],['abc','def']) 01757 01758 t = onlyParameters.parseString("InputTag blah = tag") 01759 d=dict(iter(t)) 01760 self.assertEqual(type(d['blah']),cms.InputTag) 01761 self.assertEqual(d['blah'].moduleLabel,'tag') 01762 self.assertEqual(d['blah'].productInstanceLabel,'') 01763 t = onlyParameters.parseString("InputTag blah = tag:") 01764 d=dict(iter(t)) 01765 self.assertEqual(type(d['blah']),cms.InputTag) 01766 self.assertEqual(d['blah'].moduleLabel,'tag') 01767 self.assertEqual(d['blah'].productInstanceLabel,'') 01768 01769 t = onlyParameters.parseString("InputTag blah =tag:youIt") 01770 # FAILS! 01771 # = onlyParameters.parseString("InputTag blah = \"tag:youIt\"") 01772 d=dict(iter(t)) 01773 self.assertEqual(type(d['blah']),cms.InputTag) 01774 self.assertEqual(d['blah'].moduleLabel,'tag') 01775 self.assertEqual(d['blah'].productInstanceLabel,'youIt') 01776 01777 t = onlyParameters.parseString("InputTag blah = tag::proc") 01778 d=dict(iter(t)) 01779 self.assertEqual(type(d['blah']),cms.InputTag) 01780 self.assertEqual(d['blah'].moduleLabel,'tag') 01781 self.assertEqual(d['blah'].processName,'proc') 01782 01783 t = onlyParameters.parseString("InputTag blah = tag:youIt:Now") 01784 d=dict(iter(t)) 01785 self.assertEqual(type(d['blah']),cms.InputTag) 01786 self.assertEqual(d['blah'].moduleLabel,'tag') 01787 self.assertEqual(d['blah'].productInstanceLabel,'youIt') 01788 self.assertEqual(d['blah'].processName,'Now') 01789 01790 t=onlyParameters.parseString("VInputTag blah = {}") 01791 d=dict(iter(t)) 01792 self.assertEqual(type(d['blah']),cms.VInputTag) 01793 self.assertEqual(len(d['blah']),0) 01794 t=onlyParameters.parseString("VInputTag blah = {abc}") 01795 d=dict(iter(t)) 01796 self.assertEqual(type(d['blah']),cms.VInputTag) 01797 self.assertEqual(d['blah'],[cms.InputTag('abc')]) 01798 t=onlyParameters.parseString("VInputTag blah = {abc, def}") 01799 d=dict(iter(t)) 01800 self.assertEqual(type(d['blah']),cms.VInputTag) 01801 self.assertEqual(d['blah'],[cms.InputTag('abc'),cms.InputTag('def')]) 01802 t=onlyParameters.parseString("VInputTag blah = {'abc', def}") 01803 d=dict(iter(t)) 01804 self.assertEqual(type(d['blah']),cms.VInputTag) 01805 self.assertEqual(d['blah'],[cms.InputTag('abc'),cms.InputTag('def')]) 01806 01807 01808 t=onlyParameters.parseString("EventID eid= 1:2") 01809 d=dict(iter(t)) 01810 self.assertEqual(type(d['eid']),cms.EventID) 01811 self.assertEqual(d['eid'].run(), 1) 01812 self.assertEqual(d['eid'].event(), 2) 01813 t=onlyParameters.parseString("LuminosityBlockID lbid= 1:2") 01814 d=dict(iter(t)) 01815 self.assertEqual(type(d['lbid']),cms.LuminosityBlockID) 01816 self.assertEqual(d['lbid'].run(), 1) 01817 self.assertEqual(d['lbid'].luminosityBlock(), 2) 01818 01819 01820 01821 t=onlyParameters.parseString("PSet blah = {}") 01822 d=dict(iter(t)) 01823 self.assertEqual(type(d['blah']),cms.PSet) 01824 01825 t=onlyParameters.parseString("PSet blah = {int32 ick = 1 }") 01826 d=dict(iter(t)) 01827 self.assertEqual(type(d['blah']),cms.PSet) 01828 self.assertEqual(d['blah'].ick.value(), 1) 01829 01830 t=onlyParameters.parseString("""PSet blah = { 01831 int32 ick = 1 01832 }""") 01833 d=dict(iter(t)) 01834 self.assertEqual(type(d['blah']),cms.PSet) 01835 self.assertEqual(d['blah'].ick.value(), 1) 01836 01837 t=onlyParameters.parseString("""PSet blah = { 01838 InputTag t1 = abc: 01839 InputTag t2 = def:GHI 01840 }""") 01841 d=dict(iter(t)) 01842 self.assertEqual(type(d['blah']),cms.PSet) 01843 01844 t=onlyParameters.parseString("VPSet blah = {}") 01845 d=dict(iter(t)) 01846 self.assertEqual(type(d['blah']),cms.VPSet) 01847 01848 t=onlyParameters.parseString("VPSet blah = { {} }") 01849 d=dict(iter(t)) 01850 self.assertEqual(type(d['blah']),cms.VPSet) 01851 self.assertEqual(len(d['blah']),1) 01852 01853 t=onlyParameters.parseString("VPSet blah = { {int32 ick = 1 } }") 01854 d=dict(iter(t)) 01855 self.assertEqual(type(d['blah']),cms.VPSet) 01856 self.assertEqual(len(d['blah']),1) 01857 t=onlyParameters.parseString("VPSet blah = { {int32 ick = 1 }, {int32 ick =2} }") 01858 d=dict(iter(t)) 01859 self.assertEqual(type(d['blah']),cms.VPSet) 01860 self.assertEqual(len(d['blah']),2) 01861 01862 t=onlyParameters.parseString("secsource blah = Foo {int32 ick=1}") 01863 d=dict(iter(t)) 01864 self.assertEqual(type(d['blah']),cms.SecSource) 01865 def testValidation(self):
| def parseConfig::TestModuleCommand::testParseCffFile | ( | self | ) |
Definition at line 1962 of file parseConfig.py.
01962 : 01963 import StringIO 01964 global _fileFactory 01965 oldFactory = _fileFactory 01966 try: 01967 _fileFactory = TestFactory('Sub/Pack/data/foo.cff', 01968 """module a = AProducer {} 01969 sequence s1 = {s} 01970 sequence s = {a}""") 01971 p=parseCffFile('Sub/Pack/data/foo.cff') 01972 self.assertEqual(p.a.type_(),'AProducer') 01973 self.assertEqual(type(p.s1),cms.Sequence) 01974 self.assertTrue(p.s1._seq is p.s) 01975 pr=cms.Process('Test') 01976 pr.extend(p) 01977 self.assertEqual(str(pr.s),'a') 01978 pr.dumpConfig() 01979 finally: 01980 _fileFactory = oldFactory 01981 def testPlugin(self):
| def parseConfig::TestModuleCommand::testPath | ( | self | ) |
Definition at line 2722 of file parseConfig.py.
02722 : 02723 p = cms.Process('Test') 02724 p.out = cms.OutputModule('PoolOutputModule') 02725 p.a = cms.EDProducer('AProd') 02726 p.b = cms.EDProducer('BProd') 02727 p.c = cms.EDProducer('CProd') 02728 t=path.parseString('path p = {out}') 02729 self.assertEqual(str(t[0][1]),'out') 02730 pth = t[0][1].make(p) 02731 self.assertEqual(str(pth),'out') 02732 #setattr(p,t[0][0],pth) 02733 #print getattr(p,t[0][0]) 02734 #print pth 02735 # print t[0][1] 02736 t=path.parseString('path p = {a,b}') 02737 self.assertEqual(str(t[0][1]),'(a,b)') 02738 self.checkRepr(t[0][1], 'cms.Path(a*b)') 02739 options = PrintOptions() 02740 options.isCfg = True 02741 self.assertEqual(t[0][1].dumpPython(options), 'cms.Path(process.a*process.b)') 02742 pth = t[0][1].make(p) 02743 self.assertEqual(str(pth),'a*b') 02744 #print pth 02745 # print t[0][1] 02746 t=path.parseString('path p = {a&b}') 02747 self.assertEqual(str(t[0][1]),'(a&b)') 02748 pth = t[0][1].make(p) 02749 self.assertEqual(str(pth),'a+b') 02750 # print t[0][1] 02751 t=path.parseString('path p = {a,b,c}') 02752 self.assertEqual(str(t[0][1]),'((a,b),c)') 02753 pth = t[0][1].make(p) 02754 self.assertEqual(str(pth),'a*b*c') 02755 # print t[0][1] 02756 t=path.parseString('path p = {a&b&c}') 02757 self.assertEqual(str(t[0][1]),'((a&b)&c)') 02758 pth = t[0][1].make(p) 02759 self.assertEqual(str(pth),'a+b+c') 02760 # print t[0][1] 02761 t=path.parseString('path p = {a&b,c}') 02762 self.assertEqual(str(t[0][1]),'(a&(b,c))') 02763 pth = t[0][1].make(p) 02764 self.assertEqual(str(pth),'a+b*c') 02765 # print t[0][1] 02766 t=path.parseString('path p = {a,b&c}') 02767 self.assertEqual(str(t[0][1]),'((a,b)&c)') 02768 pth = t[0][1].make(p) 02769 self.assertEqual(str(pth),'a*b+c') 02770 # print t[0][1] 02771 t=path.parseString('path p = {(a,b)&c}') 02772 self.assertEqual(str(t[0][1]),'((a,b)&c)') 02773 pth = t[0][1].make(p) 02774 self.assertEqual(str(pth),'a*b+c') 02775 # print t[0][1] 02776 t=path.parseString('path p = {(a&b),c}') 02777 self.assertEqual(str(t[0][1]),'((a&b),c)') 02778 pth = t[0][1].make(p) 02779 self.assertEqual(str(pth),'(a+b)*c') 02780 # print t[0][1] 02781 t=path.parseString('path p = {a,(b&c)}') 02782 self.assertEqual(str(t[0][1]),'(a,(b&c))') 02783 pth = t[0][1].make(p) 02784 self.assertEqual(str(pth),'a*(b+c)') 02785 # print t[0][1] 02786 t=path.parseString('path p = {a&(b,c)}') 02787 self.assertEqual(str(t[0][1]),'(a&(b,c))') 02788 pth = t[0][1].make(p) 02789 self.assertEqual(str(pth),'a+b*c') 02790 # print t[0][1] 02791 p.d = cms.Sequence(p.a*p.b) 02792 t=path.parseString('path p = {d,c}') 02793 self.assertEqual(str(t[0][1]),'(d,c)') 02794 pth = t[0][1].make(p) 02795 self.assertEqual(str(pth),'a*b*c') 02796 # print t[0][1] 02797 t=path.parseString('path p = {a&!b}') 02798 self.assertEqual(str(t[0][1]),'(a&!b)') 02799 pth = t[0][1].make(p) 02800 self.assertEqual(str(pth),'a+~b') 02801 # print t[0][1] 02802 t=path.parseString('path p = {!a&!b&!c}') 02803 self.assertEqual(str(t[0][1]),'((!a&!b)&!c)') 02804 pth = t[0][1].make(p) 02805 self.assertEqual(str(pth),'~a+~b+~c') 02806 02807 t=path.parseString('path p = {a&-b}') 02808 self.assertEqual(str(t[0][1]),'(a&-b)') 02809 pth = t[0][1].make(p) 02810 self.assertEqual(str(pth),'a+cms.ignore(b)') 02811 02812 @staticmethod def strip(value):
| def parseConfig::TestModuleCommand::testPlaceholder | ( | self | ) |
Definition at line 1686 of file parseConfig.py.
01686 : 01687 t=path.parseString('path p = {out}') 01688 _validateSequences(t) 01689 self.assertEqual(repr(t[0][1]), "cms.Path(cms.SequencePlaceholder(\"out\"))") 01690 def testLetterstart(self):
| def parseConfig::TestModuleCommand::testPlugin | ( | self | ) |
Definition at line 1982 of file parseConfig.py.
01982 : 01983 t=plugin.parseString("source = PoolSource { }") 01984 d=dict(iter(t)) 01985 self.assertEqual(type(d['source']),cms.Source) 01986 self.assertEqual(d['source'].type_(),"PoolSource") 01987 01988 t=plugin.parseString("source = PoolSource { }") 01989 d=dict(iter(t)) 01990 self.assertEqual(type(d['source']),cms.Source) 01991 self.assertEqual(d['source'].type_(),"PoolSource") 01992 01993 t=plugin.parseString("service = MessageLogger { }") 01994 d=dict(iter(t)) 01995 self.assertEqual(type(d['MessageLogger']),cms.Service) 01996 self.assertEqual(d['MessageLogger'].type_(),"MessageLogger") 01997 01998 t=plugin.parseString("module foo = FooMod { }") 01999 d=dict(iter(t)) 02000 self.assertEqual(type(d['foo']),cms.EDFilter) 02001 self.assertEqual(d['foo'].type_(),"FooMod") 02002 02003 t=plugin.parseString("module out = AsciiOutputModule { }") 02004 d=dict(iter(t)) 02005 self.assertEqual(type(d['out']),cms.OutputModule) 02006 self.assertEqual(d['out'].type_(),"AsciiOutputModule") 02007 02008 t=plugin.parseString("module foo = FooProd { }") 02009 d=dict(iter(t)) 02010 self.assertEqual(type(d['foo']),cms.EDProducer) 02011 self.assertEqual(d['foo'].type_(),"FooProd") 02012 02013 t=plugin.parseString("module foo = FooProducer { }") 02014 d=dict(iter(t)) 02015 self.assertEqual(type(d['foo']),cms.EDProducer) 02016 self.assertEqual(d['foo'].type_(),"FooProducer") 02017 02018 t=plugin.parseString("es_module = NoLabel {}") 02019 d=dict(iter(t)) 02020 self.assertEqual(type(d['NoLabel']),cms.ESProducer) 02021 self.assertEqual(d['NoLabel'].type_(),"NoLabel") 02022 02023 t=plugin.parseString("es_module foo = WithLabel {}") 02024 d=dict(iter(t)) 02025 self.assertEqual(type(d['foo']),cms.ESProducer) 02026 self.assertEqual(d['foo'].type_(),"WithLabel") 02027 02028 t=plugin.parseString("""module mix = MixingModule { 02029 secsource input = PoolRASource { 02030 vstring fileNames = {} 02031 } 02032 } 02033 """) 02034 global _fileFactory 02035 oldFactory = _fileFactory 02036 try: 02037 _fileFactory = TestFactory('Sub/Pack/data/foo.cfi', 'module foo = TestProd {}') 02038 t=plugin.parseString("module bar = foo from 'Sub/Pack/data/foo.cfi'") 02039 t = _findAndHandleProcessBlockIncludes(t) 02040 d = dict(iter(t)) 02041 self.assertEqual(type(d['bar']),cms.EDProducer) 02042 self.assertEqual(d['bar'].type_(),"TestProd") 02043 02044 02045 _fileFactory = TestFactory('Sub/Pack/data/foo.cfi', 'es_module foo = TestProd {}') 02046 t=plugin.parseString("es_module bar = foo from 'Sub/Pack/data/foo.cfi'") 02047 t = _findAndHandleProcessBlockIncludes(t) 02048 d=dict(iter(t)) 02049 self.assertEqual(type(d['bar']),cms.ESProducer) 02050 self.assertEqual(d['bar'].type_(),"TestProd") 02051 finally: 02052 _fileFactory = oldFactory 02053 02054 self.assertRaises(pp.ParseFatalException, 02055 plugin.parseString, 02056 ("""es_module foo = WithLabel { 02057 uint32 a = 1 02058 int32 a = 1 02059 }""")) def testProcess(self):
| def parseConfig::TestModuleCommand::testProcess | ( | self | ) |
Definition at line 2060 of file parseConfig.py.
02060 : 02061 global _allUsingLabels 02062 _allUsingLabels = set() 02063 t=process.parseString( 02064 """ 02065 process RECO = { 02066 source = PoolSource { 02067 untracked vstring fileNames = {"file:foo.root"} 02068 } 02069 module out = PoolOutputModule { 02070 untracked string fileName = "blah.root" 02071 } 02072 path p = {out} 02073 }""") 02074 self.assertEqual(t[0].source.type_(),"PoolSource") 02075 self.assertEqual(t[0].out.type_(),"PoolOutputModule") 02076 self.assertEqual(type(t[0].p),cms.Path) 02077 self.assertEqual(str(t[0].p),'out') 02078 #print t[0].dumpConfig() 02079 import StringIO 02080 global _fileFactory 02081 oldFactory = _fileFactory 02082 try: 02083 _fileFactory = TestFactory('Sub/Pack/data/foo.cfi', 02084 'module foo = FooProd {}') 02085 _allUsingLabels = set() 02086 t=process.parseString( 02087 """ 02088 process RECO = { 02089 source = PoolSource { 02090 untracked vstring fileNames = {"file:foo.root"} 02091 } 02092 include "Sub/Pack/data/foo.cfi" 02093 path p = {foo} 02094 }""") 02095 self.assertEqual(t[0].foo.type_(),"FooProd") 02096 finally: 02097 _fileFactory = oldFactory 02098 02099 _allUsingLabels = set() 02100 t=process.parseString( 02101 """ 02102 process RECO = { 02103 source = PoolSource { 02104 untracked vstring fileNames = {"file:foo.root"} 02105 } 02106 module out = PoolOutputModule { 02107 untracked string fileName = "blah.root" 02108 } 02109 endpath e = {out} 02110 module foo = FooProd {} 02111 module bar = BarProd {} 02112 module fii = FiiProd {} 02113 path p = {s&fii} 02114 sequence s = {foo,bar} 02115 }""") 02116 self.assertEqual(str(t[0].p),'foo*bar+fii') 02117 self.assertEqual(str(t[0].s),'foo*bar') 02118 t[0].dumpConfig() 02119 02120 _allUsingLabels = set() 02121 t=process.parseString( 02122 """ 02123 process RECO = { 02124 source = PoolSource { 02125 untracked vstring fileNames = {"file:foo.root"} 02126 } 02127 module out = PoolOutputModule { 02128 untracked string fileName = "blah.root" 02129 } 02130 endpath e = {out} 02131 module foo = FooProd {} 02132 module bar = BarProd {} 02133 module fii = FiiProd {} 02134 path p = {s&!fii} 02135 sequence s = {foo,bar} 02136 }""") 02137 self.assertEqual(str(t[0].p),'foo*bar+~fii') 02138 self.assertEqual(str(t[0].s),'foo*bar') 02139 t[0].dumpConfig() 02140 02141 s=""" 02142 process RECO = { 02143 module foo = FooProd {} 02144 path p = {fo} 02145 } 02146 """ 02147 self.assertRaises(RuntimeError,process.parseString,(s),**dict()) 02148 try: 02149 _allUsingLabels = set() 02150 t=process.parseString(s) 02151 except Exception, e: 02152 print e 02153 02154 _allUsingLabels = set() 02155 t=process.parseString(""" 02156 process RECO = { 02157 block outputStuff = { 02158 vstring outputCommands = {"drop *"} 02159 } 02160 block toKeep = { 02161 vstring outputCommands = {"keep blah_*_*_*"} 02162 } 02163 replace outputStuff.outputCommands += toKeep.outputCommands 02164 } 02165 """) 02166 self.assertEqual(t[0].outputStuff.outputCommands,["drop *","keep blah_*_*_*"]) 02167 02168 _allUsingLabels = set() 02169 t=process.parseString(""" 02170 process RECO = { 02171 module i = iterativeCone5CaloJets from "FWCore/ParameterSet/test/chainIncludeModule.cfi" 02172 } 02173 """) 02174 self.assertEqual(t[0].i.jetType.value(), "CaloJet") 02175 02176 02177 _allUsingLabels = set() 02178 t=process.parseString(""" 02179 process RECO = { 02180 include "FWCore/ParameterSet/test/chainIncludeBlock.cfi" 02181 replace CaloJetParameters.inputEMin = 0.1 02182 module i = iterativeConeNoBlock from "FWCore/ParameterSet/test/chainIncludeModule2.cfi" 02183 } 02184 """) 02185 self.assertEqual(t[0].i.jetType.value(), "CaloJet") 02186 self.assertEqual(t[0].i.inputEMin.value(), 0.1) 02187 02188 02189 02190 _allUsingLabels = set() 02191 t=process.parseString(""" 02192 process RECO = { 02193 block outputStuff = { 02194 vstring outputCommands = {"drop *"} 02195 } 02196 block toKeep1 = { 02197 vstring outputCommands = {"keep blah1_*_*_*"} 02198 } 02199 block toKeep2 = { 02200 vstring outputCommands = {"keep blah2_*_*_*"} 02201 } 02202 block toKeep3 = { 02203 vstring outputCommands = {"keep blah3_*_*_*"} 02204 } 02205 replace outputStuff.outputCommands += toKeep1.outputCommands 02206 replace outputStuff.outputCommands += toKeep2.outputCommands 02207 replace outputStuff.outputCommands += toKeep3.outputCommands 02208 } 02209 """) 02210 self.assertEqual(t[0].outputStuff.outputCommands,["drop *", 02211 "keep blah1_*_*_*", 02212 "keep blah2_*_*_*", 02213 "keep blah3_*_*_*"]) 02214 02215 _allUsingLabels = set() 02216 t=process.parseString(""" 02217 process RECO = { 02218 block outputStuff = { 02219 vstring outputCommands = {"drop *"} 02220 } 02221 block toKeep1 = { 02222 vstring outputCommands = {"keep blah1_*_*_*"} 02223 } 02224 block toKeep2 = { 02225 vstring outputCommands = {"keep blah2_*_*_*"} 02226 } 02227 block toKeep3 = { 02228 vstring outputCommands = {"keep blah3_*_*_*"} 02229 } 02230 replace outputStuff.outputCommands += toKeep1.outputCommands 02231 replace outputStuff.outputCommands += toKeep2.outputCommands 02232 replace outputStuff.outputCommands += toKeep3.outputCommands 02233 02234 module out = PoolOutputModule { 02235 using outputStuff 02236 } 02237 } 02238 """) 02239 self.assertEqual(t[0].out.outputCommands,["drop *", 02240 "keep blah1_*_*_*", 02241 "keep blah2_*_*_*", 02242 "keep blah3_*_*_*"]) 02243 t=process.parseString(""" 02244 process RECO = { 02245 block FEVTEventContent = { 02246 vstring outputCommands = {"drop *"} 02247 } 02248 block FEVTSIMEventContent = { 02249 vstring outputCommands = {"drop *"} 02250 } 02251 block toKeep1 = { 02252 vstring outputCommands = {"keep blah1_*_*_*"} 02253 } 02254 block toKeep2 = { 02255 vstring outputCommands = {"keep blah2_*_*_*"} 02256 } 02257 block toKeep3 = { 02258 vstring outputCommands = {"keep blah3_*_*_*"} 02259 } 02260 02261 block toKeepSim1 = { 02262 vstring outputCommands = {"keep blahs1_*_*_*"} 02263 } 02264 block toKeepSim2 = { 02265 vstring outputCommands = {"keep blahs2_*_*_*"} 02266 } 02267 block toKeepSim3 = { 02268 vstring outputCommands = {"keep blahs3_*_*_*"} 02269 } 02270 02271 replace FEVTEventContent.outputCommands += toKeep1.outputCommands 02272 replace FEVTEventContent.outputCommands += toKeep2.outputCommands 02273 replace FEVTEventContent.outputCommands += toKeep3.outputCommands 02274 02275 replace FEVTSIMEventContent.outputCommands += FEVTEventContent.outputCommands 02276 02277 replace FEVTSIMEventContent.outputCommands += toKeepSim1.outputCommands 02278 replace FEVTSIMEventContent.outputCommands += toKeepSim2.outputCommands 02279 replace FEVTSIMEventContent.outputCommands += toKeepSim3.outputCommands 02280 02281 } 02282 """) 02283 self.assertEqual(t[0].FEVTEventContent.outputCommands,["drop *", 02284 "keep blah1_*_*_*", 02285 "keep blah2_*_*_*", 02286 "keep blah3_*_*_*"]) 02287 02288 self.assertEqual(t[0].FEVTSIMEventContent.outputCommands,["drop *", 02289 "drop *", 02290 "keep blah1_*_*_*", 02291 "keep blah2_*_*_*", 02292 "keep blah3_*_*_*", 02293 "keep blahs1_*_*_*", 02294 "keep blahs2_*_*_*", 02295 "keep blahs3_*_*_*"]) 02296 02297 t=process.parseString(""" 02298 process RECO = { 02299 block FEVTEventContent = { 02300 vstring outputCommands = {"drop *"} 02301 } 02302 block FEVTSIMEventContent = { 02303 vstring outputCommands = {"drop *"} 02304 } 02305 block toKeep1 = { 02306 vstring outputCommands = {"keep blah1_*_*_*"} 02307 } 02308 block toKeep2 = { 02309 vstring outputCommands = {"keep blah2_*_*_*"} 02310 } 02311 block toKeep3 = { 02312 vstring outputCommands = {"keep blah3_*_*_*"} 02313 } 02314 02315 block toKeepSim1 = { 02316 vstring outputCommands = {"keep blahs1_*_*_*"} 02317 } 02318 block toKeepSim2 = { 02319 vstring outputCommands = {"keep blahs2_*_*_*"} 02320 } 02321 block toKeepSim3 = { 02322 vstring outputCommands = {"keep blahs3_*_*_*"} 02323 } 02324 02325 replace FEVTEventContent.outputCommands += toKeep1.outputCommands 02326 replace FEVTEventContent.outputCommands += toKeep2.outputCommands 02327 replace FEVTEventContent.outputCommands += toKeep3.outputCommands 02328 02329 replace FEVTSIMEventContent.outputCommands += FEVTEventContent.outputCommands 02330 02331 replace FEVTSIMEventContent.outputCommands += toKeepSim1.outputCommands 02332 replace FEVTSIMEventContent.outputCommands += toKeepSim2.outputCommands 02333 replace FEVTSIMEventContent.outputCommands += toKeepSim3.outputCommands 02334 02335 module out = PoolOutputModule { 02336 using FEVTSIMEventContent 02337 } 02338 } 02339 """) 02340 self.assertEqual(t[0].FEVTEventContent.outputCommands,["drop *", 02341 "keep blah1_*_*_*", 02342 "keep blah2_*_*_*", 02343 "keep blah3_*_*_*"]) 02344 02345 self.assertEqual(t[0].FEVTSIMEventContent.outputCommands,["drop *", 02346 "drop *", 02347 "keep blah1_*_*_*", 02348 "keep blah2_*_*_*", 02349 "keep blah3_*_*_*", 02350 "keep blahs1_*_*_*", 02351 "keep blahs2_*_*_*", 02352 "keep blahs3_*_*_*"]) 02353 self.assertEqual(t[0].out.outputCommands, 02354 t[0].FEVTSIMEventContent.outputCommands) 02355 02356 02357 #NOTE: standard cfg parser can't do the following 02358 _allUsingLabels = set() 02359 s=""" 02360 process RECO = { 02361 block outputStuff = { 02362 vstring outputCommands = {"drop *"} 02363 } 02364 block aTest = { 02365 vstring outputCommands = {"keep blah_*_*_*"} 02366 } 02367 block toKeep = { 02368 using aTest 02369 } 02370 replace outputStuff.outputCommands += toKeep.outputCommands 02371 } 02372 """ 02373 self.assertRaises(RuntimeError,process.parseString,(s),**dict()) 02374 #self.assertEqual(t[0].outputStuff.outputCommands,["drop *","keep blah_*_*_*"]) 02375 02376 _allUsingLabels = set() 02377 t=process.parseString(""" 02378 process RECO = { 02379 block outputStuff = { 02380 vstring outputCommands = {"drop *"} 02381 } 02382 block toKeep = { 02383 vstring outputCommands = {"keep blah_*_*_*"} 02384 } 02385 02386 block final = { 02387 using outputStuff 02388 } 02389 replace outputStuff.outputCommands += toKeep.outputCommands 02390 } 02391 """) 02392 self.assertEqual(t[0].outputStuff.outputCommands,["drop *","keep blah_*_*_*"]) 02393 self.assertEqual(t[0].final.outputCommands,["drop *","keep blah_*_*_*"]) 02394 02395 _allUsingLabels = set() 02396 t=process.parseString(""" 02397 process TEST = { 02398 service = MessageLogger { 02399 untracked vstring destinations = {"dummy"} 02400 untracked PSet default = { 02401 untracked int32 limit = -1 02402 } 02403 untracked PSet dummy = {} 02404 } 02405 replace MessageLogger.default.limit = 10 02406 replace MessageLogger.destinations += {"goofy"} 02407 replace MessageLogger.dummy = { untracked string threshold = "WARNING" } 02408 }""") 02409 self.assertEqual(t[0].MessageLogger.default.limit.value(),10) 02410 self.assertEqual(t[0].MessageLogger.destinations,["dummy","goofy"]) 02411 self.assertEqual(t[0].MessageLogger.dummy.threshold.value(),"WARNING") 02412 02413 _allUsingLabels = set() 02414 t=process.parseString(""" 02415 process TEST = { 02416 PSet first = { 02417 int32 foo = 1 02418 int32 fii = 2 02419 } 02420 02421 module second = AModule { 02422 using first 02423 } 02424 02425 replace first.foo = 2 02426 02427 replace second.fii = 3 02428 } 02429 """) 02430 self.assertEqual(t[0].first.foo.value(), 2) 02431 self.assertEqual(t[0].first.fii.value(),2) 02432 self.assertEqual(t[0].second.foo.value(),2) 02433 self.assertEqual(t[0].second.fii.value(),3) 02434 02435 _allUsingLabels = set() 02436 t=process.parseString(""" 02437 process TEST = { 02438 es_module = UnnamedProd { 02439 int32 foo = 10 02440 } 02441 02442 es_module me = NamedProd { 02443 int32 fii = 5 02444 } 02445 02446 replace UnnamedProd.foo = 1 02447 02448 replace me.fii = 10 02449 } 02450 """) 02451 self.assertEqual(t[0].UnnamedProd.foo.value(),1) 02452 self.assertEqual(t[0].me.fii.value(),10) 02453 02454 _allUsingLabels = set() 02455 t=process.parseString(""" 02456 process RECO = { 02457 block outputStuff = { 02458 vstring outputCommands = {"drop *"} 02459 } 02460 block toKeep = { 02461 vstring outputCommands = {"keep blah_*_*_*"} 02462 } 02463 replace outputStuff.outputCommands += toKeep.outputCommands 02464 02465 source = PoolSource { 02466 untracked vstring fileNames = {"file:foo.root"} 02467 untracked vint32 foos = {1} 02468 } 02469 module out = PoolOutputModule { 02470 using outputStuff 02471 untracked string fileName = "blah.root" 02472 } 02473 replace PoolSource.fileNames = {"file:bar.root"} 02474 replace out.fileName = 'blih.root' 02475 replace PoolSource.foos += 2 02476 replace PoolSource.foos += 3 02477 }""") 02478 self.assertEqual(t[0].source.fileNames,["file:bar.root"]) 02479 self.assertEqual(t[0].out.fileName.value(),"blih.root") 02480 self.assertEqual(t[0].source.foos,[1,2,3]) 02481 self.assertEqual(t[0].outputStuff.outputCommands,["drop *","keep blah_*_*_*"]) 02482 self.assertEqual(t[0].out.outputCommands,["drop *","keep blah_*_*_*"]) 02483 02484 _allUsingLabels = set() 02485 t=process.parseString(""" 02486 process RECO = { 02487 module foo = FooProd {using b} 02488 PSet b = {uint32 i = 1} 02489 PSet c = {using b} 02490 block p1 = { int32 x = 2 02491 int32 y = 9 02492 } 02493 PSet p2 = { using p1 } 02494 module m1 = MProd { using p2 } 02495 module m2 = MProd { using p2 } 02496 block b1 = {double y = 1.1 } 02497 block b2 = {double x = 2.2 } 02498 } 02499 """) 02500 self.assertEqual(t[0].foo.i.value(),1) 02501 self.assertEqual(t[0].c.i.value(),1) 02502 self.assert_(not hasattr(t[0].foo,'using_b') ) 02503 self.assertEqual(t[0].p2.x.value(),2) 02504 self.assertEqual(t[0].m1.x.value(),2) 02505 self.assertEqual(t[0].m2.x.value(),2) 02506 #print t[0].dumpConfig() 02507 02508 _allUsingLabels = set() 02509 s=""" 02510 process RECO = { 02511 module foo = FooProd {using b} 02512 PSet b = {using c} 02513 PSet c = {using b} 02514 } 02515 """ 02516 self.assertRaises(RuntimeError,process.parseString,(s),**dict()) 02517 02518 _allUsingLabels = set() 02519 s=""" 02520 process RECO = { 02521 module foo = FooProd {using b 02522 uint32 alreadyHere = 1 02523 } 02524 PSet b = {uint32 alreadyHere = 2} 02525 } 02526 """ 02527 self.assertRaises(RuntimeError,process.parseString,(s),**dict()) 02528 #this was failing because of order in which the using was applied 02529 02530 _allUsingLabels = set() 02531 t=process.parseString(""" 02532 process USER = 02533 { 02534 source = PoolInput 02535 { 02536 string filename = "here" 02537 } 02538 02539 block p1 = { 02540 int32 x = 2 02541 int32 y = 9 02542 } 02543 PSet p2 = { 02544 using p1 02545 } 02546 02547 module m1 = MidpointJetProducer 02548 { 02549 using p2 02550 } 02551 02552 module m2 = MidpointJetProducer 02553 { 02554 using p2 02555 } 02556 02557 block b1 = { double y = 1.1 } 02558 block b2 = { double x = 2.2 } 02559 02560 block G = { 02561 int32 g = 0 02562 } 02563 02564 block H = { 02565 using G 02566 } 02567 02568 block I = { 02569 using J 02570 } 02571 02572 block J = { 02573 int32 j = 0 02574 } 02575 02576 replace J.j = 1 02577 02578 module A = UnconfigurableModule { } 02579 module B = UnconfigurableModule { } 02580 module C = UnconfigurableModule { } 02581 module D = UnconfigurableModule { } 02582 module E = UnconfigurableModule { } 02583 module F = UnconfigurableModule { } 02584 module filter = UnconfigurableFilter { } 02585 02586 sequence s0a = { A} 02587 sequence s0b = { A,B} 02588 sequence s0c = { A&B} 02589 sequence s1 = { A,B&C,(D,E)&F } 02590 sequence s2 = { C&(A,B), m1,m2,s1 } 02591 sequence s3 = {s0a} 02592 02593 path t1 = { (A,B&C,D),s0a,filter } 02594 path t2 = { A,B,C,D } 02595 path t3 = {s3&F} 02596 endpath te = { A&B } 02597 02598 schedule = {t1,t2} 02599 02600 } 02601 """) 02602 self.assertEqual(t[0].p2.x.value(), 2) 02603 self.assertEqual(t[0].m1.x.value(),2) 02604 self.assertEqual(t[0].m2.x.value(),2) 02605 self.assertEqual(t[0].J.j.value(),1) 02606 self.assertEqual(t[0].I.j.value(),1) 02607 #make sure dump succeeds 02608 t[0].dumpConfig() 02609 02610 _allUsingLabels = set() 02611 t=process.parseString(""" 02612 process USER = 02613 { 02614 block a = {int32 i = 1} 02615 PSet b = {PSet c = {using a 02616 VPSet e={{using a} } } } 02617 VPSet d = {{using a}, {}} 02618 }""") 02619 self.assertEqual(t[0].b.c.i.value(),1) 02620 self.assertEqual(t[0].d[0].i.value(),1) 02621 self.assertEqual(t[0].b.c.e[0].i.value(), 1) 02622 #make sure dump succeeds 02623 t[0].dumpConfig() 02624 02625 _allUsingLabels = set() 02626 t=process.parseString(""" 02627 process USER = 02628 { 02629 block a = {int32 i = 1} 02630 PSet b = { PSet c = {} 02631 VPSet g = {} } 02632 replace b.c = {using a 02633 VPSet e={{using a} } } 02634 VPSet d = {{using a}, {}} 02635 }""") 02636 self.assertEqual(t[0].b.c.i.value(),1) 02637 self.assertEqual(t[0].d[0].i.value(),1) 02638 self.assertEqual(t[0].b.c.e[0].i.value(), 1) 02639 #make sure dump succeeds 02640 t[0].dumpConfig() 02641 02642 _allUsingLabels = set() 02643 t=process.parseString(""" 02644 process USER = 02645 { 02646 block a = {int32 i = 1} 02647 PSet b = { PSet c = {} } 02648 replace b.c = { PSet d = { using a } 02649 VPSet e={{using a} } } 02650 }""") 02651 self.assertEqual(t[0].b.c.d.i.value(),1) 02652 self.assertEqual(t[0].b.c.e[0].i.value(), 1) 02653 #make sure dump succeeds 02654 t[0].dumpConfig() 02655 02656 t=process.parseString(""" 02657 process USER = 02658 { 02659 block a = {int32 i = 1} 02660 module b = BWorker { PSet c = {} } 02661 replace b.c = { PSet d = { using a } 02662 VPSet e={{using a} } } 02663 }""") 02664 self.assertEqual(t[0].b.c.d.i.value(),1) 02665 self.assertEqual(t[0].b.c.e[0].i.value(), 1) 02666 #make sure dump succeeds 02667 t[0].dumpConfig() 02668 02669 t=process.parseString(""" 02670 process p = { 02671 02672 block roster = { 02673 string thirdBase = 'Some dude' 02674 PSet outfielders = { 02675 string rightField = 'Some dude' 02676 } 02677 } 02678 02679 module bums = Ballclub { 02680 using roster 02681 } 02682 02683 02684 module allstars = Ballclub { 02685 using roster 02686 } 02687 02688 replace allstars.thirdBase = 'Chuck Norris' 02689 replace allstars.outfielders.rightField = 'Babe Ruth' 02690 }""") 02691 self.assertEqual(t[0].bums.thirdBase.value(), 'Some dude') 02692 self.assertEqual(t[0].bums.outfielders.rightField.value(), 'Some dude') 02693 self.assertEqual(t[0].allstars.thirdBase.value(), 'Chuck Norris') 02694 self.assertEqual(t[0].allstars.outfielders.rightField.value(), 'Babe Ruth') 02695 02696 _allUsingLabels = set() 02697 02698 input= """process RECO = { 02699 es_prefer label = FooESProd { 02700 } 02701 es_module label = FooESProd { 02702 } 02703 }""" 02704 02705 t=process.parseString(input) 02706 self.assertEqual(t[0].label.type_(),"FooESProd") 02707 print t[0].dumpConfig() 02708 #self.checkRepr(t[0].dumpConfig(), input) 02709 _allUsingLabels = set() 02710 t=process.parseString( 02711 """ 02712 process RECO = { 02713 es_prefer = FooESProd { 02714 } 02715 es_module = FooESProd { 02716 } 02717 }""") 02718 self.assertEqual(t[0].FooESProd.type_(),"FooESProd") 02719 print t[0].dumpConfig() 02720 02721 def testPath(self):
| def parseConfig::TestModuleCommand::testReplace | ( | self | ) |
Definition at line 2821 of file parseConfig.py.
02821 : 02822 process = cms.Process("Test") 02823 process.a = cms.EDProducer('FooProd', b=cms.uint32(2)) 02824 t=replace.parseString('replace a.b = 1') 02825 self.assertEqual(t[0][0],'a.b') 02826 self.assertEqual(t[0][1].path, ['a','b']) 02827 self.assertEqual(t[0][1].value,'1') 02828 self.checkRepr(t[0][1], "a.b = 1") 02829 t[0][1].do(process) 02830 self.assertEqual(process.a.b.value(),1) 02831 #print t 02832 process = cms.Process("Test") 02833 process.a = cms.EDProducer('FooProd', b=cms.PSet(c=cms.double(2))) 02834 t=replace.parseString('replace a.b.c = 1') 02835 self.assertEqual(t[0][0],'a.b.c') 02836 self.assertEqual(t[0][1].path, ['a','b','c']) 02837 self.assertEqual(t[0][1].value,'1') 02838 self.checkRepr(t[0][1], "a.b.c = 1") 02839 self.assertEqual(type(process.a.b),cms.PSet) 02840 t[0][1].do(process) 02841 self.assertEqual(type(process.a.b),cms.PSet) 02842 self.assertEqual(process.a.b.c.value(),1.0) 02843 #print t 02844 t=replace.parseString('replace a.b.c = 1.359') 02845 self.assertEqual(t[0][0],'a.b.c') 02846 self.assertEqual(t[0][1].path, ['a','b','c']) 02847 self.assertEqual(t[0][1].value,'1.359') 02848 self.checkRepr(t[0][1], "a.b.c = 1.359") 02849 t[0][1].do(process) 02850 self.assertEqual(type(process.a.b),cms.PSet) 02851 self.assertEqual(process.a.b.c.value(),1.359) 02852 #print t 02853 process = cms.Process("Test") 02854 process.a = cms.EDProducer('FooProd', b=cms.untracked.PSet()) 02855 self.assertEqual(process.a.b.isTracked(),False) 02856 t=replace.parseString('replace a.b = {untracked string threshold ="DEBUG"}') 02857 t[0][1].do(process) 02858 self.assertEqual(type(process.a.b),cms.PSet) 02859 self.assertEqual(process.a.b.isTracked(),False) 02860 self.assertEqual(process.a.b.threshold.value(),"DEBUG") 02861 self.assertEqual(process.a.b.threshold.isTracked(),False) 02862 #print t 02863 process = cms.Process("Test") 02864 process.a = cms.EDProducer('FooProd', b=cms.PSet(c=cms.untracked.double(2))) 02865 self.assertEqual(process.a.b.c.value(),2.0) 02866 self.assertEqual(process.a.b.c.isTracked(),False) 02867 t=replace.parseString('replace a.b.c = 1') 02868 self.checkRepr(t[0][1], "a.b.c = 1") 02869 t[0][1].do(process) 02870 self.assertEqual(type(process.a.b),cms.PSet) 02871 self.assertEqual(process.a.b.c.value(),1.0) 02872 self.assertEqual(process.a.b.c.isTracked(),False) 02873 02874 t=replace.parseString('replace a.b = "all that"') 02875 self.assertEqual(t[0][0],'a.b') 02876 self.assertEqual(t[0][1].path, ['a','b']) 02877 self.assertEqual(t[0][1].value,'all that') 02878 process = cms.Process("Test") 02879 process.a = cms.EDProducer('FooProd', b=cms.string('thing')) 02880 self.checkRepr(t[0][1], "a.b = \'all that\'") 02881 t[0][1].do(process) 02882 self.assertEqual(process.a.b.value(),'all that') #print t 02883 02884 t=replace.parseString('replace a.b = {}') 02885 self.assertEqual(t[0][0],'a.b') 02886 self.assertEqual(t[0][1].path, ['a','b']) 02887 self.assertEqual(t[0][1].value,[]) 02888 self.checkRepr(t[0][1], "a.b = []") 02889 02890 #print t 02891 t=replace.parseString('replace a.b = {1, 3, 6}') 02892 self.assertEqual(t[0][0],'a.b') 02893 self.assertEqual(t[0][1].path, ['a','b']) 02894 self.assertEqual(t[0][1].value,['1','3','6']) 02895 process = cms.Process("Test") 02896 process.a = cms.EDProducer('FooProd', b=cms.vint32()) 02897 self.checkRepr(t[0][1], "a.b = [1, 3, 6]") 02898 02899 t[0][1].do(process) 02900 self.assertEqual(len(process.a.b),3) 02901 #print t 02902 t=replace.parseString('replace a.b = {"all", "that"}') 02903 self.assertEqual(t[0][0],'a.b') 02904 self.assertEqual(t[0][1].path, ['a','b']) 02905 self.assertEqual(t[0][1].value,['all','that']) 02906 self.checkRepr(t[0][1], "a.b = [\'all\', \'that\']") 02907 t=replace.parseString('replace a.b = {"all that"}') 02908 self.assertEqual(t[0][0],'a.b') 02909 self.assertEqual(t[0][1].path, ['a','b']) 02910 self.assertEqual(t[0][1].value,['all that']) 02911 02912 t=replace.parseString('replace a.b = { int32 i = 1 }') 02913 self.assertEqual(t[0][0],'a.b') 02914 self.assertEqual(t[0][1].path, ['a','b']) 02915 self.assertEqual(type(t[0][1].value),cms.PSet) 02916 self.assertEqual(t[0][1].value.i.value(), 1) 02917 self.checkRepr(t[0][1], "a.b = cms.PSet(i=cms.int32(1))") 02918 process = cms.Process("Test") 02919 process.a = cms.EDProducer('FooProd', b=cms.PSet(j=cms.uint32(5))) 02920 t[0][1].do(process) 02921 self.assertEqual(process.a.b.i.value(),1) 02922 self.assertEqual(getattr(process.a.b,'j',None),None) 02923 #print t 02924 # print t[0][1].value 02925 t=replace.parseString('replace a.b = { { int32 i = 1 } }') 02926 self.assertEqual(t[0][0],'a.b') 02927 self.assertEqual(t[0][1].path, ['a','b']) 02928 self.assertEqual(type(t[0][1].value),cms.VPSet) 02929 self.assertEqual(t[0][1].value[0].i.value(), 1) 02930 self.checkRepr(t[0][1], "a.b = cms.VPSet(cms.PSet(i=cms.int32(1)))") 02931 process = cms.Process("Test") 02932 process.a = cms.EDProducer('FooProd', b=cms.VPSet((cms.PSet(j=cms.uint32(5))))) 02933 t[0][1].do(process) 02934 self.assertEqual(process.a.b[0].i.value(),1) 02935 02936 process = cms.Process("Test") 02937 process.a = cms.EDProducer('FooProd', b=cms.vuint32(2)) 02938 t=replace.parseString('replace a.b += 1') 02939 self.assertEqual(t[0][0],'a.b') 02940 self.assertEqual(t[0][1].path, ['a','b']) 02941 self.assertEqual(t[0][1].value,'1') 02942 self.checkRepr(t[0][1], "a.b.append(1)") 02943 t[0][1].do(process) 02944 self.assertEqual(list(process.a.b),[2,1]) 02945 02946 process = cms.Process("Test") 02947 process.a = cms.EDProducer('FooProd', b=cms.vuint32(2)) 02948 t=replace.parseString('replace a.b += {1,3}') 02949 self.assertEqual(t[0][0],'a.b') 02950 self.assertEqual(t[0][1].path, ['a','b']) 02951 self.assertEqual(t[0][1].value,['1','3']) 02952 self.checkRepr(t[0][1], "a.b.extend([1,3])") 02953 t[0][1].do(process) 02954 self.assertEqual(list(process.a.b),[2,1,3]) 02955 02956 t=replace.parseString('replace a.b += "all that"') 02957 self.assertEqual(t[0][0],'a.b') 02958 self.assertEqual(t[0][1].path, ['a','b']) 02959 self.assertEqual(t[0][1].value,'all that') 02960 self.checkRepr(t[0][1], "a.b.append(\'all that\')") 02961 process = cms.Process("Test") 02962 process.a = cms.EDProducer('FooProd', b=cms.vstring('thing')) 02963 t[0][1].do(process) 02964 self.assertEqual(list(process.a.b),['thing','all that']) 02965 02966 t=replace.parseString('replace a.b += {"all that","and more"}') 02967 self.assertEqual(t[0][0],'a.b') 02968 self.assertEqual(t[0][1].path, ['a','b']) 02969 self.assertEqual(t[0][1].value,['all that','and more']) 02970 self.checkRepr(t[0][1], "a.b.extend([\'all that\', \'and more\'])") 02971 process = cms.Process("Test") 02972 process.a = cms.EDProducer('FooProd', b=cms.vstring('thing')) 02973 t[0][1].do(process) 02974 self.assertEqual(list(process.a.b),['thing','all that','and more']) 02975 02976 t=replace.parseString('replace a.b += { int32 i = 1 }') 02977 self.assertEqual(t[0][0],'a.b') 02978 self.assertEqual(t[0][1].path, ['a','b']) 02979 self.assertEqual(type(t[0][1].value),cms.PSet) 02980 self.assertEqual(t[0][1].value.i.value(), 1) 02981 self.checkRepr(t[0][1], "a.b.append(cms.PSet(i=cms.int32(1)))") 02982 process = cms.Process("Test") 02983 process.a = cms.EDProducer('FooProd', 02984 b=cms.VPSet((cms.PSet(j=cms.uint32(5))))) 02985 t[0][1].do(process) 02986 self.assertEqual(len(process.a.b),2) 02987 self.assertEqual(process.a.b[1].i.value(),1) 02988 02989 t=replace.parseString('replace a.b += { { int32 i = 1 } }') 02990 self.assertEqual(t[0][0],'a.b') 02991 self.assertEqual(t[0][1].path, ['a','b']) 02992 self.assertEqual(type(t[0][1].value),cms.VPSet) 02993 self.assertEqual(t[0][1].value[0].i.value(), 1) 02994 self.checkRepr(t[0][1], "a.b.extend(cms.VPSet(cms.PSet(i=cms.int32(1))))") 02995 process = cms.Process("Test") 02996 process.a = cms.EDProducer('FooProd', b=cms.VPSet((cms.PSet(j=cms.uint32(5))))) 02997 t[0][1].do(process) 02998 self.assertEqual(len(process.a.b),2) 02999 self.assertEqual(process.a.b[1].i.value(),1) 03000 03001 process = cms.Process("Test") 03002 process.a = cms.EDProducer('FooProd', b=cms.vuint32(2), c=cms.vuint32(1)) 03003 t=replace.parseString('replace a.b += a.c') 03004 self.assertEqual(t[0][0],'a.b') 03005 self.assertEqual(t[0][1].path, ['a','b']) 03006 self.assertEqual(t[0][1].value,'a.c') 03007 self.checkRepr(t[0][1], "a.b.append(process.a.c)") 03008 t[0][1].do(process) 03009 self.assertEqual(list(process.a.b),[2,1]) 03010 03011 process = cms.Process("Test") 03012 process.a = cms.EDProducer('FooProd', b=cms.vuint32(2), c=cms.uint32(1)) 03013 t=replace.parseString('replace a.b += a.c') 03014 self.assertEqual(t[0][0],'a.b') 03015 self.assertEqual(t[0][1].path, ['a','b']) 03016 self.assertEqual(t[0][1].value,'a.c') 03017 self.checkRepr(t[0][1], "a.b.append(process.a.c)") 03018 t[0][1].do(process) 03019 self.assertEqual(list(process.a.b),[2,1]) 03020 03021 process = cms.Process("Test") 03022 foobar = 'cms.InputTag("foobar","","")' 03023 fooRepr = 'foobar:' 03024 process.a = cms.EDProducer('FooProd', b=cms.InputTag("bar","")) 03025 t = replace.parseString('replace a.b = foobar:') 03026 self.checkRepr(t[0][1], "a.b ='foobar:'") 03027 t[0][1].do(process) 03028 self.assertEqual(process.a.b.configValue(),'foobar') 03029 03030 process = cms.Process("Test") 03031 process.a = cms.EDProducer('FooProd', b=cms.VInputTag((cms.InputTag("bar")))) 03032 t = replace.parseString('replace a.b = {foobar:}') 03033 self.checkRepr(t[0][1], "a.b = ['foobar:']") 03034 t[0][1].do(process) 03035 #self.assertEqual(process.a.b.configValue('',''),'{\nfoobar::\n}\n') 03036 self.assertEqual(list(process.a.b),[cms.InputTag('foobar')]) 03037 03038 process = cms.Process("Test") 03039 process.a = cms.EDProducer('FooProd', b=cms.VInputTag((cms.InputTag("bar")))) 03040 t = replace.parseString('replace a.b += {foobar:}') 03041 self.checkRepr(t[0][1], "a.b.extend(['foobar:'])") 03042 t[0][1].do(process) 03043 #self.assertEqual(process.a.b.configValue('',''),'{\nfoobar::\n}\n') 03044 self.assertEqual(list(process.a.b),[cms.InputTag("bar"),cms.InputTag('foobar')]) 03045 03046 process = cms.Process("Test") 03047 process.a = cms.EDProducer("FooProd", b = cms.uint32(1)) 03048 t = replace.parseString('replace a.c = 2') 03049 self.assertRaises(pp.ParseBaseException,t[0][1].do,(process)) 03050 03051 unittest.main() #try:
| def parseConfig::TestModuleCommand::testUsing | ( | self | ) |
Definition at line 1891 of file parseConfig.py.
01891 : 01892 #self.assertRaises(pp.ParseFatalException,onlyParameters.parseString,("PSet blah = {using ick}"),**dict()) 01893 t=onlyParameters.parseString("PSet blah = {using ick}") 01894 d=dict(iter(t)) 01895 self.assertEqual(type(d['blah']),cms.PSet) 01896 self.assertEqual(d['blah'].using_ick.value(), 'ick') def testInclude(self):
| def parseConfig::TestModuleCommand::testValidation | ( | self | ) |
Definition at line 1866 of file parseConfig.py.
01866 : 01867 self.assertRaises(pp.ParseFatalException,onlyParameters.parseString,(""" 01868 PSet blah = { 01869 int32 ick = 1 01870 int32 ick = 2 01871 }"""),**dict()) 01872 global _fileFactory 01873 oldFactory = _fileFactory 01874 try: 01875 _fileFactory = TestFactory('blah.cfi', 'int32 blah = 1') 01876 t=onlyParameters.parseString(""" 01877 PSet blah = { 01878 include "blah.cfi" 01879 include "blah.cfi" 01880 }""") 01881 d = dict(iter(t)) 01882 self.assertEqual(getattr(d['blah'],"blah").value(), 1) 01883 _fileFactory = TestFactory('blah.cfi', 'int32 blah = 1') 01884 self.assertRaises(pp.ParseFatalException,onlyParameters.parseString,(""" 01885 PSet blah = { 01886 include "blah.cfi" 01887 int32 blah = 2 01888 }"""),**dict()) 01889 finally: 01890 _fileFactory=oldFactory def testUsing(self):
1.5.4