Mercurial > repos > yufei-luo > s_mart

comparison commons/core/utils/test/Test_FileUtils.py @ 6:769e306b7933

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Change the repository level.
author yufei-luo
date Fri, 18 Jan 2013 04:54:14 -0500
parents
children 94ab73e8a190
comparison
equal deleted inserted replaced
5:ea3082881bf8 6:769e306b7933
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 )