Mercurial > repos > yufei-luo > s_mart
diff commons/core/utils/test/Test_FileUtils.py @ 6:769e306b7933
Change the repository level.
author | yufei-luo |
---|---|
date | Fri, 18 Jan 2013 04:54:14 -0500 |
parents | |
children | 94ab73e8a190 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commons/core/utils/test/Test_FileUtils.py Fri Jan 18 04:54:14 2013 -0500 @@ -0,0 +1,885 @@ +# Copyright INRA (Institut National de la Recherche Agronomique) +# http://www.inra.fr +# http://urgi.versailles.inra.fr +# +# This software is governed by the CeCILL license under French law and +# abiding by the rules of distribution of free software. You can use, +# modify and/ or redistribute the software under the terms of the CeCILL +# license as circulated by CEA, CNRS and INRIA at the following URL +# "http://www.cecill.info". +# +# As a counterpart to the access to the source code and rights to copy, +# modify and redistribute granted by the license, users are provided only +# with a limited warranty and the software's author, the holder of the +# economic rights, and the successive licensors have only limited +# liability. +# +# In this respect, the user's attention is drawn to the risks associated +# with loading, using, modifying and/or developing or reproducing the +# software by the user in light of its specific status of free software, +# that may mean that it is complicated to manipulate, and that also +# therefore means that it is reserved for developers and experienced +# professionals having in-depth computer knowledge. Users are therefore +# encouraged to load and test the software's suitability as regards their +# requirements in conditions enabling the security of their systems and/or +# data to be ensured and, more generally, to use and operate it in the +# same conditions as regards security. +# +# The fact that you are presently reading this means that you have had +# knowledge of the CeCILL license and that you accept its terms. + + +import os +import sys +import unittest +import time +import shutil +from commons.core.utils.FileUtils import FileUtils + + +class Test_FileUtils( unittest.TestCase ): + + def setUp( self ): + self._uniqId = "%s_%s" % ( time.strftime("%Y%m%d%H%M%S"), os.getpid() ) + + def tearDown( self ): + self._uniqId = "" + + def test_getNbLinesInSingleFile_non_empty( self ): + file = "dummyFile_%s" % ( self._uniqId ) + f = open( file, "w" ) + f.write( "line1\n" ) + f.write( "line2\n" ) + f.write( "line3" ) + f.close() + exp = 3 + obs = FileUtils.getNbLinesInSingleFile( file ) + self.assertEquals( exp, obs ) + os.remove( file ) + + def test_getNbLinesInSingleFile_non_empty_endEmptyLine( self ): + file = "dummyFile_%s" % ( self._uniqId ) + f = open( file, "w" ) + f.write( "line1\n" ) + f.write( "line2\n" ) + f.write( "line3\n" ) + f.write( "\n" ) + f.close() + exp = 3 + obs = FileUtils.getNbLinesInSingleFile( file ) + self.assertEquals( exp, obs ) + os.remove( file ) + + def test_getNbLinesInSingleFile_empty( self ): + file = "dummyFile_%s" % ( self._uniqId ) + os.system( "touch %s" % ( file ) ) + exp = 0 + obs = FileUtils.getNbLinesInSingleFile( file ) + self.assertEquals( exp, obs ) + os.remove( file ) + + def test_getNbLinesInFileList_non_empty( self ): + f = open("dummy1.txt", "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3") + f.close() + f = open("dummy2.txt", "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3") + f.close() + f = open("dummy3.txt", "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3") + f.close() + lFiles = [ "dummy1.txt", "dummy2.txt", "dummy3.txt" ] + exp = 9 + obs = FileUtils.getNbLinesInFileList( lFiles ) + self.assertEqual( exp, obs ) + for f in lFiles: + os.remove( f ) + + def test_catFilesByPattern( self ): + f = open("dummy1.txt", "w") + f.write("line11\n") + f.write("line12\n") + f.write("line13") + f.close() + f = open("dummy2.txt", "w") + f.write("line21\n") + f.write("line22\n") + f.write("line23\n") + f.close() + f = open("dummy3.txt", "w") + f.write("line31\n") + f.write("line32\n") + f.write("line33") + f.close() + lFiles = [ "dummy1.txt", "dummy2.txt", "dummy3.txt" ] + outFile = "concatFiles.txt" + FileUtils.catFilesByPattern( "dummy*.txt", outFile ) + self.assertTrue( os.path.exists( outFile ) ) + exp = "line11\nline12\nline13line21\nline22\nline23\nline31\nline32\nline33" + obs = FileUtils.getFileContent( [ outFile ] ) + self.assertEqual( exp, obs ) + for f in lFiles: + os.remove( f ) + os.remove(outFile) + + def test_catFilesByPattern_with_headers( self ): + f = open("dummy1.txt", "w") + f.write("line11\n") + f.write("line12\n") + f.write("line13\n") + f.close() + f = open("dummy2.txt", "w") + f.write("line21\n") + f.write("line22\n") + f.write("line23\n") + f.close() + f = open("dummy3.txt", "w") + f.write("line31\n") + f.write("line32\n") + f.write("line33\n") + f.close() + lFiles = [ "dummy1.txt", "dummy2.txt", "dummy3.txt" ] + outFile = "concatFiles.txt" + FileUtils.catFilesByPattern( "dummy*.txt", outFile, skipHeaders = True) + self.assertTrue( os.path.exists( outFile ) ) + exp = "line12\nline13\nline22\nline23\nline32\nline33\n" + obs = FileUtils.getFileContent( [ outFile ] ) + self.assertEqual( exp, obs ) + for f in lFiles: + os.remove( f ) + os.remove(outFile) + + def test_catFilesByPattern_with_separator( self ): + f = open("dummy1.txt", "w") + f.write("line11\n") + f.write("line12\n") + f.write("line13") + f.close() + f = open("dummy2.txt", "w") + f.write("line21\n") + f.write("line22\n") + f.write("line23\n") + f.close() + f = open("dummy3.txt", "w") + f.write("line31\n") + f.write("line32\n") + f.write("line33") + f.close() + lFiles = [ "dummy1.txt", "dummy2.txt", "dummy3.txt" ] + outFile = "concatFiles.txt" + FileUtils.catFilesByPattern( "dummy*.txt", outFile, separator = "\n+------------+\n") + self.assertTrue( os.path.exists( outFile ) ) + exp = "line11\nline12\nline13\n+------------+\nline21\nline22\nline23\n\n+------------+\nline31\nline32\nline33" + obs = FileUtils.getFileContent( [ outFile ] ) + self.assertEqual( exp, obs ) + for f in lFiles: + os.remove( f ) + os.remove(outFile) + + def test_catFilesByPattern_with_headers_and_separator( self ): + f = open("dummy1.txt", "w") + f.write("line11\n") + f.write("line12\n") + f.write("line13\n") + f.close() + f = open("dummy2.txt", "w") + f.write("line21\n") + f.write("line22\n") + f.write("line23\n") + f.close() + f = open("dummy3.txt", "w") + f.write("line31\n") + f.write("line32\n") + f.write("line33\n") + f.close() + lFiles = [ "dummy1.txt", "dummy2.txt", "dummy3.txt" ] + outFile = "concatFiles.txt" + FileUtils.catFilesByPattern( "dummy*.txt", outFile, separator = "\n+------------+\n", skipHeaders = True) + self.assertTrue( os.path.exists( outFile ) ) + exp = "line12\nline13\n\n+------------+\nline22\nline23\n\n+------------+\nline32\nline33\n" + obs = FileUtils.getFileContent( [ outFile ] ) + self.assertEqual( exp, obs ) + for f in lFiles: + os.remove( f ) + os.remove(outFile) + + def test_isRessourceExists_exists(self): + f = open("dummyFile.txt", "w") + f.close() + self.assertTrue(FileUtils.isRessourceExists("dummyFile.txt")) + os.system("rm dummyFile.txt") + + def test_isRessourceExists_not_exists(self): + self.assertFalse(FileUtils.isRessourceExists("dummyFile.txt")) + + def test_isEmpty_empty( self ): + file = "dummyFile_%s" % ( self._uniqId ) + os.system( "touch %s" % ( file ) ) + self.assertTrue( FileUtils.isEmpty( file ) ) + os.remove( file ) + + def test_isEmpty_non_empty( self ): + file = "dummyFile_%s" % ( self._uniqId ) + fileHandler = open( file, "w" ) + fileHandler.write( "line1\n" ) + fileHandler.close() + self.assertFalse( FileUtils.isEmpty( file ) ) + os.remove( file ) + + def test_are2FilesIdentical_true( self ): + f = open("dummy1.txt", "w") + f.write("line11\n") + f.close() + f = open("dummy2.txt", "w") + f.write("line11\n") + f.close() + self.assertTrue( FileUtils.are2FilesIdentical( "dummy1.txt", "dummy2.txt" ) ) + for f in [ "dummy1.txt", "dummy2.txt" ]: + os.remove( f ) + + def test_are2FilesIdentical_false( self ): + f = open("dummy1.txt", "w") + f.write("line11\n") + f.close() + f = open("dummy2.txt", "w") + f.write("line21\n") + f.close() + self.assertFalse( FileUtils.are2FilesIdentical( "dummy1.txt", "dummy2.txt" ) ) + for f in [ "dummy1.txt", "dummy2.txt" ]: + os.remove( f ) + + def test_getFileContent( self ): + inFile = "dummyInFile_%s" % ( self._uniqId ) + inFileHandler = open( inFile, "w" ) + inFileHandler.write( "zgdfet\n" ) + inFileHandler.write( "agdfet\n" ) + inFileHandler.close() + exp = "zgdfet\n" + "agdfet\n" + obs = FileUtils.getFileContent( [ inFile ] ) + self.assertEquals( exp, obs ) + os.remove( inFile ) + + def test_sortFileContent( self ): + inFile = "dummyInFile_%s" % ( self._uniqId ) + inFileHandler = open( inFile, "w" ) + inFileHandler.write( "zgdfet\n" ) + inFileHandler.write( "agdfet\n" ) + inFileHandler.close() + + expFile = "dummyExpFile_%s" % ( self._uniqId ) + expFileHandler = open( expFile, "w" ) + expFileHandler.write( "agdfet\n" ) + expFileHandler.write( "zgdfet\n" ) + expFileHandler.close() + + FileUtils.sortFileContent( inFile ) + + self.assertTrue( FileUtils.are2FilesIdentical( expFile, inFile ) ) + for f in [ inFile, expFile ]: + os.remove( f ) + + def test_removeFilesByPattern_prefix( self ): + fileName1 = "filetest.fa" + fileName2 = "test.fa.Nstretch.map" + fileName3 = "test.fa_cut" + os.system("touch %s" % fileName1) + os.system("touch %s" % fileName2) + os.system("touch %s" % fileName3) + FileUtils.removeFilesByPattern("test*") + self.assertTrue(os.path.exists(fileName1)) + self.assertFalse(os.path.exists(fileName2)) + self.assertFalse(os.path.exists(fileName3)) + os.remove(fileName1) + + def test_removeFilesByPattern_suffix( self ): + fileName1 = "filetest" + fileName2 = "test.fa.Nstretch.map" + fileName3 = "test.fa_cut" + os.system("touch %s" % fileName1) + os.system("touch %s" % fileName2) + os.system("touch %s" % fileName3) + FileUtils.removeFilesByPattern("*test") + self.assertFalse(os.path.exists(fileName1)) + self.assertTrue(os.path.exists(fileName2)) + self.assertTrue(os.path.exists(fileName3)) + os.remove(fileName2) + os.remove(fileName3) + + def test_removeFilesBySuffixList( self ): + tmpDir = "dummyDir_%s" % ( self._uniqId ) + if not os.path.exists( tmpDir ): + os.mkdir( tmpDir ) + commonPrefix = "dummyFile_%s" %( self._uniqId ) + os.system( "touch %s/%s.fa" % ( tmpDir, commonPrefix ) ) + os.system( "touch %s/%s.fa.Nstretch.map" % ( tmpDir, commonPrefix ) ) + os.system( "touch %s/%s.fa_cut" % ( tmpDir, commonPrefix ) ) + lSuffixes = [ ".Nstretch.map", "_cut" ] + FileUtils.removeFilesBySuffixList( tmpDir, lSuffixes ) + self.assertTrue( os.path.exists( "%s/%s.fa" % ( tmpDir, commonPrefix ) ) ) + self.assertFalse( os.path.exists( "%s/%s.fa.Nstretch.map" % ( tmpDir, commonPrefix ) ) ) + self.assertFalse( os.path.exists( "%s/%s.fa_cut" % ( tmpDir, commonPrefix ) ) ) + shutil.rmtree( tmpDir ) + + def test_removeRepeatedBlanks( self ): + inFileName = "dummyWithRepeatedBlanks.dum" + obsFileName = "dummyWithoutRepeatedBlanks.dum" + expFileName = "dummyExpWithoutRepeatedBlanks.dum" + self._writeFileWithRepeatedBlanks( inFileName ) + self._writeFileWithoutRepeatedBlanks( expFileName ) + FileUtils.removeRepeatedBlanks( inFileName, obsFileName ) + self.assertTrue( FileUtils.are2FilesIdentical( expFileName, obsFileName ) ) + for f in [ inFileName, expFileName, obsFileName ]: + os.remove( f ) + + def test_RemoveRepeatedBlanks_without_outfileName (self): + inFileName = "dummyWithRepeatedBlanks.dum" + expFileName = "dummyExpWithoutRepeatedBlanks.dum" + obsFileName = inFileName + self._writeFileWithRepeatedBlanks( inFileName ) + self._writeFileWithoutRepeatedBlanks( expFileName ) + FileUtils.removeRepeatedBlanks( inFileName ) + self.assertTrue( FileUtils.are2FilesIdentical( expFileName, obsFileName ) ) + for f in [ inFileName, expFileName ]: + os.remove( f ) + + + def test_fromWindowsToUnixEof( self ): + inFile = "dummyInFile" + inFileHandler = open( inFile, "w" ) + inFileHandler.write( "toto\r\n" ) + inFileHandler.close() + expFile = "dummyExpFile" + expFileHandler = open( expFile, "w" ) + expFileHandler.write( "toto\n" ) + expFileHandler.close() + FileUtils.fromWindowsToUnixEof( inFile ) + self.assertTrue( FileUtils.are2FilesIdentical( expFile, inFile ) ) + for f in [ inFile, expFile ]: + os.remove( f ) + + + def test_removeDuplicatedLines( self ): + inFile = "dummyInFile" + inFileHandler = open( inFile, "w" ) + inFileHandler.write( "toto\n" ) + inFileHandler.write( "titi\n" ) + inFileHandler.write( "toto\n" ) + inFileHandler.close() + expFile = "dummyExpFile" + expFileHandler = open( expFile, "w" ) + expFileHandler.write( "toto\n" ) + expFileHandler.write( "titi\n" ) + expFileHandler.close() + FileUtils.removeDuplicatedLines( inFile ) + self.assertTrue( FileUtils.are2FilesIdentical( expFile, inFile ) ) + for f in [ inFile, expFile ]: + os.remove( f ) + + + def test_writeLineListInFile( self ): + inFile = "dummyInFile" + lLines = [ "toto\n", "titi\n" ] + expFile = "dummyExpFile" + expFileHandler = open( expFile, "w" ) + expFileHandler.write( "toto\n" ) + expFileHandler.write( "titi\n" ) + expFileHandler.close() + FileUtils.writeLineListInFile( inFile, lLines ) + self.assertTrue( FileUtils.are2FilesIdentical( expFile, inFile ) ) + for f in [ inFile, expFile ]: + os.remove( f ) + + + def test_getAbsoluteDirectoryPathList(self): + currentDir = os.getcwd() + rootDir = currentDir + "/" + "dummy" + if os.path.exists( rootDir ): + shutil.rmtree(rootDir) + os.mkdir(rootDir) + + os.mkdir(rootDir + "/" + "dummyDir1") + os.mkdir(rootDir + "/" + "dummyDir2") + + expLDir = [rootDir + "/" + "dummyDir1", rootDir + "/" + "dummyDir2"] + obsLDir = FileUtils.getAbsoluteDirectoryPathList(rootDir) + + expLDir.sort() + obsLDir.sort() + self.assertEquals(expLDir, obsLDir) + + shutil.rmtree(rootDir + "/" + "dummyDir1") + shutil.rmtree(rootDir + "/" + "dummyDir2") + shutil.rmtree(rootDir) + + + def test_getAbsoluteDirectoryPathList_empty_dir(self): + currentDir = os.getcwd() + rootDir = currentDir + "/" + "dummy" + if os.path.exists( rootDir ): + shutil.rmtree(rootDir) + os.mkdir(rootDir) + + expLDir = [] + obsLDir = FileUtils.getAbsoluteDirectoryPathList(rootDir) + + self.assertEquals(expLDir, obsLDir) + + shutil.rmtree(rootDir) + + + def test_getSubListAccordingToPattern_match(self): + lPath = ["/home/repet/titi", "/pattern/test", "/patter/test", "/_patternic_/test", "/home/patternic/test", "/home/pattern", "pattern", ""] + + expL = ["/pattern/test", "/_patternic_/test", "/home/patternic/test", "/home/pattern", "pattern"] + obsL = FileUtils.getSubListAccordingToPattern(lPath, "pattern") + + self.assertEquals(expL, obsL) + + + def test_getSubListAccordingToPattern_not_match(self): + lPath = ["/home/repet/titi", "/pattern/test", "/patter/test", "/_patternic_/test", "/home/patternic/test", "/home/pattern", "pattern", ""] + + expL = ["/home/repet/titi", "/patter/test", ""] + obsL = FileUtils.getSubListAccordingToPattern(lPath, "pattern", False) + + self.assertEquals(expL, obsL) + + + def test_getFileNamesList(self): + currentDir = os.getcwd() + rootDir = currentDir + "/" + "dummy" + if os.path.exists( rootDir ): + shutil.rmtree(rootDir) + os.mkdir(rootDir) + + directory = "testDir" + os.mkdir(rootDir + "/" + directory) + fileName1 = "dummyFile1.gff" + fullFileName1 = rootDir + "/" + directory + "/" + fileName1 + file1 = open(fullFileName1, "w") + file1.close() + fileName2 = "dummyFile2.gff" + fullFileName2 = rootDir + "/" + directory + "/" + fileName2 + file2 = open(fullFileName2, "w") + file2.close() + + expLFiles = [fileName1, fileName2] + obsLFiles = FileUtils.getFileNamesList(rootDir + "/" + directory) + + self.assertEquals(expLFiles, sorted(obsLFiles)) + + shutil.rmtree(rootDir) + + def test_getFileNamesList_withPattern(self): + currentDir = os.getcwd() + rootDir = currentDir + "/" + "dummy" + if os.path.exists( rootDir ): + shutil.rmtree(rootDir) + os.mkdir(rootDir) + + directory = "testDir" + os.mkdir(rootDir + "/" + directory) + fileName1 = "dummyFile1.gff" + fullFileName1 = rootDir + "/" + directory + "/" + fileName1 + file1 = open(fullFileName1, "w") + file1.close() + fileName2 = "dummyFile2.gff" + fullFileName2 = rootDir + "/" + directory + "/" + fileName2 + file2 = open(fullFileName2, "w") + file2.close() + + expLFiles = [fileName1] + obsLFiles = FileUtils.getFileNamesList(rootDir + "/" + directory, "dummyFile1.*") + + self.assertEquals(expLFiles, obsLFiles) + + shutil.rmtree(rootDir) + + def test_getFileNamesList_empty_dir(self): + currentDir = os.getcwd() + rootDir = currentDir + "/" + "dummy" + os.mkdir(rootDir) + + directory = "testDir" + os.mkdir(rootDir + "/" + directory) + + expLFiles = [] + obsLFiles = FileUtils.getFileNamesList(rootDir + "/" + directory) + + self.assertEquals(expLFiles, obsLFiles) + + shutil.rmtree(rootDir) + + def test_getMd5SecureHash( self ): + if "hashlib" in sys.modules: + inFile = "dummyInFile" + inFileHandler = open( inFile, "w" ) + inFileHandler.write( "DLZIH17T63B;?" ) + inFileHandler.close() + exp = "50d1e2ded8f03881f940f70226e2b986" + obs = FileUtils.getMd5SecureHash( inFile ) + self.assertEqual( exp, obs ) + os.remove( inFile ) + + def test_catFilesOfDir(self): + currentDir = os.getcwd() + rootDir = currentDir + "/" + "dummy" + if os.path.exists( rootDir ): + shutil.rmtree(rootDir) + os.mkdir(rootDir) + + directory = "testDir" + os.mkdir(rootDir + "/" + directory) + fileName1 = "dummyFile1.gff" + fullFileName1 = rootDir + "/" + directory + "/" + fileName1 + file1 = open(fullFileName1, "w") + file1.write("file1\n") + file1.close() + fileName2 = "dummyFile2.gff" + fullFileName2 = rootDir + "/" + directory + "/" + fileName2 + file2 = open(fullFileName2, "w") + file2.write("file2\n") + file2.close() + obsFile = "obsFile" + expFile = "expFile" + expF = open(expFile, "w") + expF.write("file1\nfile2\n") + expF.close() + FileUtils.catFilesOfDir(rootDir + "/" + directory, obsFile) + self.assertTrue(FileUtils.are2FilesIdentical(expFile, obsFile)) + + shutil.rmtree(rootDir) + os.remove(expFile) + os.remove(obsFile) + + def test_isSizeNotNull_True(self): + file = "dummyExpFile" + fileHandler = open( file, "w" ) + fileHandler.write( "toto\n" ) + fileHandler.write( "titi\n" ) + fileHandler.close() + obsSize = FileUtils.isSizeNotNull(file) + self.assertTrue(obsSize) + os.remove(file) + + def test_isSizeNotNull_False(self): + file = "dummyExpFile" + fileHandler = open( file, "w" ) + fileHandler.close() + obsSize = FileUtils.isSizeNotNull(file) + self.assertFalse(obsSize) + os.remove(file) + + def test_splitFileIntoNFiles_3_files(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + obsFile2 = "dummy-2.txt" + obsFile3 = "dummy-3.txt" + + f = open(inputFile, "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3\n") + f.close() + + exp1 = "line1\n" + exp2 = "line2\n" + exp3 = "line3\n" + + FileUtils.splitFileIntoNFiles(inputFile, 3) + + obs1 = open(obsFile1).read() + obs2 = open(obsFile2).read() + obs3 = open(obsFile3).read() + + self.assertEqual(exp1, obs1) + self.assertEqual(exp2, obs2) + self.assertEqual(exp3, obs3) + self.assertFalse(FileUtils.isRessourceExists("dummy-4.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileIntoNFiles_2_files(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + obsFile2 = "dummy-2.txt" + + f = open(inputFile, "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3\n") + f.close() + + exp1 = "line1\nline2\n" + exp2 = "line3\n" + + FileUtils.splitFileIntoNFiles(inputFile, 2) + + obs1 = open(obsFile1).read() + obs2 = open(obsFile2).read() + + self.assertEqual(exp1, obs1) + self.assertEqual(exp2, obs2) + self.assertFalse(FileUtils.isRessourceExists("dummy-3.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileIntoNFiles_one_file(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + + f = open(inputFile, "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3\n") + f.close() + + exp1 = "line1\nline2\nline3\n" + + FileUtils.splitFileIntoNFiles(inputFile, 1) + + obs1 = open(obsFile1).read() + + self.assertEqual(exp1, obs1) + self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileIntoNFiles_more_file_than_lines(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + obsFile2 = "dummy-2.txt" + obsFile3 = "dummy-3.txt" + + f = open(inputFile, "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3\n") + f.close() + + exp1 = "line1\n" + exp2 = "line2\n" + exp3 = "line3\n" + + FileUtils.splitFileIntoNFiles(inputFile, 10) + + obs1 = open(obsFile1).read() + obs2 = open(obsFile2).read() + obs3 = open(obsFile3).read() + + self.assertEqual(exp1, obs1) + self.assertEqual(exp2, obs2) + self.assertEqual(exp3, obs3) + self.assertFalse(FileUtils.isRessourceExists("dummy-4.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileIntoNFiles_empty_file(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + + os.system( "touch %s" % ( inputFile ) ) + + exp1 = "" + + FileUtils.splitFileIntoNFiles(inputFile, 10) + + obs1 = open(obsFile1).read() + + self.assertEqual(exp1, obs1) + self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileIntoNFiles_0_file(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + + f = open(inputFile, "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3\n") + f.close() + + exp1 = "line1\nline2\nline3\n" + + FileUtils.splitFileIntoNFiles(inputFile, 0) + + obs1 = open(obsFile1).read() + + self.assertEqual(exp1, obs1) + self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileAccordingToLineNumber_3_files(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + obsFile2 = "dummy-2.txt" + obsFile3 = "dummy-3.txt" + + f = open(inputFile, "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3\n") + f.close() + + exp1 = "line1\n" + exp2 = "line2\n" + exp3 = "line3\n" + + FileUtils.splitFileAccordingToLineNumber(inputFile, 1) + + obs1 = open(obsFile1).read() + obs2 = open(obsFile2).read() + obs3 = open(obsFile3).read() + + self.assertEqual(exp1, obs1) + self.assertEqual(exp2, obs2) + self.assertEqual(exp3, obs3) + self.assertFalse(FileUtils.isRessourceExists("dummy-4.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileAccordingToLineNumber_2_files(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + obsFile2 = "dummy-2.txt" + + f = open(inputFile, "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3\n") + f.close() + + exp1 = "line1\nline2\n" + exp2 = "line3\n" + + FileUtils.splitFileAccordingToLineNumber(inputFile, 2) + + obs1 = open(obsFile1).read() + obs2 = open(obsFile2).read() + + self.assertEqual(exp1, obs1) + self.assertEqual(exp2, obs2) + self.assertFalse(FileUtils.isRessourceExists("dummy-3.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileAccordingToLineNumber_one_file(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + + f = open(inputFile, "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3\n") + f.close() + + exp1 = "line1\nline2\nline3\n" + + FileUtils.splitFileAccordingToLineNumber(inputFile, 3) + + obs1 = open(obsFile1).read() + + self.assertEqual(exp1, obs1) + self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileAccordingToLineNumber_more_maxLines_than_lines(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + + f = open(inputFile, "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3\n") + f.close() + + exp1 = "line1\nline2\nline3\n" + + FileUtils.splitFileAccordingToLineNumber(inputFile, 10) + + obs1 = open(obsFile1).read() + + self.assertEqual(exp1, obs1) + self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileAccordingToLineNumber_empty_file(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + + os.system( "touch %s" % ( inputFile ) ) + + exp1 = "" + + FileUtils.splitFileAccordingToLineNumber(inputFile, 10) + + obs1 = open(obsFile1).read() + + self.assertEqual(exp1, obs1) + self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def test_splitFileAccordingToLineNumber_0_lines(self): + inputFile = "dummy.txt" + obsFile1 = "dummy-1.txt" + + f = open(inputFile, "w") + f.write("line1\n") + f.write("line2\n") + f.write("line3\n") + f.close() + + exp1 = "line1\nline2\nline3\n" + + FileUtils.splitFileAccordingToLineNumber(inputFile, 0) + + obs1 = open(obsFile1).read() + + self.assertEqual(exp1, obs1) + self.assertFalse(FileUtils.isRessourceExists("dummy-2.txt")) + FileUtils.removeFilesByPattern("dummy*") + + def _writeFile( self, fileName ): + inFile = open(fileName, 'w') + inFile.write(">Sequence_de_reference\n") + inFile.write("ATTTTGCAGTCTTATTCGAG-----GCCATTGCT\n") + inFile.write(">Lignee1_mismatch\n") + inFile.write("ATTTTGCAGACTTATTCGAG-----GCCATTGCT\n") + inFile.write(">Lignee2_insertion\n") + inFile.write("ATTTTGCAGTCTTATTCGAGATTACGCCATTGCT\n") + inFile.write(">Lignee3_deletion\n") + inFile.write("A---TGCAGTCTTATTCGAG-----GCCATTGCT\n") + inFile.close() + + def _writeFileWithEmptyLine( self, fileName ): + fileWithEmptyLine = open(fileName, 'w') + fileWithEmptyLine.write(">Sequence_de_reference\n") + fileWithEmptyLine.write("ATTTTGCAGTCTTATTCGAG-----GCCATTGCT\n") + fileWithEmptyLine.write("\n\n") + fileWithEmptyLine.write(">Lignee1_mismatch\n") + fileWithEmptyLine.write("ATTTTGCAGACTTATTCGAG-----GCCATTGCT\n") + fileWithEmptyLine.write("\n\n") + fileWithEmptyLine.write(">Lignee2_insertion\n") + fileWithEmptyLine.write("ATTTTGCAGTCTTATTCGAGATTACGCCATTGCT\n") + fileWithEmptyLine.write("\n") + fileWithEmptyLine.write(">Lignee3_deletion\n") + fileWithEmptyLine.write("A---TGCAGTCTTATTCGAG-----GCCATTGCT\n") + fileWithEmptyLine.close() + + def _writeFileWithRepeatedBlanks( self, fileName ): + fileWithRepeatedBlanks = open(fileName, 'w') + fileWithRepeatedBlanks.write(">Sequ ence_de _reference\n") + fileWithRepeatedBlanks.write("ATTTT GCAGTCTT TTCGAG- ----GCCATT GCT\n") + fileWithRepeatedBlanks.close() + + def _writeFileWithoutRepeatedBlanks( self, fileName ): + fileWithoutRepeatedBlanks = open(fileName, 'w') + fileWithoutRepeatedBlanks.write(">Sequ ence_de _reference\n") + fileWithoutRepeatedBlanks.write("ATTTT GCAGTCTT TTCGAG- ----GCCATT GCT\n") + fileWithoutRepeatedBlanks.close() + +test_suite = unittest.TestSuite() +test_suite.addTest( unittest.makeSuite( Test_FileUtils ) ) +if __name__ == "__main__": + unittest.TextTestRunner(verbosity=2).run( test_suite )