Mercurial > repos > yufei-luo > s_mart
comparison smart_toolShed/commons/core/utils/test/Test_FileUtils.py @ 0:e0f8dcca02ed
Uploaded S-MART tool. A toolbox manages RNA-Seq and ChIP-Seq data.
author | yufei-luo |
---|---|
date | Thu, 17 Jan 2013 10:52:14 -0500 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:e0f8dcca02ed |
---|---|
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 ) |