|
6
|
1 # Copyright INRA (Institut National de la Recherche Agronomique)
|
|
|
2 # http://www.inra.fr
|
|
|
3 # http://urgi.versailles.inra.fr
|
|
|
4 #
|
|
|
5 # This software is governed by the CeCILL license under French law and
|
|
|
6 # abiding by the rules of distribution of free software. You can use,
|
|
|
7 # modify and/ or redistribute the software under the terms of the CeCILL
|
|
|
8 # license as circulated by CEA, CNRS and INRIA at the following URL
|
|
|
9 # "http://www.cecill.info".
|
|
|
10 #
|
|
|
11 # As a counterpart to the access to the source code and rights to copy,
|
|
|
12 # modify and redistribute granted by the license, users are provided only
|
|
|
13 # with a limited warranty and the software's author, the holder of the
|
|
|
14 # economic rights, and the successive licensors have only limited
|
|
|
15 # liability.
|
|
|
16 #
|
|
|
17 # In this respect, the user's attention is drawn to the risks associated
|
|
|
18 # with loading, using, modifying and/or developing or reproducing the
|
|
|
19 # software by the user in light of its specific status of free software,
|
|
|
20 # that may mean that it is complicated to manipulate, and that also
|
|
|
21 # therefore means that it is reserved for developers and experienced
|
|
|
22 # professionals having in-depth computer knowledge. Users are therefore
|
|
|
23 # encouraged to load and test the software's suitability as regards their
|
|
|
24 # requirements in conditions enabling the security of their systems and/or
|
|
|
25 # data to be ensured and, more generally, to use and operate it in the
|
|
|
26 # same conditions as regards security.
|
|
|
27 #
|
|
|
28 # The fact that you are presently reading this means that you have had
|
|
|
29 # knowledge of the CeCILL license and that you accept its terms.
|
|
|
30
|
|
|
31
|
|
|
32 import os
|
|
|
33 import sys
|
|
|
34 import unittest
|
|
|
35 import time
|
|
|
36 import shutil
|
|
|
37 from commons.core.utils.FileUtils import FileUtils
|
|
|
38
|
|
|
39
|
|
|
40 class Test_FileUtils( unittest.TestCase ):
|
|
|
41
|
|
|
42 def setUp( self ):
|
|
|
43 self._uniqId = "%s_%s" % ( time.strftime("%Y%m%d%H%M%S"), os.getpid() )
|
|
|
44
|
|
|
45 def tearDown( self ):
|
|
|
46 self._uniqId = ""
|
|
|
47
|
|
|
48 def test_getNbLinesInSingleFile_non_empty( self ):
|
|
|
49 file = "dummyFile_%s" % ( self._uniqId )
|
|
|
50 f = open( file, "w" )
|
|
|
51 f.write( "line1\n" )
|
|
|
52 f.write( "line2\n" )
|
|
|
53 f.write( "line3" )
|
|
|
54 f.close()
|
|
|
55 exp = 3
|
|
|
56 obs = FileUtils.getNbLinesInSingleFile( file )
|
|
|
57 self.assertEquals( exp, obs )
|
|
|
58 os.remove( file )
|
|
|
59
|
|
|
60 def test_getNbLinesInSingleFile_non_empty_endEmptyLine( self ):
|
|
|
61 file = "dummyFile_%s" % ( self._uniqId )
|
|
|
62 f = open( file, "w" )
|
|
|
63 f.write( "line1\n" )
|
|
|
64 f.write( "line2\n" )
|
|
|
65 f.write( "line3\n" )
|
|
|
66 f.write( "\n" )
|
|
|
67 f.close()
|
|
|
68 exp = 3
|
|
|
69 obs = FileUtils.getNbLinesInSingleFile( file )
|
|
|
70 self.assertEquals( exp, obs )
|
|
|
71 os.remove( file )
|
|
|
72
|
|
|
73 def test_getNbLinesInSingleFile_empty( self ):
|
|
|
74 file = "dummyFile_%s" % ( self._uniqId )
|
|
|
75 os.system( "touch %s" % ( file ) )
|
|
|
76 exp = 0
|
|
|
77 obs = FileUtils.getNbLinesInSingleFile( file )
|
|
|
78 self.assertEquals( exp, obs )
|
|
|
79 os.remove( file )
|
|
|
80
|
|
|
81 def test_getNbLinesInFileList_non_empty( self ):
|
|
|
82 f = open("dummy1.txt", "w")
|
|
|
83 f.write("line1\n")
|
|
|
84 f.write("line2\n")
|
|
|
85 f.write("line3")
|
|
|
86 f.close()
|
|
|
87 f = open("dummy2.txt", "w")
|
|
|
88 f.write("line1\n")
|
|
|
89 f.write("line2\n")
|
|
|
90 f.write("line3")
|
|
|
91 f.close()
|
|
|
92 f = open("dummy3.txt", "w")
|
|
|
93 f.write("line1\n")
|
|
|
94 f.write("line2\n")
|
|
|
95 f.write("line3")
|
|
|
96 f.close()
|
|
|
97 lFiles = [ "dummy1.txt", "dummy2.txt", "dummy3.txt" ]
|
|
|
98 exp = 9
|
|
|
99 obs = FileUtils.getNbLinesInFileList( lFiles )
|
|
|
100 self.assertEqual( exp, obs )
|
|
|
101 for f in lFiles:
|
|
|
102 os.remove( f )
|
|
|
103
|
|
|
104 def test_catFilesByPattern( self ):
|
|
|
105 f = open("dummy1.txt", "w")
|
|
|
106 f.write("line11\n")
|
|
|
107 f.write("line12\n")
|
|
|
108 f.write("line13")
|
|
|
109 f.close()
|
|
|
110 f = open("dummy2.txt", "w")
|
|
|
111 f.write("line21\n")
|
|
|
112 f.write("line22\n")
|
|
|
113 f.write("line23\n")
|
|
|
114 f.close()
|
|
|
115 f = open("dummy3.txt", "w")
|
|
|
116 f.write("line31\n")
|
|
|
117 f.write("line32\n")
|
|
|
118 f.write("line33")
|
|
|
119 f.close()
|
|
|
120 lFiles = [ "dummy1.txt", "dummy2.txt", "dummy3.txt" ]
|
|
|
121 outFile = "concatFiles.txt"
|
|
|
122 FileUtils.catFilesByPattern( "dummy*.txt", outFile )
|
|
|
123 self.assertTrue( os.path.exists( outFile ) )
|
|
|
124 exp = "line11\nline12\nline13line21\nline22\nline23\nline31\nline32\nline33"
|
|
|
125 obs = FileUtils.getFileContent( [ outFile ] )
|
|
|
126 self.assertEqual( exp, obs )
|
|
|
127 for f in lFiles:
|
|
|
128 os.remove( f )
|
|
|
129 os.remove(outFile)
|
|
|
130
|
|
|
131 def test_catFilesByPattern_with_headers( self ):
|
|
|
132 f = open("dummy1.txt", "w")
|
|
|
133 f.write("line11\n")
|
|
|
134 f.write("line12\n")
|
|
|
135 f.write("line13\n")
|
|
|
136 f.close()
|
|
|
137 f = open("dummy2.txt", "w")
|
|
|
138 f.write("line21\n")
|
|
|
139 f.write("line22\n")
|
|
|
140 f.write("line23\n")
|
|
|
141 f.close()
|
|
|
142 f = open("dummy3.txt", "w")
|
|
|
143 f.write("line31\n")
|
|
|
144 f.write("line32\n")
|
|
|
145 f.write("line33\n")
|
|
|
146 f.close()
|
|
|
147 lFiles = [ "dummy1.txt", "dummy2.txt", "dummy3.txt" ]
|
|
|
148 outFile = "concatFiles.txt"
|
|
|
149 FileUtils.catFilesByPattern( "dummy*.txt", outFile, skipHeaders = True)
|
|
|
150 self.assertTrue( os.path.exists( outFile ) )
|
|
|
151 exp = "line12\nline13\nline22\nline23\nline32\nline33\n"
|
|
|
152 obs = FileUtils.getFileContent( [ outFile ] )
|
|
|
153 self.assertEqual( exp, obs )
|
|
|
154 for f in lFiles:
|
|
|
155 os.remove( f )
|
|
|
156 os.remove(outFile)
|
|
|
157
|
|
|
158 def test_catFilesByPattern_with_separator( self ):
|
|
|
159 f = open("dummy1.txt", "w")
|
|
|
160 f.write("line11\n")
|
|
|
161 f.write("line12\n")
|
|
|
162 f.write("line13")
|
|
|
163 f.close()
|
|
|
164 f = open("dummy2.txt", "w")
|
|
|
165 f.write("line21\n")
|
|
|
166 f.write("line22\n")
|
|
|
167 f.write("line23\n")
|
|
|
168 f.close()
|
|
|
169 f = open("dummy3.txt", "w")
|
|
|
170 f.write("line31\n")
|
|
|
171 f.write("line32\n")
|
|
|
172 f.write("line33")
|
|
|
173 f.close()
|
|
|
174 lFiles = [ "dummy1.txt", "dummy2.txt", "dummy3.txt" ]
|
|
|
175 outFile = "concatFiles.txt"
|
|
|
176 FileUtils.catFilesByPattern( "dummy*.txt", outFile, separator = "\n+------------+\n")
|
|
|
177 self.assertTrue( os.path.exists( outFile ) )
|
|
|
178 exp = "line11\nline12\nline13\n+------------+\nline21\nline22\nline23\n\n+------------+\nline31\nline32\nline33"
|
|
|
179 obs = FileUtils.getFileContent( [ outFile ] )
|
|
|
180 self.assertEqual( exp, obs )
|
|
|
181 for f in lFiles:
|
|
|
182 os.remove( f )
|
|
|
183 os.remove(outFile)
|
|
|
184
|
|
|
185 def test_catFilesByPattern_with_headers_and_separator( self ):
|
|
|
186 f = open("dummy1.txt", "w")
|
|
|
187 f.write("line11\n")
|
|
|
188 f.write("line12\n")
|
|
|
189 f.write("line13\n")
|
|
|
190 f.close()
|
|
|
191 f = open("dummy2.txt", "w")
|
|
|
192 f.write("line21\n")
|
|
|
193 f.write("line22\n")
|
|
|
194 f.write("line23\n")
|
|
|
195 f.close()
|
|
|
196 f = open("dummy3.txt", "w")
|
|
|
197 f.write("line31\n")
|
|
|
198 f.write("line32\n")
|
|
|
199 f.write("line33\n")
|
|
|
200 f.close()
|
|
|
201 lFiles = [ "dummy1.txt", "dummy2.txt", "dummy3.txt" ]
|
|
|
202 outFile = "concatFiles.txt"
|
|
|
203 FileUtils.catFilesByPattern( "dummy*.txt", outFile, separator = "\n+------------+\n", skipHeaders = True)
|
|
|
204 self.assertTrue( os.path.exists( outFile ) )
|
|
|
205 exp = "line12\nline13\n\n+------------+\nline22\nline23\n\n+------------+\nline32\nline33\n"
|
|
|
206 obs = FileUtils.getFileContent( [ outFile ] )
|
|
|
207 self.assertEqual( exp, obs )
|
|
|
208 for f in lFiles:
|
|
|
209 os.remove( f )
|
|
|
210 os.remove(outFile)
|
|
|
211
|
|
|
212 def test_isRessourceExists_exists(self):
|
|
|
213 f = open("dummyFile.txt", "w")
|
|
|
214 f.close()
|
|
|
215 self.assertTrue(FileUtils.isRessourceExists("dummyFile.txt"))
|
|
|
216 os.system("rm dummyFile.txt")
|
|
|
217
|
|
|
218 def test_isRessourceExists_not_exists(self):
|
|
|
219 self.assertFalse(FileUtils.isRessourceExists("dummyFile.txt"))
|
|
|
220
|
|
|
221 def test_isEmpty_empty( self ):
|
|
|
222 file = "dummyFile_%s" % ( self._uniqId )
|
|
|
223 os.system( "touch %s" % ( file ) )
|
|
|
224 self.assertTrue( FileUtils.isEmpty( file ) )
|
|
|
225 os.remove( file )
|
|
|
226
|
|
|
227 def test_isEmpty_non_empty( self ):
|
|
|
228 file = "dummyFile_%s" % ( self._uniqId )
|
|
|
229 fileHandler = open( file, "w" )
|
|
|
230 fileHandler.write( "line1\n" )
|
|
|
231 fileHandler.close()
|
|
|
232 self.assertFalse( FileUtils.isEmpty( file ) )
|
|
|
233 os.remove( file )
|
|
|
234
|
|
|
235 def test_are2FilesIdentical_true( self ):
|
|
|
236 f = open("dummy1.txt", "w")
|
|
|
237 f.write("line11\n")
|
|
|
238 f.close()
|
|
|
239 f = open("dummy2.txt", "w")
|
|
|
240 f.write("line11\n")
|
|
|
241 f.close()
|
|
|
242 self.assertTrue( FileUtils.are2FilesIdentical( "dummy1.txt", "dummy2.txt" ) )
|
|
|
243 for f in [ "dummy1.txt", "dummy2.txt" ]:
|
|
|
244 os.remove( f )
|
|
|
245
|
|
|
246 def test_are2FilesIdentical_false( self ):
|
|
|
247 f = open("dummy1.txt", "w")
|
|
|
248 f.write("line11\n")
|
|
|
249 f.close()
|
|
|
250 f = open("dummy2.txt", "w")
|
|
|
251 f.write("line21\n")
|
|
|
252 f.close()
|
|
|
253 self.assertFalse( FileUtils.are2FilesIdentical( "dummy1.txt", "dummy2.txt" ) )
|
|
|
254 for f in [ "dummy1.txt", "dummy2.txt" ]:
|
|
|
255 os.remove( f )
|
|
|
256
|
|
|
257 def test_getFileContent( self ):
|
|
|
258 inFile = "dummyInFile_%s" % ( self._uniqId )
|
|
|
259 inFileHandler = open( inFile, "w" )
|
|
|
260 inFileHandler.write( "zgdfet\n" )
|
|
|
261 inFileHandler.write( "agdfet\n" )
|
|
|
262 inFileHandler.close()
|
|
|
263 exp = "zgdfet\n" + "agdfet\n"
|
|
|
264 obs = FileUtils.getFileContent( [ inFile ] )
|
|
|
265 self.assertEquals( exp, obs )
|
|
|
266 os.remove( inFile )
|
|
|
267
|
|
|
268 def test_sortFileContent( self ):
|
|
|
269 inFile = "dummyInFile_%s" % ( self._uniqId )
|
|
|
270 inFileHandler = open( inFile, "w" )
|
|
|
271 inFileHandler.write( "zgdfet\n" )
|
|
|
272 inFileHandler.write( "agdfet\n" )
|
|
|
273 inFileHandler.close()
|
|
|
274
|
|
|
275 expFile = "dummyExpFile_%s" % ( self._uniqId )
|
|
|
276 expFileHandler = open( expFile, "w" )
|
|
|
277 expFileHandler.write( "agdfet\n" )
|
|
|
278 expFileHandler.write( "zgdfet\n" )
|
|
|
279 expFileHandler.close()
|
|
|
280
|
|
|
281 FileUtils.sortFileContent( inFile )
|
|
|
282
|
|
|
283 self.assertTrue( FileUtils.are2FilesIdentical( expFile, inFile ) )
|
|
|
284 for f in [ inFile, expFile ]:
|
|
|
285 os.remove( f )
|
|
|
286
|
|
|
287 def test_removeFilesByPattern_prefix( self ):
|
|
|
288 fileName1 = "filetest.fa"
|
|
|
289 fileName2 = "test.fa.Nstretch.map"
|
|
|
290 fileName3 = "test.fa_cut"
|
|
|
291 os.system("touch %s" % fileName1)
|
|
|
292 os.system("touch %s" % fileName2)
|
|
|
293 os.system("touch %s" % fileName3)
|
|
|
294 FileUtils.removeFilesByPattern("test*")
|
|
|
295 self.assertTrue(os.path.exists(fileName1))
|
|
|
296 self.assertFalse(os.path.exists(fileName2))
|
|
|
297 self.assertFalse(os.path.exists(fileName3))
|
|
|
298 os.remove(fileName1)
|
|
|
299
|
|
|
300 def test_removeFilesByPattern_suffix( self ):
|
|
|
301 fileName1 = "filetest"
|
|
|
302 fileName2 = "test.fa.Nstretch.map"
|
|
|
303 fileName3 = "test.fa_cut"
|
|
|
304 os.system("touch %s" % fileName1)
|
|
|
305 os.system("touch %s" % fileName2)
|
|
|
306 os.system("touch %s" % fileName3)
|
|
|
307 FileUtils.removeFilesByPattern("*test")
|
|
|
308 self.assertFalse(os.path.exists(fileName1))
|
|
|
309 self.assertTrue(os.path.exists(fileName2))
|
|
|
310 self.assertTrue(os.path.exists(fileName3))
|
|
|
311 os.remove(fileName2)
|
|
|
312 os.remove(fileName3)
|
|
|
313
|
|
|
314 def test_removeFilesBySuffixList( self ):
|
|
|
315 tmpDir = "dummyDir_%s" % ( self._uniqId )
|
|
|
316 if not os.path.exists( tmpDir ):
|
|
|
317 os.mkdir( tmpDir )
|
|
|
318 commonPrefix = "dummyFile_%s" %( self._uniqId )
|
|
|
319 os.system( "touch %s/%s.fa" % ( tmpDir, commonPrefix ) )
|
|
|
320 os.system( "touch %s/%s.fa.Nstretch.map" % ( tmpDir, commonPrefix ) )
|
|
|
321 os.system( "touch %s/%s.fa_cut" % ( tmpDir, commonPrefix ) )
|
|
|
322 lSuffixes = [ ".Nstretch.map", "_cut" ]
|
|
|
323 FileUtils.removeFilesBySuffixList( tmpDir, lSuffixes )
|
|
|
324 self.assertTrue( os.path.exists( "%s/%s.fa" % ( tmpDir, commonPrefix ) ) )
|
|
|
325 self.assertFalse( os.path.exists( "%s/%s.fa.Nstretch.map" % ( tmpDir, commonPrefix ) ) )
|
|
|
326 self.assertFalse( os.path.exists( "%s/%s.fa_cut" % ( tmpDir, commonPrefix ) ) )
|
|
|
327 shutil.rmtree( tmpDir )
|
|
|
328
|
|
|
329 def test_removeRepeatedBlanks( self ):
|
|
|
330 inFileName = "dummyWithRepeatedBlanks.dum"
|
|
|
331 obsFileName = "dummyWithoutRepeatedBlanks.dum"
|
|
|
332 expFileName = "dummyExpWithoutRepeatedBlanks.dum"
|
|
|
333 self._writeFileWithRepeatedBlanks( inFileName )
|
|
|
334 self._writeFileWithoutRepeatedBlanks( expFileName )
|
|
|
335 FileUtils.removeRepeatedBlanks( inFileName, obsFileName )
|
|
|
336 self.assertTrue( FileUtils.are2FilesIdentical( expFileName, obsFileName ) )
|
|
|
337 for f in [ inFileName, expFileName, obsFileName ]:
|
|
|
338 os.remove( f )
|
|
|
339
|
|
|
340 def test_RemoveRepeatedBlanks_without_outfileName (self):
|
|
|
341 inFileName = "dummyWithRepeatedBlanks.dum"
|
|
|
342 expFileName = "dummyExpWithoutRepeatedBlanks.dum"
|
|
|
343 obsFileName = inFileName
|
|
|
344 self._writeFileWithRepeatedBlanks( inFileName )
|
|
|
345 self._writeFileWithoutRepeatedBlanks( expFileName )
|
|
|
346 FileUtils.removeRepeatedBlanks( inFileName )
|
|
|
347 self.assertTrue( FileUtils.are2FilesIdentical( expFileName, obsFileName ) )
|
|
|
348 for f in [ inFileName, expFileName ]:
|
|
|
349 os.remove( f )
|
|
|
350
|
|
|
351
|
|
|
352 def test_fromWindowsToUnixEof( self ):
|
|
|
353 inFile = "dummyInFile"
|
|
|
354 inFileHandler = open( inFile, "w" )
|
|
|
355 inFileHandler.write( "toto\r\n" )
|
|
|
356 inFileHandler.close()
|
|
|
357 expFile = "dummyExpFile"
|
|
|
358 expFileHandler = open( expFile, "w" )
|
|
|
359 expFileHandler.write( "toto\n" )
|
|
|
360 expFileHandler.close()
|
|
|
361 FileUtils.fromWindowsToUnixEof( inFile )
|
|
|
362 self.assertTrue( FileUtils.are2FilesIdentical( expFile, inFile ) )
|
|
|
363 for f in [ inFile, expFile ]:
|
|
|
364 os.remove( f )
|
|
|
365
|
|
|
366
|
|
|
367 def test_removeDuplicatedLines( self ):
|
|
|
368 inFile = "dummyInFile"
|
|
|
369 inFileHandler = open( inFile, "w" )
|
|
|
370 inFileHandler.write( "toto\n" )
|
|
|
371 inFileHandler.write( "titi\n" )
|
|
|
372 inFileHandler.write( "toto\n" )
|
|
|
373 inFileHandler.close()
|
|
|
374 expFile = "dummyExpFile"
|
|
|
375 expFileHandler = open( expFile, "w" )
|
|
|
376 expFileHandler.write( "toto\n" )
|
|
|
377 expFileHandler.write( "titi\n" )
|
|
|
378 expFileHandler.close()
|
|
|
379 FileUtils.removeDuplicatedLines( inFile )
|
|
|
380 self.assertTrue( FileUtils.are2FilesIdentical( expFile, inFile ) )
|
|
|
381 for f in [ inFile, expFile ]:
|
|
|
382 os.remove( f )
|
|
|
383
|
|
|
384
|
|
|
385 def test_writeLineListInFile( self ):
|
|
|
386 inFile = "dummyInFile"
|
|
|
387 lLines = [ "toto\n", "titi\n" ]
|
|
|
388 expFile = "dummyExpFile"
|
|
|
389 expFileHandler = open( expFile, "w" )
|
|
|
390 expFileHandler.write( "toto\n" )
|
|
|
391 expFileHandler.write( "titi\n" )
|
|
|
392 expFileHandler.close()
|
|
|
393 FileUtils.writeLineListInFile( inFile, lLines )
|
|
|
394 self.assertTrue( FileUtils.are2FilesIdentical( expFile, inFile ) )
|
|
|
395 for f in [ inFile, expFile ]:
|
|
|
396 os.remove( f )
|
|
|
397
|
|
|
398
|
|
|
399 def test_getAbsoluteDirectoryPathList(self):
|
|
|
400 currentDir = os.getcwd()
|
|
|
401 rootDir = currentDir + "/" + "dummy"
|
|
|
402 if os.path.exists( rootDir ):
|
|
|
403 shutil.rmtree(rootDir)
|
|
|
404 os.mkdir(rootDir)
|
|
|
405
|
|
|
406 os.mkdir(rootDir + "/" + "dummyDir1")
|
|
|
407 os.mkdir(rootDir + "/" + "dummyDir2")
|
|
|
408
|
|
|
409 expLDir = [rootDir + "/" + "dummyDir1", rootDir + "/" + "dummyDir2"]
|
|
|
410 obsLDir = FileUtils.getAbsoluteDirectoryPathList(rootDir)
|
|
|
411
|
|
|
412 expLDir.sort()
|
|
|
413 obsLDir.sort()
|
|
|
414 self.assertEquals(expLDir, obsLDir)
|
|
|
415
|
|
|
416 shutil.rmtree(rootDir + "/" + "dummyDir1")
|
|
|
417 shutil.rmtree(rootDir + "/" + "dummyDir2")
|
|
|
418 shutil.rmtree(rootDir)
|
|
|
419
|
|
|
420
|
|
|
421 def test_getAbsoluteDirectoryPathList_empty_dir(self):
|
|
|
422 currentDir = os.getcwd()
|
|
|
423 rootDir = currentDir + "/" + "dummy"
|
|
|
424 if os.path.exists( rootDir ):
|
|
|
425 shutil.rmtree(rootDir)
|
|
|
426 os.mkdir(rootDir)
|
|
|
427
|
|
|
428 expLDir = []
|
|
|
429 obsLDir = FileUtils.getAbsoluteDirectoryPathList(rootDir)
|
|
|
430
|
|
|
431 self.assertEquals(expLDir, obsLDir)
|
|
|
432
|
|
|
433 shutil.rmtree(rootDir)
|
|
|
434
|
|
|
435
|
|
|
436 def test_getSubListAccordingToPattern_match(self):
|
|
|
437 lPath = ["/home/repet/titi", "/pattern/test", "/patter/test", "/_patternic_/test", "/home/patternic/test", "/home/pattern", "pattern", ""]
|
|
|
438
|
|
|
439 expL = ["/pattern/test", "/_patternic_/test", "/home/patternic/test", "/home/pattern", "pattern"]
|
|
|
440 obsL = FileUtils.getSubListAccordingToPattern(lPath, "pattern")
|
|
|
441
|
|
|
442 self.assertEquals(expL, obsL)
|
|
|
443
|
|
|
444
|
|
|
445 def test_getSubListAccordingToPattern_not_match(self):
|
|
|
446 lPath = ["/home/repet/titi", "/pattern/test", "/patter/test", "/_patternic_/test", "/home/patternic/test", "/home/pattern", "pattern", ""]
|
|
|
447
|
|
|
448 expL = ["/home/repet/titi", "/patter/test", ""]
|
|
|
449 obsL = FileUtils.getSubListAccordingToPattern(lPath, "pattern", False)
|
|
|
450
|
|
|
451 self.assertEquals(expL, obsL)
|
|
|
452
|
|
|
453
|
|
|
454 def test_getFileNamesList(self):
|
|
|
455 currentDir = os.getcwd()
|
|
|
456 rootDir = currentDir + "/" + "dummy"
|
|
|
457 if os.path.exists( rootDir ):
|
|
|
458 shutil.rmtree(rootDir)
|
|
|
459 os.mkdir(rootDir)
|
|
|
460
|
|
|
461 directory = "testDir"
|
|
|
462 os.mkdir(rootDir + "/" + directory)
|
|
|
463 fileName1 = "dummyFile1.gff"
|
|
|
464 fullFileName1 = rootDir + "/" + directory + "/" + fileName1
|
|
|
465 file1 = open(fullFileName1, "w")
|
|
|
466 file1.close()
|
|
|
467 fileName2 = "dummyFile2.gff"
|
|
|
468 fullFileName2 = rootDir + "/" + directory + "/" + fileName2
|
|
|
469 file2 = open(fullFileName2, "w")
|
|
|
470 file2.close()
|
|
|
471
|
|
|
472 expLFiles = [fileName1, fileName2]
|
|
|
473 obsLFiles = FileUtils.getFileNamesList(rootDir + "/" + directory)
|
|
|
474
|
|
|
475 self.assertEquals(expLFiles, sorted(obsLFiles))
|
|
|
476
|
|
|
477 shutil.rmtree(rootDir)
|
|
|
478
|
|
|
479 def test_getFileNamesList_withPattern(self):
|
|
|
480 currentDir = os.getcwd()
|
|
|
481 rootDir = currentDir + "/" + "dummy"
|
|
|
482 if os.path.exists( rootDir ):
|
|
|
483 shutil.rmtree(rootDir)
|
|
|
484 os.mkdir(rootDir)
|
|
|
485
|
|
|
486 directory = "testDir"
|
|
|
487 os.mkdir(rootDir + "/" + directory)
|
|
|
488 fileName1 = "dummyFile1.gff"
|
|
|
489 fullFileName1 = rootDir + "/" + directory + "/" + fileName1
|
|
|
490 file1 = open(fullFileName1, "w")
|
|
|
491 file1.close()
|
|
|
492 fileName2 = "dummyFile2.gff"
|
|
|
493 fullFileName2 = rootDir + "/" + directory + "/" + fileName2
|
|
|
494 file2 = open(fullFileName2, "w")
|
|
|
495 file2.close()
|
|
|
496
|
|
|
497 expLFiles = [fileName1]
|
|
|
498 obsLFiles = FileUtils.getFileNamesList(rootDir + "/" + directory, "dummyFile1.*")
|
|
|
499
|
|
|
500 self.assertEquals(expLFiles, obsLFiles)
|
|
|
501
|
|
|
502 shutil.rmtree(rootDir)
|
|
|
503
|
|
|
504 def test_getFileNamesList_empty_dir(self):
|
|
|
505 currentDir = os.getcwd()
|
|
|
506 rootDir = currentDir + "/" + "dummy"
|
|
|
507 os.mkdir(rootDir)
|
|
|
508
|
|
|
509 directory = "testDir"
|
|
|
510 os.mkdir(rootDir + "/" + directory)
|
|
|
511
|
|
|
512 expLFiles = []
|
|
|
513 obsLFiles = FileUtils.getFileNamesList(rootDir + "/" + directory)
|
|
|
514
|
|
|
515 self.assertEquals(expLFiles, obsLFiles)
|
|
|
516
|
|
|
517 shutil.rmtree(rootDir)
|
|
|
518
|
|
|
519 def test_getMd5SecureHash( self ):
|
|
|
520 if "hashlib" in sys.modules:
|
|
|
521 inFile = "dummyInFile"
|
|
|
522 inFileHandler = open( inFile, "w" )
|
|
|
523 inFileHandler.write( "DLZIH17T63B;?" )
|
|
|
524 inFileHandler.close()
|
|
|
525 exp = "50d1e2ded8f03881f940f70226e2b986"
|
|
|
526 obs = FileUtils.getMd5SecureHash( inFile )
|
|
|
527 self.assertEqual( exp, obs )
|
|
|
528 os.remove( inFile )
|
|
|
529
|
|
|
530 def test_catFilesOfDir(self):
|
|
|
531 currentDir = os.getcwd()
|
|
|
532 rootDir = currentDir + "/" + "dummy"
|
|
|
533 if os.path.exists( rootDir ):
|
|
|
534 shutil.rmtree(rootDir)
|
|
|
535 os.mkdir(rootDir)
|
|
|
536
|
|
|
537 directory = "testDir"
|
|
|
538 os.mkdir(rootDir + "/" + directory)
|
|
|
539 fileName1 = "dummyFile1.gff"
|
|
|
540 fullFileName1 = rootDir + "/" + directory + "/" + fileName1
|
|
|
541 file1 = open(fullFileName1, "w")
|
|
|
542 file1.write("file1\n")
|
|
|
543 file1.close()
|
|
|
544 fileName2 = "dummyFile2.gff"
|
|
|
545 fullFileName2 = rootDir + "/" + directory + "/" + fileName2
|
|
|
546 file2 = open(fullFileName2, "w")
|
|
|
547 file2.write("file2\n")
|
|
|
548 file2.close()
|
|
|
549 obsFile = "obsFile"
|
|
|
550 expFile = "expFile"
|
|
|
551 expF = open(expFile, "w")
|
|
|
552 expF.write("file1\nfile2\n")
|
|
|
553 expF.close()
|
|
|
554 FileUtils.catFilesOfDir(rootDir + "/" + directory, obsFile)
|
|
|
555 self.assertTrue(FileUtils.are2FilesIdentical(expFile, obsFile))
|
|
|
556
|
|
|
557 shutil.rmtree(rootDir)
|
|
|
558 os.remove(expFile)
|
|
|
559 os.remove(obsFile)
|
|
|
560
|
|
|
561 def test_isSizeNotNull_True(self):
|
|
|
562 file = "dummyExpFile"
|
|
|
563 fileHandler = open( file, "w" )
|
|
|
564 fileHandler.write( "toto\n" )
|
|
|
565 fileHandler.write( "titi\n" )
|
|
|
566 fileHandler.close()
|
|
|
567 obsSize = FileUtils.isSizeNotNull(file)
|
|
|
568 self.assertTrue(obsSize)
|
|
|
569 os.remove(file)
|
|
|
570
|
|
|
571 def test_isSizeNotNull_False(self):
|
|
|
572 file = "dummyExpFile"
|
|
|
573 fileHandler = open( file, "w" )
|
|
|
574 fileHandler.close()
|
|
|
575 obsSize = FileUtils.isSizeNotNull(file)
|
|
|
576 self.assertFalse(obsSize)
|
|
|
577 os.remove(file)
|
|
|
578
|
|
|
579 def test_splitFileIntoNFiles_3_files(self):
|
|
|
580 inputFile = "dummy.txt"
|
|
|
581 obsFile1 = "dummy-1.txt"
|
|
|
582 obsFile2 = "dummy-2.txt"
|
|
|
583 obsFile3 = "dummy-3.txt"
|
|
|
584
|
|
|
585 f = open(inputFile, "w")
|
|
|
586 f.write("line1\n")
|
|
|
587 f.write("line2\n")
|
|
|
588 f.write("line3\n")
|
|
|
589 f.close()
|
|
|
590
|
|
|
591 exp1 = "line1\n"
|
|
|
592 exp2 = "line2\n"
|
|
|
593 exp3 = "line3\n"
|
|
|
594
|
|
|
595 FileUtils.splitFileIntoNFiles(inputFile, 3)
|
|
|
596
|
|
|
597 obs1 = open(obsFile1).read()
|
|
|
598 obs2 = open(obsFile2).read()
|
|
|
599 obs3 = open(obsFile3).read()
|
|
|
600
|
|
|
601 self.assertEqual(exp1, obs1)
|
|
|
602 self.assertEqual(exp2, obs2)
|
|
|
603 self.assertEqual(exp3, obs3)
|
|
|
604 self.assertFalse(FileUtils.isRessourceExists("dummy-4.txt"))
|
|
|
605 FileUtils.removeFilesByPattern("dummy*")
|
|
|
606
|
|
|
607 def test_splitFileIntoNFiles_2_files(self):
|
|
|
608 inputFile = "dummy.txt"
|
|
|
609 obsFile1 = "dummy-1.txt"
|
|
|
610 obsFile2 = "dummy-2.txt"
|
|
|
611
|
|
|
612 f = open(inputFile, "w")
|
|
|
613 f.write("line1\n")
|
|
|
614 f.write("line2\n")
|
|
|
615 f.write("line3\n")
|
|
|
616 f.close()
|
|
|
617
|
|
|
618 exp1 = "line1\nline2\n"
|
|
|
619 exp2 = "line3\n"
|
|
|
620
|
|
|
621 FileUtils.splitFileIntoNFiles(inputFile, 2)
|
|
|
622
|
|
|
623 obs1 = open(obsFile1).read()
|
|
|
624 obs2 = open(obsFile2).read()
|
|
|
625
|
|
|
626 self.assertEqual(exp1, obs1)
|
|
|
627 self.assertEqual(exp2, obs2)
|
|
|
628 self.assertFalse(FileUtils.isRessourceExists("dummy-3.txt"))
|
|
|
629 FileUtils.removeFilesByPattern("dummy*")
|
|
|
630
|
|
|
631 def test_splitFileIntoNFiles_one_file(self):
|
|
|
632 inputFile = "dummy.txt"
|
|
|
633 obsFile1 = "dummy-1.txt"
|
|
|
634
|
|
|
635 f = open(inputFile, "w")
|
|
|
636 f.write("line1\n")
|
|
|
637 f.write("line2\n")
|
|
|
638 f.write("line3\n")
|
|
|
639 f.close()
|
|
|
640
|
|
|
641 exp1 = "line1\nline2\nline3\n"
|
|
|
642
|
|
|
643 FileUtils.splitFileIntoNFiles(inputFile, 1)
|
|
|
644
|
|
|
645 obs1 = open(obsFile1).read()
|
|
|
646
|
|
|
647 self.assertEqual(exp1, obs1)
|
|
|
648 self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt"))
|
|
|
649 FileUtils.removeFilesByPattern("dummy*")
|
|
|
650
|
|
|
651 def test_splitFileIntoNFiles_more_file_than_lines(self):
|
|
|
652 inputFile = "dummy.txt"
|
|
|
653 obsFile1 = "dummy-1.txt"
|
|
|
654 obsFile2 = "dummy-2.txt"
|
|
|
655 obsFile3 = "dummy-3.txt"
|
|
|
656
|
|
|
657 f = open(inputFile, "w")
|
|
|
658 f.write("line1\n")
|
|
|
659 f.write("line2\n")
|
|
|
660 f.write("line3\n")
|
|
|
661 f.close()
|
|
|
662
|
|
|
663 exp1 = "line1\n"
|
|
|
664 exp2 = "line2\n"
|
|
|
665 exp3 = "line3\n"
|
|
|
666
|
|
|
667 FileUtils.splitFileIntoNFiles(inputFile, 10)
|
|
|
668
|
|
|
669 obs1 = open(obsFile1).read()
|
|
|
670 obs2 = open(obsFile2).read()
|
|
|
671 obs3 = open(obsFile3).read()
|
|
|
672
|
|
|
673 self.assertEqual(exp1, obs1)
|
|
|
674 self.assertEqual(exp2, obs2)
|
|
|
675 self.assertEqual(exp3, obs3)
|
|
|
676 self.assertFalse(FileUtils.isRessourceExists("dummy-4.txt"))
|
|
|
677 FileUtils.removeFilesByPattern("dummy*")
|
|
|
678
|
|
|
679 def test_splitFileIntoNFiles_empty_file(self):
|
|
|
680 inputFile = "dummy.txt"
|
|
|
681 obsFile1 = "dummy-1.txt"
|
|
|
682
|
|
|
683 os.system( "touch %s" % ( inputFile ) )
|
|
|
684
|
|
|
685 exp1 = ""
|
|
|
686
|
|
|
687 FileUtils.splitFileIntoNFiles(inputFile, 10)
|
|
|
688
|
|
|
689 obs1 = open(obsFile1).read()
|
|
|
690
|
|
|
691 self.assertEqual(exp1, obs1)
|
|
|
692 self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt"))
|
|
|
693 FileUtils.removeFilesByPattern("dummy*")
|
|
|
694
|
|
|
695 def test_splitFileIntoNFiles_0_file(self):
|
|
|
696 inputFile = "dummy.txt"
|
|
|
697 obsFile1 = "dummy-1.txt"
|
|
|
698
|
|
|
699 f = open(inputFile, "w")
|
|
|
700 f.write("line1\n")
|
|
|
701 f.write("line2\n")
|
|
|
702 f.write("line3\n")
|
|
|
703 f.close()
|
|
|
704
|
|
|
705 exp1 = "line1\nline2\nline3\n"
|
|
|
706
|
|
|
707 FileUtils.splitFileIntoNFiles(inputFile, 0)
|
|
|
708
|
|
|
709 obs1 = open(obsFile1).read()
|
|
|
710
|
|
|
711 self.assertEqual(exp1, obs1)
|
|
|
712 self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt"))
|
|
|
713 FileUtils.removeFilesByPattern("dummy*")
|
|
|
714
|
|
|
715 def test_splitFileAccordingToLineNumber_3_files(self):
|
|
|
716 inputFile = "dummy.txt"
|
|
|
717 obsFile1 = "dummy-1.txt"
|
|
|
718 obsFile2 = "dummy-2.txt"
|
|
|
719 obsFile3 = "dummy-3.txt"
|
|
|
720
|
|
|
721 f = open(inputFile, "w")
|
|
|
722 f.write("line1\n")
|
|
|
723 f.write("line2\n")
|
|
|
724 f.write("line3\n")
|
|
|
725 f.close()
|
|
|
726
|
|
|
727 exp1 = "line1\n"
|
|
|
728 exp2 = "line2\n"
|
|
|
729 exp3 = "line3\n"
|
|
|
730
|
|
|
731 FileUtils.splitFileAccordingToLineNumber(inputFile, 1)
|
|
|
732
|
|
|
733 obs1 = open(obsFile1).read()
|
|
|
734 obs2 = open(obsFile2).read()
|
|
|
735 obs3 = open(obsFile3).read()
|
|
|
736
|
|
|
737 self.assertEqual(exp1, obs1)
|
|
|
738 self.assertEqual(exp2, obs2)
|
|
|
739 self.assertEqual(exp3, obs3)
|
|
|
740 self.assertFalse(FileUtils.isRessourceExists("dummy-4.txt"))
|
|
|
741 FileUtils.removeFilesByPattern("dummy*")
|
|
|
742
|
|
|
743 def test_splitFileAccordingToLineNumber_2_files(self):
|
|
|
744 inputFile = "dummy.txt"
|
|
|
745 obsFile1 = "dummy-1.txt"
|
|
|
746 obsFile2 = "dummy-2.txt"
|
|
|
747
|
|
|
748 f = open(inputFile, "w")
|
|
|
749 f.write("line1\n")
|
|
|
750 f.write("line2\n")
|
|
|
751 f.write("line3\n")
|
|
|
752 f.close()
|
|
|
753
|
|
|
754 exp1 = "line1\nline2\n"
|
|
|
755 exp2 = "line3\n"
|
|
|
756
|
|
|
757 FileUtils.splitFileAccordingToLineNumber(inputFile, 2)
|
|
|
758
|
|
|
759 obs1 = open(obsFile1).read()
|
|
|
760 obs2 = open(obsFile2).read()
|
|
|
761
|
|
|
762 self.assertEqual(exp1, obs1)
|
|
|
763 self.assertEqual(exp2, obs2)
|
|
|
764 self.assertFalse(FileUtils.isRessourceExists("dummy-3.txt"))
|
|
|
765 FileUtils.removeFilesByPattern("dummy*")
|
|
|
766
|
|
|
767 def test_splitFileAccordingToLineNumber_one_file(self):
|
|
|
768 inputFile = "dummy.txt"
|
|
|
769 obsFile1 = "dummy-1.txt"
|
|
|
770
|
|
|
771 f = open(inputFile, "w")
|
|
|
772 f.write("line1\n")
|
|
|
773 f.write("line2\n")
|
|
|
774 f.write("line3\n")
|
|
|
775 f.close()
|
|
|
776
|
|
|
777 exp1 = "line1\nline2\nline3\n"
|
|
|
778
|
|
|
779 FileUtils.splitFileAccordingToLineNumber(inputFile, 3)
|
|
|
780
|
|
|
781 obs1 = open(obsFile1).read()
|
|
|
782
|
|
|
783 self.assertEqual(exp1, obs1)
|
|
|
784 self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt"))
|
|
|
785 FileUtils.removeFilesByPattern("dummy*")
|
|
|
786
|
|
|
787 def test_splitFileAccordingToLineNumber_more_maxLines_than_lines(self):
|
|
|
788 inputFile = "dummy.txt"
|
|
|
789 obsFile1 = "dummy-1.txt"
|
|
|
790
|
|
|
791 f = open(inputFile, "w")
|
|
|
792 f.write("line1\n")
|
|
|
793 f.write("line2\n")
|
|
|
794 f.write("line3\n")
|
|
|
795 f.close()
|
|
|
796
|
|
|
797 exp1 = "line1\nline2\nline3\n"
|
|
|
798
|
|
|
799 FileUtils.splitFileAccordingToLineNumber(inputFile, 10)
|
|
|
800
|
|
|
801 obs1 = open(obsFile1).read()
|
|
|
802
|
|
|
803 self.assertEqual(exp1, obs1)
|
|
|
804 self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt"))
|
|
|
805 FileUtils.removeFilesByPattern("dummy*")
|
|
|
806
|
|
|
807 def test_splitFileAccordingToLineNumber_empty_file(self):
|
|
|
808 inputFile = "dummy.txt"
|
|
|
809 obsFile1 = "dummy-1.txt"
|
|
|
810
|
|
|
811 os.system( "touch %s" % ( inputFile ) )
|
|
|
812
|
|
|
813 exp1 = ""
|
|
|
814
|
|
|
815 FileUtils.splitFileAccordingToLineNumber(inputFile, 10)
|
|
|
816
|
|
|
817 obs1 = open(obsFile1).read()
|
|
|
818
|
|
|
819 self.assertEqual(exp1, obs1)
|
|
|
820 self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt"))
|
|
|
821 FileUtils.removeFilesByPattern("dummy*")
|
|
|
822
|
|
|
823 def test_splitFileAccordingToLineNumber_0_lines(self):
|
|
|
824 inputFile = "dummy.txt"
|
|
|
825 obsFile1 = "dummy-1.txt"
|
|
|
826
|
|
|
827 f = open(inputFile, "w")
|
|
|
828 f.write("line1\n")
|
|
|
829 f.write("line2\n")
|
|
|
830 f.write("line3\n")
|
|
|
831 f.close()
|
|
|
832
|
|
|
833 exp1 = "line1\nline2\nline3\n"
|
|
|
834
|
|
|
835 FileUtils.splitFileAccordingToLineNumber(inputFile, 0)
|
|
|
836
|
|
|
837 obs1 = open(obsFile1).read()
|
|
|
838
|
|
|
839 self.assertEqual(exp1, obs1)
|
|
|
840 self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt"))
|
|
|
841 FileUtils.removeFilesByPattern("dummy*")
|
|
|
842
|
|
|
843 def _writeFile( self, fileName ):
|
|
|
844 inFile = open(fileName, 'w')
|
|
|
845 inFile.write(">Sequence_de_reference\n")
|
|
|
846 inFile.write("ATTTTGCAGTCTTATTCGAG-----GCCATTGCT\n")
|
|
|
847 inFile.write(">Lignee1_mismatch\n")
|
|
|
848 inFile.write("ATTTTGCAGACTTATTCGAG-----GCCATTGCT\n")
|
|
|
849 inFile.write(">Lignee2_insertion\n")
|
|
|
850 inFile.write("ATTTTGCAGTCTTATTCGAGATTACGCCATTGCT\n")
|
|
|
851 inFile.write(">Lignee3_deletion\n")
|
|
|
852 inFile.write("A---TGCAGTCTTATTCGAG-----GCCATTGCT\n")
|
|
|
853 inFile.close()
|
|
|
854
|
|
|
855 def _writeFileWithEmptyLine( self, fileName ):
|
|
|
856 fileWithEmptyLine = open(fileName, 'w')
|
|
|
857 fileWithEmptyLine.write(">Sequence_de_reference\n")
|
|
|
858 fileWithEmptyLine.write("ATTTTGCAGTCTTATTCGAG-----GCCATTGCT\n")
|
|
|
859 fileWithEmptyLine.write("\n\n")
|
|
|
860 fileWithEmptyLine.write(">Lignee1_mismatch\n")
|
|
|
861 fileWithEmptyLine.write("ATTTTGCAGACTTATTCGAG-----GCCATTGCT\n")
|
|
|
862 fileWithEmptyLine.write("\n\n")
|
|
|
863 fileWithEmptyLine.write(">Lignee2_insertion\n")
|
|
|
864 fileWithEmptyLine.write("ATTTTGCAGTCTTATTCGAGATTACGCCATTGCT\n")
|
|
|
865 fileWithEmptyLine.write("\n")
|
|
|
866 fileWithEmptyLine.write(">Lignee3_deletion\n")
|
|
|
867 fileWithEmptyLine.write("A---TGCAGTCTTATTCGAG-----GCCATTGCT\n")
|
|
|
868 fileWithEmptyLine.close()
|
|
|
869
|
|
|
870 def _writeFileWithRepeatedBlanks( self, fileName ):
|
|
|
871 fileWithRepeatedBlanks = open(fileName, 'w')
|
|
|
872 fileWithRepeatedBlanks.write(">Sequ ence_de _reference\n")
|
|
|
873 fileWithRepeatedBlanks.write("ATTTT GCAGTCTT TTCGAG- ----GCCATT GCT\n")
|
|
|
874 fileWithRepeatedBlanks.close()
|
|
|
875
|
|
|
876 def _writeFileWithoutRepeatedBlanks( self, fileName ):
|
|
|
877 fileWithoutRepeatedBlanks = open(fileName, 'w')
|
|
|
878 fileWithoutRepeatedBlanks.write(">Sequ ence_de _reference\n")
|
|
|
879 fileWithoutRepeatedBlanks.write("ATTTT GCAGTCTT TTCGAG- ----GCCATT GCT\n")
|
|
|
880 fileWithoutRepeatedBlanks.close()
|
|
|
881
|
|
|
882 test_suite = unittest.TestSuite()
|
|
|
883 test_suite.addTest( unittest.makeSuite( Test_FileUtils ) )
|
|
|
884 if __name__ == "__main__":
|
|
|
885 unittest.TextTestRunner(verbosity=2).run( test_suite )
|
