Source Code for Module medite.MediteAppli.test.test_MediteAppli

  1  # -*- coding: iso-8859-1 -*- 
  2  # Copyright 20003 - 2008: Julien Bourdaillet (julien.bourdaillet@lip6.fr), Jean-Gabriel Ganascia (jean-gabriel.ganascia@lip6.fr) 
  3  # This file is part of MEDITE. 
  4  # 
  5  #    MEDITE is free software; you can redistribute it and/or modify 
  6  #    it under the terms of the GNU General Public License as published by 
  7  #    the Free Software Foundation; either version 2 of the License, or 
  8  #    (at your option) any later version. 
  9  # 
 10  #    MEDITE is distributed in the hope that it will be useful, 
 11  #    but WITHOUT ANY WARRANTY; without even the implied warranty of 
 12  #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 13  #    GNU General Public License for more details. 
 14  # 
 15  #    You should have received a copy of the GNU General Public License 
 16  #    along with Foobar; if not, write to the Free Software 
 17  #    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA 
 18   
 19  import unittest, contract, logging, os, os.path 
 20  import MediteAppli.MediteAppli, MediteAppli.synthetic 
 21  import test_data 
 22  import Donnees.resultatAppli  
 23  import Donnees.planTravail 
 24  import Controleurs.cInformations, Controleurs.DGManager 
 25  # vérification des contrats 
 26  contract.checkmod(MediteAppli.MediteAppli) 
 27  contract.checkmod(Donnees.resultatAppli) 
 28   
 29 -class Test_MediteAppli(unittest.TestCase): 
 30           
 31 -    def setUp(self): 
 32          f = test_data.TestDataFactory() 
 33          #self.td = f.getTestData(test_data.ClaudeBernard,"2") 
 34          #self.td = f.getTestData(test_data.Traduction,"1") 
 35          #self.td = f.getTestData(test_data.Chedid,"1") 
 36          #self.td.texte1 = 'ABCDA' ; self.td.texte2 = 'ZADW' 
 37          #self.td = f.getTestData(test_data.Bovary,"1") 
 38          #self.td = f.getTestData(test_data.Verne,"1") 
 39          self.td = f.getTestData(test_data.Brousse,"1") 
 40          self.planTravail = Donnees.planTravail.PlanTravail('pAuteur', 'pOeuvre',  
 41              'pVS', 'pFS', 'pVC', 'pFC', Donnees.planTravail.Parametres()) 
 42 -    def test_ecartTextesRecur(self): 
 43          self.texte=self.td.gettexte1()+self.td.gettexte2() 
 44          self.et = MediteAppli.MediteAppli.ecartTextesRecur(self.td.gettexte1(),self.td.gettexte2(), 
 45              self.td.getp1(),self.td.getp2(),self.td.getp3(), 
 46              self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
 47              self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive()) 
 48          res = self.et.run() 
 49          self.__test_ecartTextesRecur(res) 
 50           
 51 -    def test_ecartTextesRecur2(self): 
 52          self.planTravail = Donnees.planTravail.PlanTravail('Traduction', 'Traduction',  
 53              'pVS', self.td.file1, 'pVC', self.td.file2, Donnees.planTravail.Parametres(self.td.getp1(), 
 54              self.td.getp2()*25,self.td.getp3()*1000,self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
 55              self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive())) 
 56          self.texte=self.td.gettexte1()+self.td.gettexte2() 
 57          self.et = MediteAppli.MediteAppli.ecartTextesRecur2(self.td.gettexte1(),self.td.gettexte2(), 
 58              self.td.getp1(),self.td.getp2(),self.td.getp3(), 
 59              self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
 60              self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive(), 
 61              self.planTravail) 
 62          dgm = Controleurs.DGManager.DGManager()             
 63          res = self.et.run(textesApparies=False, dossierRapport=dgm.getDG('Traduction', 'Traduction')) 
 64          #trace("res = self.et.run(textesApparies=True, dossierRapport=dgm.getDG('Traduction', 'Traduction'))",locals()) 
 65          #self.__test_ecartTextesRecur(res) 
 66          logging.debug('cinfos.enregistrerTransformations()') 
 67          cinfos = Controleurs.cInformations.CInformations(stream=True) 
 68          cinfos.enregistrerTransformations(self.planTravail,res) 
 69          self.et.xpNgram() 
 70          logging.debug('FIN')  
 71           
 72 -    def test_ecartTextesRecur3(self): 
 73          self.planTravail = Donnees.planTravail.PlanTravail('Traduction', 'Traduction',  
 74              'pVS', self.td.file1, 'pVC', self.td.file2, Donnees.planTravail.Parametres(self.td.getp1(), 
 75              self.td.getp2()*25,self.td.getp3()*1000,self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
 76              self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive())) 
 77          self.texte=self.td.gettexte1()+self.td.gettexte2() 
 78          self.et = MediteAppli.MediteAppli.ecartTextesRecur3(self.td.gettexte1(),self.td.gettexte2(), 
 79              self.td.getp1(),self.td.getp2(),self.td.getp3(), 
 80              self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
 81              self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive(), 
 82              self.planTravail) 
 83          dgm = Controleurs.DGManager.DGManager()             
 84          res = self.et.run(textesApparies=True, dossierRapport=dgm.getDG('Traduction', 'Traduction')) 
 85          #trace("res = self.et.run(textesApparies=True, dossierRapport=dgm.getDG('Traduction', 'Traduction'))",locals()) 
 86          #self.__test_ecartTextesRecur(res) 
 87          logging.debug('cinfos.enregistrerTransformations()') 
 88          cinfos = Controleurs.cInformations.CInformations(stream=True) 
 89          cinfos.enregistrerTransformations(self.planTravail,res) 
 90          logging.debug('FIN')  
 91           
 92 -    def test_ecartTextesRecur3Stream(self): 
 93          self.planTravail = Donnees.planTravail.PlanTravail('Traduction', 'Traduction',  
 94              'pVS', self.td.file1, 'pVC', self.td.file2, Donnees.planTravail.Parametres(self.td.getp1(), 
 95              self.td.getp2()*25,self.td.getp3()*1000,self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
 96              self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive())) 
 97          self.texte=self.td.gettexte1()+self.td.gettexte2() 
 98          self.et = MediteAppli.MediteAppli.ecartTextesRecur3(self.td.gettexte1(),self.td.gettexte2(), 
 99              self.td.getp1(),self.td.getp2(),self.td.getp3(), 
100              self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
101              self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive(), 
102              self.planTravail) 
103          dgm = Controleurs.DGManager.DGManager()             
104          #res = self.et.runStream(textesApparies=True, dossierRapport=dgm.getDG('Traduction', 'Traduction')) 
105          res = self.et.run(textesApparies=True, dossierRapport=dgm.getDG('Traduction', 'Traduction')) 
106          #trace("res = self.et.run(textesApparies=True, dossierRapport=dgm.getDG('Traduction', 'Traduction'))",locals()) 
107          #self.__test_ecartTextesRecur(res) 
108          #logging.debug('cinfos.enregistrerTransformations()') 
109          #cinfos = Controleurs.cInformations.CInformations(stream=True) 
110          #cinfos.enregistrerTransformations(self.planTravail,res) 
111           
112          logging.debug('FIN')  
113           
114 -    def test_ecartTextesRecur2diff(self): 
115          """Teste la difference symetrique entre la vieille facon de creer les dep et la nouvelle avec la bibloclist""" 
116          self.texte=self.td.gettexte1()+self.td.gettexte2() 
117          self.et = MediteAppli.MediteAppli.ecartTextesRecur2(self.td.gettexte1(),self.td.gettexte2(), 
118              self.td.getp1(),self.td.getp2(),self.td.getp3(), 
119              self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
120              self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive(), 
121              self.planTravail) 
122          res1 = self.et.run() 
123          res2 = self.et.run__() 
124          resDiffSym = res1 ^ res2 # xor ici différence symétrique par surcharge d'opérateurs 
125          rd1 = res1 - res2 
126          rd2 = res2 - res1 
127          print resDiffSym 
128          print resDiffSym.toString() 
129          print '---------------------------------' 
130          print rd1.toString() 
131          print '---------------------------------' 
132          print rd2.toString() 
133          print rd2 
134           
135 -    def __test_ecartTextesRecur(self,res): 
136          # teste que les elements d'une liste sont bien ordonnés entre eux         
137          self.__testOrdre(res.getListeSuppressions(),0,len(self.td.gettexte1())) 
138          self.__testOrdre(res.getListeInsertions(),len(self.td.gettexte1()),len(self.td.gettexte1())+len(self.td.gettexte2())) 
139          self.__testOrdre(res.getListeRemplacementsT1(),0,len(self.td.gettexte1())) 
140          self.__testOrdre(res.getListeRemplacementsT2(),len(self.td.gettexte1()),len(self.td.gettexte1())+len(self.td.gettexte2())) 
141          self.__testOrdre(res.getBlocsCommunsT1(),0,len(self.td.gettexte1())) 
142          self.__testOrdre(res.getBlocsCommunsT2(),len(self.td.gettexte1()),len(self.td.gettexte1())+len(self.td.gettexte2())) 
143          self.__testOrdre(res.getListeDeplacementsT1(),0,len(self.td.gettexte1())) 
144          self.__testOrdre(res.getListeDeplacementsT2(),len(self.td.gettexte1()),len(self.td.gettexte1())+len(self.td.gettexte2())) 
145   
146          # teste si il n'ya pas de recouvrements entre llistes 
147          self.__testRecouvrements(res.getBlocsCommuns(),res.getListeSuppressions()) 
148          self.__testRecouvrements(res.getBlocsCommuns(),res.getListeInsertions()) 
149          self.__testRecouvrements(res.getBlocsCommuns(),res.getListeRemplacements()) 
150          self.__testRecouvrements(res.getBlocsCommuns(),res.getListeDeplacements()) 
151          self.__testRecouvrements(res.getListeRemplacements(),res.getListeSuppressions()) 
152          self.__testRecouvrements(res.getListeRemplacements(),res.getListeInsertions()) 
153           
154 -    def __testOrdre(self,L1,d1,f1): 
155          if len(L1) == 0: return 
156          self.assert_(d1<=L1[0][0]<=L1[0][1]<=f1,str(L1[0])) 
157          for i in xrange(1,len(L1)): 
158              self.assert_(d1<=L1[i-1][1]<=L1[i][0]<=f1) 
159          self.assert_(d1<=L1[-1][0]<=L1[-1][1]<=f1) 
160           
161               
162 -    def __testRecouvrements(self,L1,L2): 
163          #res="" 
164          for (d1,f1) in L1: 
165              for (d2,f2) in L2: 
166                  self.assert_(not(d1<=d2<f1 or d2<=d1<f2),str((d1,f1))+str((d2,f2))+ 
167                      self.texte[d1:f1]+"/"+self.texte[d2:f2]) 
168                  #if (d1<=d2<f1 or d2<=d1<f2):  
169                  #    res+= str((d1,f1))+str((d2,f2))+self.texte[d1:f1]+"/"+self.texte[d2:f2] +"\n" 
170          #return res 
171             
172 -    def test_separator(self): 
173          self.texte=self.td.gettexte1()+self.td.gettexte2() 
174          #self.et = MediteAppli.MediteAppli.ecartTextesRecur(self.td.gettexte1(),self.td.gettexte2(), 
175          #    self.td.getp1(),self.td.getp2(),self.td.getp3(), 
176          #    self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
177          #    self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive()) 
178          self.et = MediteAppli.MediteAppli.ecartTextesRecur("ab.cd..e.....f","ab.cd.e", 
179              self.td.getp1(),self.td.getp2(),self.td.getp3(), 
180              self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
181              self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive())             
182          res = self.et.run() 
183           
184 -    def test_duplicateLinkage(self): 
185          import cPickle 
186          import MediteAppli.RecordLinkage as rl 
187          file_pickle = os.path.join(os.getcwd(),'test_MediteAppli_bbl.pkl') 
188          if os.path.isfile(file_pickle): 
189              pkl_file = open(file_pickle, 'rb') 
190              bbl = cPickle.load(pkl_file) 
191              pkl_file.close() 
192          else: 
193              f = test_data.TestDataFactory() 
194              self.td = f.getTestData(test_data.Resto,"1") 
195              self.planTravail = Donnees.planTravail.PlanTravail('Resto', 'Resto',  
196                  'pVS', self.td.file1, 'pVC', self.td.file2, Donnees.planTravail.Parametres(self.td.getp1(), 
197                  self.td.getp2()*25,self.td.getp3()*1000,self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
198                  self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive())) 
199              self.texte=self.td.gettexte1()+self.td.gettexte2() 
200              self.et = MediteAppli.MediteAppli.ecartTextesRecur2(self.td.gettexte1(),self.td.gettexte2(), 
201                  self.td.getp1(),self.td.getp2(),self.td.getp3(), self.td.getpcarOuMot(),self.td.getpcaseSensitive(), 
202                  self.td.getpseparatorSensivitive(),self.td.getpdiacriticSensitive(),self.planTravail) 
203              dgm = Controleurs.DGManager.DGManager()             
204              res = self.et.run(textesApparies=False) 
205              bbl = self.et.bbl 
206              output = open(file_pickle, 'wb') 
207              cPickle.dump(bbl, output) 
208              output.close() 
209              #trace("res = self.et.run(textesApparies=True, dossierRapport=dgm.getDG('Traduction', 'Traduction'))",locals()) 
210              #self.__test_ecartTextesRecur(res) 
211          dc = rl.DuplicateChecker(bbl) 
212          dc.run() 
213          logging.debug('FIN')  
214           
215 -def suite(): 
216      suite = unittest.TestSuite() 
217      #suite.addTest(Test_MediteAppli("test_ecartTextesRecur")) 
218      #suite.addTest(Test_MediteAppli("test_ecartTextesRecur2")) 
219      #suite.addTest(Test_MediteAppli("test_ecartTextesRecur3")) 
220      #suite.addTest(Test_MediteAppli("test_ecartTextesRecur3Stream")) 
221      #suite.addTest(Test_MediteAppli("test_ecartTextesRecur2diff")) 
222      #suite.addTest(Test_MediteAppli("test_separator")) 
223      suite.addTest(Test_MediteAppli("test_duplicateLinkage")) 
224      return suite 
225       
226 -def trace(commande,dic_locals): 
227      import hotshot,hotshot.stats,sys 
228      #import profile,pstats,sys 
229      #profile.runctx(commande,globals(), dic_locals,'c:\workspace\medite\statFile') 
230      #s = pstats.Stats('c:\workspace\medite\statFile') 
231      #s.sort_stats('time') 
232      #s.print_stats() 
233      #sys.stderr.flush() 
234      #sys.stdout.flush() 
235      prof = hotshot.Profile("c:\workspace\medite\statFile") 
236      benchtime = prof.runctx(commande,globals(), dic_locals) 
237      prof.close() 
238      stats = hotshot.stats.load("c:\workspace\medite\statFile") 
239      #stats.strip_dirs() 
240      stats.sort_stats('time', 'calls') 
241      stats.print_stats(50) 
242       
243  if __name__ == '__main__': 
244      logging.basicConfig(level=logging.DEBUG,#INFO, 
245                              format='%(asctime)s %(levelname)s %(message)s', 
246                              #datefmt='%H:%M:%S', 
247                              filename=os.path.join(os.getcwd(),'log.txt'), 
248                              filemode='w') 
249      console = logging.StreamHandler() 
250      console.setLevel(logging.INFO)   
251      #logging.getLogger('').addHandler(console) 
252       
253      unittest.TextTestRunner(verbosity=2).run(suite()) 
254