Mercurial > repos > yufei-luo > s_mart
diff commons/core/coord/test/Test_SetUtils.py @ 31:0ab839023fe4
Uploaded
| author | m-zytnicki |
|---|---|
| date | Tue, 30 Apr 2013 14:33:21 -0400 |
| parents | 769e306b7933 |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commons/core/coord/test/Test_SetUtils.py Tue Apr 30 14:33:21 2013 -0400 @@ -0,0 +1,1689 @@ +# 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 unittest +import os +import time +from commons.core.coord.Set import Set +from commons.core.coord.Map import Map +from commons.core.coord.SetUtils import SetUtils +from commons.core.utils.FileUtils import FileUtils + + +class Test_SetUtils( unittest.TestCase ): + + def test_changeIdInList_on_empty_list(self): + lSets = [] + SetUtils.changeIdInList( lSets , 1 ) + obsLSets = lSets + expLSets = [] + self.assertEquals( expLSets , obsLSets ) + + def test_changeIdInList_on_list_size_one(self): + set1 = Set( 1, "set1", "seq1", 1, 2 ) + lSets = [ set1 ] + SetUtils.changeIdInList( lSets , 9 ) + obsLSets = lSets + set1 = Set( 9, "set1", "seq1", 1, 2 ) + expLSets = [ set1 ] + self.assertEquals( expLSets , obsLSets ) + + def test_changeIdInList(self): + set1 = Set( 1, "set1", "seq1", 1, 2 ) + set2 = Set( 2, "set2", "seq2", 2, 3 ) + lSets = [ set1, set2 ] + SetUtils.changeIdInList( lSets , 9 ) + obsLSets = lSets + set1 = Set( 9, "set1", "seq1", 1, 2 ) + set2 = Set( 9, "set2", "seq2", 2, 3 ) + expLSets = [ set1, set2 ] + + self.assertEquals( expLSets , obsLSets ) + + def test_getOverlapLengthBetweenLists_all_list_are_empty (self): + lSets1 = [] + lSets2 = [] + + expOverlapSize = 0 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_empty_list2_size_one (self): + lSets1 = [] + lSets2 = [ Set( 9, "set1", "seq1", 1, 2 ) ] + + expOverlapSize = 0 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_empty_list2_size_two (self): + lSets1 = [] + lSets2 = [ Set( 9, "set1", "seq1", 1, 2 ), Set( 9, "set2", "seq2", 2, 3 ) ] + + expOverlapSize = 0 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_size_one_list2_empty (self): + lSets1 = [ Set( 9, "set1", "seq1", 1, 2 ) ] + lSets2 = [] + + expOverlapSize = 0 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_one_without_overlapp (self): + lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ) ] + lSets2 = [ Set( 2, "set2", "seq2", 2, 3 ) ] + + expOverlapSize = 0 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_one_with_overlap_size_1 (self): + lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ) ] + lSets2 = [ Set( 2, "set1", "seq1", 2, 3 ) ] + + expOverlapSize = 1 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_one_with_overlap_size_2 (self): + lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ) ] + lSets2 = [ Set( 2, "set1", "seq1", 1, 3 ) ] + + expOverlapSize = 2 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_two_without_overlap_sets_in_list1_greater_than_sets_in_list2 (self): + lSets1 = [ Set( 1, "set1", "seq1", 4, 6 ) ] + lSets2 = [ Set( 2, "set2", "seq1", 2, 3 ), Set( 3, "set3", "seq3", 1, 2 ) ] + + expOverlapSize = 0 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_two_with_overlap_sets_in_list1_greater_than_sets_in_list2 (self): + lSets1 = [ Set( 1, "set1", "seq1", 4, 6 ) ] + lSets2 = [ Set( 2, "set2", "seq2", 2, 3 ), Set( 3, "set3", "seq1", 4, 5 ) ] + + expOverlapSize = 2 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_two_with_overlap_on_redundant_position (self): + lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ) ] + lSets2 = [ Set( 2, "set2", "seq1", 2, 3 ), Set( 3, "set1", "seq1", 1, 2 ) ] + + expOverlapSize = 3 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_size_two_list2_empty (self): + lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ), Set( 2, "set2", "seq2", 2, 3 ) ] + lSets2 = [] + + expOverlapSize = 0 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_on_different_seq_names (self): + lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ), Set( 2, "set2", "seq2", 2, 3 ) ] + lSets2 = [ Set( 3, "set1", "seq2", 4, 5 ), Set( 5, "set2", "seq4", 2, 3 ) ] + + expOverlapSize = 0 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_getOverlapLengthBetweenLists_list1_size_two_list2_size_two_with_overlap (self): + lSets1 = [ Set( 1, "set1", "seq1", 1, 6 ), Set( 2, "set2", "seq2", 2, 3 ) ] + lSets2 = [ Set( 3, "set1", "seq1", 1, 2 ), Set( 2, "set2", "seq3", 2, 3 ) ] + + expOverlapSize = 2 + obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 ) + + self.assertEquals( expOverlapSize, obsOverlapSize ) + + def test_areSetsOverlappingBetweenLists_list2_empty(self): + tuple1 = ("1","chr1","seq1", "100","110") + tuple2 = ("1","chr1","seq1", "200","220") + tuple3 = ("1","chr1","seq1", "300","330") + setList1 = self._makeSetListFromTupleList([tuple1, tuple2, tuple3]) + + setList2 = [] + + expRes = False + obsRes = SetUtils.areSetsOverlappingBetweenLists( setList1, setList2 ) + + self.assertEquals( expRes, obsRes ) + + def test_areSetsOverlappingBetweenLists_list2_size1(self): + tuple1 = ("1","chr1","seq1", "9","11") + tuple2 = ("1","chr1","seq1", "20","22") + tuple3 = ("1","chr1","seq1", "30","33") + setList1 = self._makeSetListFromTupleList( [ tuple1, tuple2, tuple3 ] ) + + tuple11 = ("1","chr1", "seq1", "8","11") + setList2 = self._makeSetListFromTupleList( [ tuple11 ] ) + + expRes = True + obsRes = SetUtils.areSetsOverlappingBetweenLists( setList1, setList2 ) + + self.assertEquals( expRes, obsRes ) + + def test_areSetsOverlappingBetweenLists_list1_greater_list2(self): + tuple1 = ("1","chr1","seq1","100","110") + tuple2 = ("1","chr1","seq1","200","220") + tuple3 = ("1","chr1","seq1","300","330") + setList1 = self._makeSetListFromTupleList( [ tuple1, tuple2, tuple3 ] ) + + tuple11 = ("1","chr1","seq1", "10","11") + tuple22 = ("1","chr1","seq1", "20","22") + tuple33 = ("1","chr1","seq1", "30","33") + setList2 = self._makeSetListFromTupleList( [ tuple11, tuple22, tuple33 ] ) + + expRes = False + obsRes = SetUtils.areSetsOverlappingBetweenLists( setList1, setList2 ) + + self.assertEquals( expRes, obsRes ) + + def test_areSetsOverlappingBetweenLists_unordered_first_item_of_list1_greater_second_item_smaller(self): + tuple1 = ("1","chr1","seq1","400","440") + tuple2 = ("1","chr1","seq1","1","11") + setList1 = self._makeSetListFromTupleList( [ tuple1, tuple2 ] ) + + tuple11 = ("1","chr1","seq1","15","17") + tuple22 = ("1","chr1","seq1", "20","22") + tuple33 = ("1","chr1","seq1","30","33") + setList2 = self._makeSetListFromTupleList( [ tuple11, tuple22, tuple33 ] ) + + expRes = False + obsRes = SetUtils.areSetsOverlappingBetweenLists( setList1, setList2 ) + + self.assertEquals( expRes, obsRes ) + + def test_areSetsOverlappingBetweenLists_unorderd_second_item_of_list1_overlap_first_item(self): + tuple1 = ("1","chr1","seq1","400","440") + tuple2 = ("1","chr1","seq1", "1","18") + setList1 = self._makeSetListFromTupleList( [ tuple1, tuple2 ] ) + + tuple11 = ("1","chr1","seq1","15","17") + tuple22 = ("1","chr1","seq1","20","22") + tuple33 = ("1","chr1","seq1","30","33") + setList2 = self._makeSetListFromTupleList( [ tuple11, tuple22, tuple33 ] ) + + expRes = True + obsRes = SetUtils.areSetsOverlappingBetweenLists( setList1, setList2 ) + + self.assertEquals( expRes, obsRes ) + + def test_areSetsOverlappingBetweenLists_last_item_list1_overlap_last_item_list2(self): + tuple1 = ("1","chr1","seq1","400","440") + tuple2 = ("1","chr1","seq1","320","340") + pathList1 = self._makeSetListFromTupleList( [ tuple1, tuple2 ] ) + + tuple11 = ("1","chr1","seq1","100","110") + tuple22 = ("1","chr1","seq1","200","220") + tuple33 = ("1","chr1","seq1","300","330") + pathList2 = self._makeSetListFromTupleList( [ tuple11, tuple22, tuple33 ] ) + + expRes = True + obsRes = SetUtils.areSetsOverlappingBetweenLists( pathList1, pathList2 ) + + self.assertEquals( expRes, obsRes ) + + def test_getCumulLength_empty_list(self): + lSets = [] + + expSize = 0 + obsSize = SetUtils.getCumulLength( lSets ) + + self.assertEquals( expSize, obsSize ) + + def test_getCumulLength_1_item(self): + lSets = [ Set( 1, "set1", "seq1", 1, 6 ) ] + + expSize = 6 + obsSize = SetUtils.getCumulLength( lSets ) + + self.assertEquals( expSize, obsSize ) + + def test_getCumulLength_2_items(self): + lSets = [ Set( 1, "set1", "seq1", 1, 6 ), Set( 1, "set1", "seq1", 1, 2 ) ] + + expSize = 8 + obsSize = SetUtils.getCumulLength( lSets ) + + self.assertEquals( expSize, obsSize ) + + def test_getCumulLength_complex(self): + set8 = Set(498, "(TACATA)25", "Mela_Blaster_Grouper_611_MAP_20", 17, 348) + set5 = Set(502, "(GGAGA)2", "Mela_Blaster_Grouper_611_MAP_20", 356, 366) + set6 = Set(503, "(TTTAAAGAACCC)2", "Mela_Blaster_Grouper_611_MAP_20", 433, 457) + set7 = Set(504, "(TATAA)2", "Mela_Blaster_Grouper_611_MAP_20", 484, 495) + lSets = [ set8, set5, set6, set7 ] + expSize = 380 + obsSize = SetUtils.getCumulLength( lSets ) + + self.assertEquals( expSize, obsSize ) + + def test_getListBoundaries_one_set(self): + lSets = [ Set( 1, "set1", "seq1", 3, 8 ) ] + + expTuple = ( 3, 8 ) + obsTuple = SetUtils.getListBoundaries( lSets ) + + self.assertEquals( expTuple, obsTuple ) + + def test_getListBoundaries_two_sets(self): + lSets = [ Set( 1, "set1", "seq1", 3, 8 ), Set( 2, "set2", "seq2", 5, 10 ) ] + + expTuple = ( 3, 10 ) + obsTuple = SetUtils.getListBoundaries( lSets ) + + self.assertEquals( expTuple, obsTuple ) + + def test_writeListInFile_empty_list(self): + lSets = [ ] + expFileName = "expFileName" + fileHandle = open(expFileName, "w") + fileHandle.close() + + obsFileName = "obsFileName" + fileHandle = open(obsFileName, "w") + SetUtils.writeListInFile(lSets, obsFileName, "w") + fileHandle.close() + + self.assertTrue( FileUtils.are2FilesIdentical( expFileName, obsFileName ) ) + + os.remove(obsFileName) + os.remove(expFileName) + + def test_writeListInFile_list_one_set(self): + lSets = [ Set( 1, "set1", "seq1", 3, 8 ) ] + line = "1\tset1\tseq1\t3\t8\n" + expFileName = "expFileName" + + fileHandle = open(expFileName, "w") + fileHandle.write(line) + fileHandle.close() + + obsFileName = "obsFileName" + fileHandle = open(obsFileName, "w") + SetUtils.writeListInFile(lSets, obsFileName, "w") + fileHandle.close() + + self.assertTrue( FileUtils.are2FilesIdentical( expFileName, obsFileName ) ) + + os.remove(obsFileName) + os.remove(expFileName) + + + def test_getDictOfListsWithIdAsKey_empty_list( self ): + lSets = [] + expDic = {} + obsDic = SetUtils.getDictOfListsWithIdAsKey( lSets ) + self.assertEquals( expDic, obsDic ) + + + def test_getDictOfListsWithIdAsKey_one_set( self ): + lSets = [ Set( 2, "set2", "seq2", 3, 8 ) ] + expDic = { 2: [ Set( 2, "set2", "seq2", 3, 8 ) ] } + obsDic = SetUtils.getDictOfListsWithIdAsKey( lSets ) + self.assertEquals( expDic, obsDic ) + + + def test_getDictOfListsWithIdAsKey_two_sets_with_same_id( self ): + lSets = [ Set( 2, "set2", "seq2", 10, 50 ), Set( 2, "set2", "seq2", 3, 8 )] + expDic = { 2: [Set( 2, "set2", "seq2", 10, 50 ), Set( 2, "set2", "seq2", 3, 8 )] } + obsDic = SetUtils.getDictOfListsWithIdAsKey( lSets ) + self.assertEquals( expDic, obsDic ) + + + def test_getDictOfListsWithIdAsKey_sets_with_3_different_id( self ): + set1 = Set( 1, "set2", "seq2", 10, 50 ) + set2 = Set( 1, "set2", "seq2", 20, 50 ) + set3 = Set( 2, "set2", "seq2", 30, 50 ) + set4 = Set( 2, "set2", "seq2", 40, 50 ) + set5 = Set( 3, "set2", "seq2", 1, 2 ) + lSets = [ set1, set2, set3, set4, set5 ] + expDic = { 1: [set1, set2], + 2: [set3, set4], + 3: [set5] } + obsDic = SetUtils.getDictOfListsWithIdAsKey( lSets ) + self.assertEquals( expDic, obsDic ) + + + def test_getDictOfListsWithIdAsKeyFromFile(self): + setFile = "dummySetFile" + setFileHandler = open( setFile, "w" ) + setFileHandler.write( "1\tseq31\tchr1\t151\t250\n" ) + setFileHandler.write( "2\tseq27\tchr2\t301\t500\n" ) + setFileHandler.write( "2\tseq27\tchr2\t601\t650\n" ) + setFileHandler.close() + + dExp = { 1: [ Set( 1, "seq31", "chr1", 151, 250 ) ], + 2: [ Set( 2, "seq27", "chr2", 301, 500 ), + Set( 2, "seq27", "chr2", 601, 650 ) ] } + dObs = SetUtils.getDictOfListsWithIdAsKeyFromFile( setFile ) + + self.assertEquals( dExp, dObs ) + + os.remove( setFile ) + + + def test_getMapListFromSetList_empty_list(self): + lSets = [] + + expLMap = [] + obsLMap = SetUtils.getMapListFromSetList(lSets) + + self.assertEquals(expLMap, obsLMap) + + def test_getMapListFromSetList_one_set(self): + lSets = [ Set( 1, "set", "seq1", 1, 6 )] + map1 = Map("set::1","seq1",1,6) + + expLMap = [ map1 ] + obsLMap = SetUtils.getMapListFromSetList(lSets) + + self.assertEquals(expLMap, obsLMap) + + def test_getMapListFromSetList_two_sets(self): + lSets = [ Set( 1, "set", "seq1", 1, 6 ), Set( 2, "set", "seq2", 3, 8 ) ] + map1 = Map("set::1","seq1",1,6) + map2 = Map("set::2","seq2",3,8) + + expLMap = [ map1, map2 ] + obsLMap = SetUtils.getMapListFromSetList(lSets) + + self.assertEquals(expLMap, obsLMap) + + def test_getSetListFromMapList_empty_list(self): + lMap =[] + expLSets = [] + obsLSets = SetUtils.getSetListFromMapList(lMap) + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListFromMapList_one_map(self): + map1 = Map( "map1","seq1",1,6) + lMap =[ map1 ] + expLSets = [ Set( 1, "map1", "seq1", 1, 6 ) ] + obsLSets = SetUtils.getSetListFromMapList(lMap) + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListFromMapList_two_maps(self): + map1 = Map( "map1","seq1",1,6) + map2 = Map( "map2","seq2",3,8) + lMap =[ map1,map2 ] + expLSets = [ Set( 1, "map1", "seq1", 1, 6 ), Set( 2, "map2", "seq2", 3, 8 ) ] + obsLSets = SetUtils.getSetListFromMapList(lMap) + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListFromMapList_list_with_one_empty_map(self): + map1 = Map( "map1","seq1",1,6) + map2 = Map() + lMap =[ map1,map2 ] + expLSets = [ Set( 1, "map1", "seq1", 1, 6 ), Set(2, ) ] + obsLSets = SetUtils.getSetListFromMapList(lMap) + + self.assertEquals(expLSets, obsLSets) + + def test_mergeSetsInList(self): + set1 = Set( 1, "set1", "seq1", 1, 6 ) + set2 = Set( 2, "set2", "seq1", 3, 6 ) + set3 = Set( 3, "set3", "seq1", 3, 5 ) + set4 = Set( 4, "set4", "seq1", 1, 2 ) + lSets = [ set1, set2, set3, set4 ] + + obsList = SetUtils.mergeSetsInList( lSets ) + expList = [ Set( 1, "set1", "seq1", 1, 6 ) ] + + self.assertEquals( expList, obsList ) + + + def test_mergeSetsInList_with_reverse_only(self): + set1 = Set( 1, "set1", "seq1", 6, 1 ) + set2 = Set( 2, "set2", "seq1", 6, 3 ) + set3 = Set( 3, "set3", "seq1", 5, 3 ) + set4 = Set( 4, "set4", "seq1", 2, 1 ) + lSets = [ set1, set2, set3, set4 ] + + obsList = SetUtils.mergeSetsInList( lSets ) + expList = [ Set( 1, "set1", "seq1", 6, 1 ) ] + + self.assertEquals( expList, obsList ) + + + def test_mergeSetsInList_with_direct_and_reverse(self): + set1 = Set( 1, "set1", "seq1", 6, 1 ) + set2 = Set( 2, "set2", "seq1", 6, 3 ) + set3 = Set( 3, "set3", "seq1", 3, 5 ) + set4 = Set( 4, "set4", "seq1", 2, 1 ) + lSets = [ set1, set2, set3, set4 ] + + obsList = SetUtils.mergeSetsInList( lSets ) + expList = [ set1 ] + + self.assertEquals( expList, obsList ) + + + def test_mergeSetsInList_with_empty_set(self): + set1 = Set( 1, "set1", "seq1", 1, 6 ) + set2 = Set() + set3 = Set( 3, "set3", "seq1", 3, 5 ) + set4 = Set( 4, "set4", "seq1", 1, 2 ) + lSets = [ set1, set2, set3, set4 ] + + obsList = SetUtils.mergeSetsInList( lSets ) + expList = [ set2, set1 ] + + self.assertEquals( expList, obsList ) + + + def test_mergeSetsInList_empty_list(self): + lSets = [] + + obsList = SetUtils.mergeSetsInList( lSets ) + expList = [] + + self.assertEquals( expList, obsList ) + + + def test_mergeSetsInList_one_set (self): + set1 = Set( 1, "set1", "seq1", 1, 6 ) + lSets = [ set1 ] + + obsLSets = SetUtils.mergeSetsInList( lSets ) + expLSets = [ set1 ] + + self.assertEquals( expLSets, obsLSets ) + + + def test_mergeSetsInList_diffSeqnames_without_overlapping(self): + set1 = Set( 1, "set1", "seq1", 1, 6 ) + set2 = Set( 1, "set2", "seq2", 11, 16 ) + lSets = [ set1, set2 ] + + obsLSets = SetUtils.mergeSetsInList( lSets ) + expLSets = [ set1, set2 ] + + self.assertEquals( expLSets, obsLSets ) + + + def test_mergeSetsInList_diffSeqnames_overlapping(self): + set1 = Set( 1, "set1", "seq1", 1, 6 ) + set2 = Set( 1, "set2", "seq2", 2, 5 ) + lSets = [ set1, set2 ] + + obsLSets = SetUtils.mergeSetsInList( lSets ) + expLSets = [ set1, set2 ] + + self.assertEquals( expLSets, obsLSets ) + + + def test_mergeSetsInList_sameSeqnames_without_overlapping(self): + set1 = Set( 1, "set1", "seq1", 1, 6 ) + set2 = Set( 1, "set2", "seq1", 11, 16 ) + lSets = [ set1, set2 ] + + obsLSets = SetUtils.mergeSetsInList( lSets ) + expLSets = [ set1, set2 ] + + self.assertEquals( expLSets, obsLSets ) + + def test_mergeSetsInList_complex(self): + set1 = Set(498, "(ACATATAATAA)10", "Mela_Blaster_Grouper_611_MAP_20", 77, 181) + set2 = Set(499, "(TACATA)25", "Mela_Blaster_Grouper_611_MAP_20", 17, 166) + set3 = Set(500, "(ATAAAATAC)26", "Mela_Blaster_Grouper_611_MAP_20", 94, 348) + set4 = Set(501, "(TAA)15", "Mela_Blaster_Grouper_611_MAP_20", 257, 303) + set5 = Set(502, "(GGAGA)2", "Mela_Blaster_Grouper_611_MAP_20", 356, 366) + set6 = Set(503, "(TTTAAAGAACCC)2", "Mela_Blaster_Grouper_611_MAP_20", 433, 457) + set7 = Set(504, "(TATAA)2", "Mela_Blaster_Grouper_611_MAP_20", 484, 495) + lSets = [ set1, set2, set3, set4, set5, set6, set7 ] + obsLSets = SetUtils.mergeSetsInList( lSets ) + + set8 = Set(498, "(TACATA)25", "Mela_Blaster_Grouper_611_MAP_20", 17, 348) + + expLSets = [ set8, set5, set6, set7 ] + + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListUnjoined_listToKeep_empty_listToUnjoin_empty (self): + setListToKeep = [] + setListToUnjoin = [] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + expLSets = [] + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_empty (self): + setListToKeep = [] + + setUnjoin1 = Set( 1, "set", "seq", 1, 3 ) + setUnjoin2 = Set( 1, "set", "seq", 2, 3 ) + setUnjoin3 = Set( 1, "set", "seq", 5, 7 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3 ] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + expLSets = [ setListToUnjoin ] + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_empty_listToUnjoin_size1 (self): + setListToKeep = [] + + setUnjoin = Set( 1, "set", "seq", 1, 3 ) + setListToUnjoin = [ setUnjoin ] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + expLSets = [ setListToUnjoin ] + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_empty (self): + setKeep = Set( 1, "set", "seq", 1, 3 ) + setListToKeep = [ setKeep ] + + setListToUnjoin = [] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + expLSets = [] + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_size1 (self): + setKeep = Set( 1, "set", "seq", 1, 3 ) + setListToKeep = [ setKeep ] + + setUnjoin = Set( 1, "set", "seq", 5, 9 ) + setListToUnjoin = [ setUnjoin ] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + expLSets = [ setListToUnjoin ] + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_size2_noSplit_item_in_listToKeep_smaller_item_in_listToUnjoin (self): + setKeep = Set( 1, "set", "seq", 1, 3 ) + setListToKeep = [ setKeep ] + + setUnjoin1 = Set( 1, "set", "seq", 5, 9 ) + setUnjoin2 = Set( 1, "set", "seq", 11, 16 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2 ] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + expLSets = [ setListToUnjoin ] + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_size3_noSplit_item_in_listToKeep_smaller_item_in_listToUnjoin (self): + setKeep = Set( 1, "set", "seq", 1, 3 ) + setListToKeep = [ setKeep ] + + setUnjoin1 = Set( 1, "set", "seq", 5, 9 ) + setUnjoin2 = Set( 1, "set", "seq", 11, 16 ) + setUnjoin3 = Set( 1, "set", "seq", 21, 26 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3 ] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + expLSets = [ setListToUnjoin ] + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_size2_noSplit_item_in_listToUnjoin_smaller_item_in_listToKeep (self): + setKeep = Set( 1, "set", "seq", 10, 13 ) + setListToKeep = [ setKeep ] + + setUnjoin1 = Set( 1, "set", "seq", 5, 9 ) + setUnjoin2 = Set( 1, "set", "seq", 1, 3 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2 ] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + expLSets = [ SetUtils.getSetListSortedByIncreasingMinThenMax( setListToUnjoin ) ] + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_size3_listToUnjoin_size2_oneSplit_item_in_listToKeep_smaller_item_in_listToUnjoin (self): + setKeep1 = Set( 1, "set", "seq", 1, 1 ) + setKeep2 = Set( 1, "set", "seq", 21, 30 ) + setKeep3 = Set( 1, "set", "seq", 61, 70 ) + setListToKeep = [ setKeep1, setKeep2, setKeep3 ] + + setUnjoin1 = Set( 1, "set", "seq", 41, 50 ) + setUnjoin2 = Set( 2, "set", "seq", 81, 90 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2 ] + + expLSets = [ [ setUnjoin1 ], [ setUnjoin2 ] ] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_size3_listToUnjoin_size3_twoSplits_item_in_listToUnjoin_smaller_item_in_listToKeep(self): + setKeep1 = Set( 1, "set", "seq", 21, 30 ) + setKeep2 = Set( 1, "set", "seq", 41, 50 ) + setKeep3 = Set( 1, "set", "seq", 81, 90 ) + setListToKeep = [ setKeep1, setKeep2, setKeep3 ] + + setUnjoin1 = Set( 1, "set", "seq", 1, 10 ) + setUnjoin2 = Set( 2, "set", "seq", 61, 70 ) + setUnjoin3 = Set( 2, "set", "seq", 101, 110 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3 ] + + expLSets = [ [ setUnjoin1 ], [ setUnjoin2 ], [ setUnjoin3 ] ] + + obsLSets = SetUtils.getSetListUnjoined( setListToKeep, setListToUnjoin ) + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_size2_split(self): + setKeep1 = Set( 1, "set", "seq", 51, 80 ) + setListToKeep = [ setKeep1 ] + + setUnjoin1 = Set( 1, "set", "seq", 21, 40 ) + setUnjoin2 = Set( 1, "set", "seq", 101, 150 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2 ] + + expLSets = [ [setUnjoin1] , [setUnjoin2] ] + + obsLSets = SetUtils.getSetListUnjoined( setListToKeep, setListToUnjoin ) + + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListUnjoined_listToKeep_size2_listToUnjoin_size2_split(self): + setKeep1 = Set( 1, "set", "seq", 1, 15 ) + setKeep2 = Set( 1, "set", "seq", 81, 130 ) + setListToKeep = [ setKeep1, setKeep2 ] + + setUnjoin1 = Set( 1, "set", "seq", 21, 40 ) + setUnjoin2 = Set( 1, "set", "seq", 201, 250 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2 ] + + expLSets = [ [setUnjoin1] , [setUnjoin2] ] + + obsLSets = SetUtils.getSetListUnjoined( setListToKeep, setListToUnjoin ) + + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_ordered_OneSplit(self): + setKeep = Set( 1, "set", "seq", 120, 180 ) + setListToKeep = [ setKeep ] + + setUnjoin1 = Set( 1, "set", "seq", 100, 110 ) + setUnjoin2 = Set( 1, "set", "seq", 200, 210 ) + setUnjoin3 = Set( 1, "set", "seq", 250, 280 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3 ] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + expLSets = [ [setUnjoin1], [setUnjoin2, setUnjoin3] ] + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_unordered_OneSplit(self): + setKeep = Set( 1, "set", "seq", 120, 180 ) + setListToKeep = [ setKeep ] + + setUnjoin1 = Set( 1, "set", "seq", 200, 210 ) + setUnjoin2 = Set( 1, "set", "seq", 250, 280 ) + setUnjoin3 = Set( 1, "set", "seq", 100, 110 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3 ] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + expLSets = [ [setUnjoin3], [setUnjoin1, setUnjoin2] ] + + self.assertEquals(expLSets, obsLSets) + + def test_getSetListUnjoined_listToKeep_size2_listToUnjoin_size4_twoSplits(self): + setKeep1 = Set( 1, "set", "seq", 21, 30 ) + setKeep2 = Set( 1, "set", "seq", 81, 90 ) + setListToKeep = [ setKeep1, setKeep2 ] + + setUnjoin1 = Set( 1, "set", "seq", 1, 10 ) + setUnjoin2 = Set( 1, "set", "seq", 41, 50 ) + setUnjoin3 = Set( 1, "set", "seq", 61, 70 ) + setUnjoin4 = Set( 1, "set", "seq", 101, 110 ) + setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3, setUnjoin4 ] + + expLSets = [ [setUnjoin1], [ setUnjoin2, setUnjoin3 ], [setUnjoin4] ] + + obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin) + + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListWithoutDuplicates_empty_list(self): + lSets = [] + obsLSets = SetUtils.getSetListWithoutDuplicates( lSets ) + expLSets = [] + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListWithoutDuplicates_list_size1(self): + set = Set( 1, "set", "seq", 100, 110 ) + lSets = [ set ] + obsLSets = SetUtils.getSetListWithoutDuplicates( lSets ) + expLSets = lSets + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListWithoutDuplicates_list_with_only_doublons(self): + set1 = Set( 1, "set", "seq", 100, 110 ) + set2 = Set( 1, "set", "seq", 100, 110 ) + set3 = Set( 1, "set", "seq", 100, 110 ) + set4 = Set( 1, "set", "seq", 100, 110 ) + lSets = [set1, set2, set3, set4] + + obsLSets = SetUtils.getSetListWithoutDuplicates( lSets ) + + expLSets = [ set1 ] + + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListWithoutDuplicates_list_with_doublons_at_start_and_at_end(self): + set1 = Set( 1, "set", "seq", 200, 210 ) + set2 = Set( 1, "set", "seq", 100, 110 ) + set3 = Set( 1, "set", "seq", 300, 310 ) + set4 = Set( 1, "set", "seq", 100, 110 ) + lSets = [set1, set2, set3, set4] + + obsLSets = SetUtils.getSetListWithoutDuplicates( lSets ) + + expLSets = [ set1, set2, set3 ] + expLSets = SetUtils.getSetListSortedByIncreasingMinThenMax(expLSets) + + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListWithoutDuplicates_list_with_contiguous_doublons(self): + set1 = Set( 1, "set", "seq", 200, 210 ) + set2 = Set( 1, "set", "seq", 100, 110 ) + set3 = Set( 1, "set", "seq", 100, 110 ) + set4 = Set( 1, "set", "seq", 300, 310 ) + lSets = [set1, set2, set3, set4] + + obsLSets = SetUtils.getSetListWithoutDuplicates( lSets ) + + expLSets = [ set1, set2, set4 ] + expLSets = SetUtils.getSetListSortedByIncreasingMinThenMax(expLSets) + + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListWithoutDuplicates_list_with_one_doublon(self): + set1 = Set( 1, "set", "seq", 200, 210 ) + set2 = Set( 1, "set", "seq", 100, 110 ) + set3 = Set( 1, "set", "seq", 210, 250 ) + set4 = Set( 1, "set", "seq", 100, 110 ) + set5 = Set( 1, "set", "seq", 300, 310 ) + lSets = [set1, set2, set3, set4, set5] + + obsLSets = SetUtils.getSetListWithoutDuplicates( lSets ) + + expLSets = [ set1, set2, set3, set5 ] + expLSets = SetUtils.getSetListSortedByIncreasingMinThenMax(expLSets) + + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListWithoutDuplicates_list_with_two_doublons(self): + set1 = Set( 1, "set", "seq", 200, 210 ) + set2 = Set( 1, "set", "seq", 100, 110 ) + set3 = Set( 1, "set", "seq", 210, 250 ) + set4 = Set( 1, "set", "seq", 230, 250 ) + set5 = Set( 1, "set", "seq", 210, 250 ) + set6 = Set( 1, "set", "seq", 100, 110 ) + set7 = Set( 1, "set", "seq", 300, 310 ) + lSets = [set1, set2, set3, set4, set5, set6, set7] + + obsLSets = SetUtils.getSetListWithoutDuplicates( lSets ) + + expLSets = [ set1, set2, set3, set4, set7 ] + expLSets = SetUtils.getSetListSortedByIncreasingMinThenMax(expLSets) + + self.assertEquals( expLSets, obsLSets ) + + def test_getSetListSortedByIncreasingMinThenMax_alreadyOrdered_diffIdentifier(self): + set1 = Set( 1, "set1", "seq1", 1, 10 ) + set2 = Set( 2, "set1", "seq1", 21, 30 ) + lSets = [ set1, set2 ] + + expList = [ set1, set2 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets ) + + self.assertEqual( expList, obsList ) + + + def test_getSetListSortedByIncreasingMinThenMax_unordered_diffIdentifier(self): + set1 = Set( 1, "set1", "seq1", 21, 30 ) + set2 = Set( 2, "set1", "seq1", 1, 10 ) + lSets = [ set1, set2 ] + + expList = [ set2, set1 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets ) + + self.assertEqual( expList, obsList ) + + + def test_getSetListSortedByIncreasingMinThenMax_unordered_sameIdentifier(self): + set1 = Set( 1, "set1", "seq1", 21, 30 ) + set2 = Set( 1, "set1", "seq1", 1, 10 ) + lSets = [ set1, set2 ] + + expList = [ set2, set1 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets ) + + self.assertEqual( expList, obsList ) + + + def test_getSetListSortedByIncreasingMinThenMax_unordered_overlapping(self): + set1 = Set( 2, "set1", "seq1", 6, 15 ) + set2 = Set( 1, "set1", "seq1", 1, 10 ) + lSets = [ set1, set2 ] + + expList = [ set2, set1 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets ) + + self.assertEqual( expList, obsList ) + + def test_getSetListSortedByIncreasingMinThenMax_unordered_sameMin_threeSets(self): + set1 = Set( 1, "set1", "seq1", 1, 15 ) + set2 = Set( 2, "set2", "seq1", 1, 10 ) + set3 = Set( 3, "set3", "seq1", 1, 12 ) + lSets = [ set1, set2, set3 ] + + expList = [ set2, set3, set1 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets ) + + self.assertEqual( expList, obsList ) + + + def test_getSetListSortedByIncreasingMinThenMax_unordered_included(self): + set1 = Set( 1, "set1", "seq1", 2, 4 ) + set2 = Set( 2, "set2", "seq1", 1, 5 ) + lSets = [ set1, set2 ] + + expList = [ set2, set1 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets ) + + self.assertEqual( expList, obsList ) + + + def test_getSetListSortedByIncreasingMinThenInvLength_alreadyOrdered_diffIdentifier(self): + set1 = Set( 1, "set1", "seq1", 1, 10 ) + set2 = Set( 2, "set1", "seq1", 21, 30 ) + lSets = [ set1, set2 ] + + expList = [ set1, set2 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets ) + + self.assertEqual( expList, obsList ) + + + def test_getSetListSortedByIncreasingMinThenInvLength_unordered_diffIdentifier(self): + set1 = Set( 1, "set1", "seq1", 21, 30 ) + set2 = Set( 2, "set1", "seq1", 1, 10 ) + lSets = [ set1, set2 ] + + expList = [ set2, set1 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets ) + + self.assertEqual( expList, obsList ) + + + def test_getSetListSortedByIncreasingMinThenInvLength_unordered_sameIdentifier(self): + set1 = Set( 1, "set1", "seq1", 21, 30 ) + set2 = Set( 1, "set1", "seq1", 1, 10 ) + lSets = [ set1, set2 ] + + expList = [ set2, set1 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets ) + + self.assertEqual( expList, obsList ) + + + def test_getSetListSortedByIncreasingMinThenInvLength_unordered_overlapping(self): + set1 = Set( 2, "set1", "seq1", 6, 15 ) + set2 = Set( 1, "set1", "seq1", 1, 10 ) + lSets = [ set1, set2 ] + + expList = [ set2, set1 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets ) + + self.assertEqual( expList, obsList ) + + + def test_getSetListSortedByIncreasingMinThenInvLength_unordered_sameMin_threeSets(self): + set1 = Set( 1, "set1", "seq1", 1, 10 ) + set2 = Set( 2, "set2", "seq1", 3, 8 ) + set3 = Set( 3, "set3", "seq1", 3, 17 ) + lSets = [ set1, set2, set3 ] + + expList = [ set1, set3, set2 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets ) + + self.assertEqual( expList, obsList ) + + def test_getSetListSortedByIncreasingMinThenInvLength_unordered_included(self): + set1 = Set( 1, "set1", "seq1", 2, 4 ) + set2 = Set( 2, "set2", "seq1", 1, 5 ) + lSets = [ set1, set2 ] + + expList = [ set2, set1 ] + + obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets ) + + self.assertEqual( expList, obsList ) + + def test_getSetListSortedBySeqThenRegionThenMinThenMax_already_sorted(self): + set1 = Set(1, "set1", "seq1", 2, 4) + set2 = Set(2, "set2", "seq2", 1, 5) + set3 = Set(3, "set3", "seq2", 8, 10) + lSets = [set1, set2, set3] + + expList = [set1, set2, set3] + + obsList = SetUtils.getSetListSortedBySeqThenRegionThenMinThenMax(lSets) + + self.assertEqual(expList, obsList) + + def test_getSetListSortedBySeqThenRegionThenMinThenMax_not_sorted_by_seqname(self): + set1 = Set(1, "set1", "seq1", 2, 4) + set2 = Set(2, "set2", "seq2", 1, 5) + set3 = Set(3, "set3", "seq2", 8, 10) + lSets = [set2, set1, set3] + + expList = [set1, set2, set3] + + obsList = SetUtils.getSetListSortedBySeqThenRegionThenMinThenMax(lSets) + + self.assertEqual(expList, obsList) + + def test_getSetListSortedBySeqThenRegionThenMinThenMax_not_sorted_by_region_and_start(self): + set1 = Set(1, "set1", "seq1", 2, 4) + set2 = Set(2, "set2", "seq2", 1, 5) + set3 = Set(3, "set3", "seq2", 8, 10) + lSets = [set3, set2, set1] + + expList = [set1, set2, set3] + + obsList = SetUtils.getSetListSortedBySeqThenRegionThenMinThenMax(lSets) + + self.assertEqual(expList, obsList) + + def test_getSetListSortedBySeqThenRegionThenMinThenMax_not_sorted_with_overlap(self): + set1 = Set(1, "set1", "seq1", 2, 4) + set2 = Set(2, "set2", "seq2", 1, 5) + set3 = Set(3, "set2", "seq2", 8, 10) + set4 = Set(4, "set2", "seq3", 7, 9) + set5 = Set(5, "set3", "seq3", 8, 12) + lSets = [set3, set2, set1, set5, set4] + + expList = [set1, set2, set3, set4, set5] + + obsList = SetUtils.getSetListSortedBySeqThenRegionThenMinThenMax(lSets) + + self.assertEqual(expList, obsList) + + def test_getSetListSortedBySeqThenRegionThenMinThenMax_not_sorted_with_reverse(self): + set1 = Set(1, "set1", "seq1", 2, 4) + set2 = Set(2, "set2", "seq2", 1, 5) + set3 = Set(3, "set2", "seq2", 8, 10) + set4 = Set(4, "set3", "seq3", 7, 9) + set5 = Set(5, "set3", "seq3", 12, 5) + lSets = [set3, set2, set5, set1, set4] + + expList = [set1, set2, set3, set5, set4] + + obsList = SetUtils.getSetListSortedBySeqThenRegionThenMinThenMax(lSets) + + self.assertEqual(expList, obsList) + + def test_getListOfIdListOfOverlappingSets_2_item_in_reference_list_overlaps_with_one_item_in_subject_list(self): + set1 = Set( 1, "set1", "seq1", 10, 30 ) + set2 = Set( 2, "set2", "seq1", 40, 60 ) + + lRef = [set1, set2] + + set3 = Set( 3, "set2", "seq1", 25, 45 ) + lSubj = [set3] + + lExp = [[1,-3,2]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lExp, lObs) + + def test_getListOfIdListOfOverlappingSets_one_item_in_reference_list_overlaps_with_2_item_in_subject_list(self): + set1 = Set( 1, "set2", "seq1", 25, 45 ) + lRef = [set1] + + set2 = Set( 2, "set1", "seq1", 10, 30 ) + set3 = Set( 3, "set2", "seq1", 40, 60 ) + + lSubj = [set2, set3] + + lExp = [[1,-2,-3]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lExp, lObs) + + def test_getListOfIdListOfOverlappingSets_all_item_in_reference_list_overlaps_with_items_in_subject_list(self): + set1 = Set( 1, "set1", "seq1", 10, 30 ) + set2 = Set( 2, "set2", "seq1", 40, 60 ) + set3 = Set( 3, "set2", "seq1", 70, 90 ) + + lRef = [set1, set2, set3] + + set4 = Set( 4, "set1", "seq1", 5, 9 ) + set5 = Set( 5, "set1", "seq1", 15, 29 ) + set6 = Set( 6, "set2", "seq1", 45, 55 ) + set7 = Set( 7, "set2", "seq1", 57, 68 ) + set8 = Set( 8, "set2", "seq1", 73, 85 ) + set9 = Set( 9, "set2", "seq1", 100, 115 ) + + lSubj = [set4, set5, set6, set7, set8, set9] + + lExp = [[1,-5], [2,-6,-7], [3,-8]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfIdListOfOverlappingSets_all_item_in_subject_list_overlaps_with_items_in_reference_list(self): + set1 = Set( 1, "set1", "seq1", 5, 9 ) + set2 = Set( 2, "set1", "seq1", 15, 29 ) + set3 = Set( 3, "set2", "seq1", 45, 55 ) + set4 = Set( 4, "set2", "seq1", 57, 68 ) + set5 = Set( 5, "set2", "seq1", 73, 85 ) + set6 = Set( 6, "set2", "seq1", 100, 115 ) + + lRef = [set1, set2, set3, set4, set5, set6] + + set7 = Set( 7, "set1", "seq1", 10, 30 ) + set8 = Set( 8, "set2", "seq1", 40, 60 ) + set9 = Set( 9, "set2", "seq1", 70, 90 ) + + lSubj = [set7, set8, set9] + + lExp = [[2, -7], [3, -8, 4], [5, -9]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfIdListOfOverlappingSets_all_item_overlaps_one_by_one(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + set3 = Set( 3, "set2", "seq1", 50, 60 ) + + lRef = [set1, set2, set3] + + lSubj = [set1, set2, set3] + + lExp = [[1, -1], [2, -2], [3, -3]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfIdListOfOverlappingSets_continuus_overlap_between_item_in_reference_list_and_item_in_subject_list(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + set3 = Set( 3, "set2", "seq1", 50, 60 ) + set4 = Set( 4, "set2", "seq1", 70, 80 ) + + lRef = [set1, set2, set3, set4] + + set5 = Set( 5, "set1", "seq1", 15, 32 ) + set6 = Set( 6, "set2", "seq1", 35, 52 ) + set7 = Set( 7, "set2", "seq1", 55, 75 ) + + lSubj = [set5, set6, set7] + + lExp = [[ 1, -5, 2, -6, 3, -7, 4 ]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + + def test_getListOfIdListOfOverlappingSets_first_item_in_reference_overlap_with_one_item_in_subject_list(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + + lRef = [set1, set2] + + set3 = Set( 3, "set1", "seq1", 5, 9 ) + set4 = Set( 4, "set2", "seq1", 12, 25 ) + set5 = Set( 5, "set2", "seq1", 55, 75 ) + + lSubj = [set3, set4, set5] + + lExp = [[1, -4]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfIdListOfOverlappingSets_last_item_in_reference_overlap_with_one_item_in_subject_list(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + + lRef = [set1, set2] + + set3 = Set( 3, "set1", "seq1", 5, 9 ) + set4 = Set( 4, "set2", "seq1", 32, 45 ) + set5 = Set( 5, "set2", "seq1", 55, 75 ) + + lSubj = [set3, set4, set5] + + lExp = [[2, -4]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfIdListOfOverlappingSets_one_item_in_reference_in_the_middle_overlap_with_one_item_in_subject_list(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + set3 = Set( 3, "set1", "seq1", 50, 60 ) + set4 = Set( 4, "set1", "seq1", 70, 80 ) + + lRef = [set1, set2, set3, set4] + + set5 = Set( 5, "set1", "seq1", 2, 9 ) + set6 = Set( 6, "set2", "seq1", 55, 65 ) + set7 = Set( 7, "set2", "seq1", 90, 100 ) + + lSubj = [set5, set6, set7] + + lExp = [[3, -6]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfIdListOfOverlappingSets_first_item_in_subject_overlap_with_one_item_in_reference_list(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + + lRef = [set1, set2] + + set3 = Set( 3, "set1", "seq1", 15, 25 ) + set4 = Set( 4, "set2", "seq1", 45, 50 ) + set5 = Set( 5, "set2", "seq1", 55, 75 ) + + lSubj = [set3, set4, set5] + + lExp = [[1, -3]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfIdListOfOverlappingSets_last_item_in_subject_overlap_with_one_item_in_reference_list(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + + lRef = [set1, set2] + + set3 = Set( 3, "set1", "seq1", 1, 9 ) + set4 = Set( 4, "set2", "seq1", 21, 29 ) + set5 = Set( 5, "set2", "seq1", 35, 50 ) + + lSubj = [set3, set4, set5] + + lExp = [[2, -5]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfIdListOfOverlappingSets_one_item_in_subject_in_the_middle_overlap_with_one_item_in_reference_list(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + + lRef = [set1, set2] + + set3 = Set( 3, "set1", "seq1", 1, 9 ) + set4 = Set( 4, "set2", "seq1", 21, 29 ) + set5 = Set( 5, "set2", "seq1", 35, 50 ) + set6 = Set( 6, "set2", "seq1", 60, 70 ) + + lSubj = [set3, set4, set5, set6] + + lExp = [[2, -5]] + lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfMergedSetsAndNextId_each_item_in_reference_list_overlap_with_one_different_item_in_subject_list(self): + setRef1 = Set( 1, "set1", "seq1", 10, 20 ) + setRef2 = Set( 2, "set1", "seq1", 30, 40 ) + setRef3 = Set( 3, "set1", "seq1", 50, 60 ) + + lRef = [setRef1, setRef2, setRef3] + + setSubj1 = Set( 1, "set1", "seq1", 12, 25 ) + setSubj2 = Set( 2, "set1", "seq1", 31, 45 ) + setSubj3 = Set( 3, "set1", "seq1", 55, 80 ) + + lSubj = [setSubj1, setSubj2, setSubj3] + + setRef1merged = Set( 1, "set1", "seq1", 10, 25 ) + setRef2merged = Set( 2, "set1", "seq1", 30, 45 ) + setRef3merged = Set( 3, "set1", "seq1", 50, 80 ) + + nextId = 4 + + lExp = ([setRef1merged, setRef2merged, setRef3merged], nextId) + lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfMergedSetsAndNextId_all_items_in_reference_list_overlap_with_the_same_item_in_subject_list(self): + setRef1 = Set( 1, "set1", "seq1", 10, 20 ) + setRef2 = Set( 2, "set1", "seq1", 15, 25 ) + setRef3 = Set( 3, "set1", "seq1", 20, 30 ) + + lRef = [setRef1, setRef2, setRef3] + + setSubj1 = Set( 1, "set1", "seq1", 12, 35 ) + setSubj2 = Set( 2, "set1", "seq1", 40, 45 ) + setSubj3 = Set( 3, "set1", "seq1", 55, 80 ) + + lSubj = [setSubj1, setSubj2, setSubj3] + + setRef1merged = Set( 1, "set1", "seq1", 10, 35 ) + setSubj2Exp = Set( 4, "set1", "seq1", 40, 45 ) + setSubj3Exp = Set( 5, "set1", "seq1", 55, 80 ) + + nextId = 6 + + lExp = ([setRef1merged, setSubj2Exp, setSubj3Exp], nextId) + lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfMergedSetsAndNextId_two_last_ref_items_overlap_with_last_subject_item(self): + setRef1 = Set( 1, "set1", "seq1", 10, 20 ) + setRef2 = Set( 2, "set1", "seq1", 30, 40 ) + setRef3 = Set( 3, "set1", "seq1", 50, 60 ) + + lRef = [setRef1, setRef2, setRef3] + + setSubj1 = Set( 1, "set1", "seq1", 1, 5 ) + setSubj2 = Set( 2, "set1", "seq1", 6, 9 ) + setSubj3 = Set( 3, "set1", "seq1", 35, 55 ) + + lSubj = [setSubj1, setSubj2, setSubj3] + + setRef1Exp = Set( 1, "set1", "seq1", 10, 20 ) + setRef2merged = Set( 2, "set1", "seq1", 30, 60 ) + setSubj1Exp = Set( 4, "set1", "seq1", 1, 5 ) + setSubj2Exp = Set( 5, "set1", "seq1", 6, 9 ) + + nextId = 6 + + lExp = ([setRef2merged, setRef1Exp, setSubj1Exp, setSubj2Exp], nextId) + lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfMergedSetsAndNextId_all_items_in_reference_list_overlap_with_all_items_in_subject_list(self): + setRef1 = Set( 1, "set1", "seq1", 10, 20 ) + setRef2 = Set( 2, "set1", "seq1", 30, 40 ) + + lRef = [setRef1, setRef2] + + setSubj1 = Set( 1, "set1", "seq1", 10, 20 ) + setSubj2 = Set( 2, "set1", "seq1", 30, 40 ) + + lSubj = [setSubj1, setSubj2] + + setRef1merged = Set( 1, "set1", "seq1", 10, 20 ) + setRef2merged = Set( 2, "set1", "seq1", 30, 40 ) + + nextId = 3 + + lExp = ([setRef1merged, setRef2merged], nextId) + lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfMergedSetsAndNextId_one_item_in_reference_list_overlap_with_all_items_in_subject_list(self): + setRef1 = Set( 1, "set1", "seq1", 10, 20 ) + setRef2 = Set( 2, "set1", "seq1", 30, 40 ) + setRef3 = Set( 3, "set1", "seq1", 50, 60 ) + + lRef = [setRef1, setRef2, setRef3] + + setSubj1 = Set( 1, "set1", "seq1", 11, 13 ) + setSubj2 = Set( 2, "set1", "seq1", 14, 16 ) + setSubj3 = Set( 3, "set1", "seq1", 17, 25 ) + + lSubj = [setSubj1, setSubj2, setSubj3] + + setRef1merged = Set( 1, "set1", "seq1", 10, 25 ) + setRef2Exp = Set( 2, "set1", "seq1", 30, 40 ) + setRef3Exp = Set( 3, "set1", "seq1", 50, 60 ) + + nextId = 4 + + lExp = ([setRef1merged, setRef2Exp, setRef3Exp], nextId) + lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfMergedSetsAndNextId_one_item_in_reference_list_overlap_with_one_item_in_subject_list(self): + setRef1 = Set( 1, "set1", "seq1", 10, 20 ) + setRef2 = Set( 2, "set1", "seq1", 30, 40 ) + setRef3 = Set( 3, "set1", "seq1", 50, 60 ) + + lRef = [setRef1, setRef2, setRef3] + + setSubj1 = Set( 1, "set1", "seq1", 1, 9 ) + setSubj2 = Set( 2, "set1", "seq1", 31, 45 ) + setSubj3 = Set( 3, "set1", "seq1", 70, 80 ) + + lSubj = [setSubj1, setSubj2, setSubj3] + + setRef1Exp = Set( 1, "set1", "seq1", 10, 20 ) + setRef2merged = Set( 2, "set1", "seq1", 30, 45 ) + setRef3Exp = Set( 3, "set1", "seq1", 50, 60 ) + setSubj1Exp = Set( 4, "set1", "seq1", 1, 9 ) + setSubj3Exp = Set( 5, "set1", "seq1", 70, 80 ) + + nextId = 6 + + lExp = ([setRef2merged, setRef1Exp, setRef3Exp, setSubj1Exp, setSubj3Exp], nextId) + + lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfMergedSetsAndNextId_one_item_in_reference_list_overlap_with_one_item_in_subject_list_with_strange_output_order(self): + setRef1 = Set( 5, "set1", "seq1", 10, 20 ) + setRef2 = Set( 6, "set1", "seq1", 30, 40 ) + setRef3 = Set( 7, "set1", "seq1", 50, 60 ) + setRef4 = Set( 8, "set1", "seq1", 90, 92 ) + + lRef = [setRef1, setRef2, setRef3, setRef4] + + setSubj1 = Set( 1, "set1", "seq1", 1, 9 ) + setSubj2 = Set( 2, "set1", "seq1", 35, 45 ) + setSubj3 = Set( 3, "set1", "seq1", 70, 80 ) + setSubj4 = Set( 4, "set1", "seq1", 130, 140 ) + + lSubj = [setSubj1, setSubj2, setSubj3, setSubj4] + + setRef1Exp = Set( 5, "set1", "seq1", 10, 20 ) + setRef2merged = Set( 6, "set1", "seq1", 30, 45 ) + setRef3Exp = Set( 7, "set1", "seq1", 50, 60 ) + setRef4Exp = Set( 8, "set1", "seq1", 90, 92 ) + setSubj1Exp = Set( 9, "set1", "seq1", 1, 9 ) + setSubj3Exp = Set( 10, "set1", "seq1", 70, 80 ) + setSubj4Exp = Set( 11, "set1", "seq1", 130, 140 ) + + nextId = 12 + + lExp = ([setRef2merged, setRef4Exp, setRef1Exp, setRef3Exp, setSubj1Exp, setSubj3Exp, setSubj4Exp], nextId) + + lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfMergedSetsAndNextId_all_items_overlap_between_lists_with_same_length(self): + setRef1 = Set( 1, "set1", "seq1", 10, 20 ) + setRef2 = Set( 2, "set1", "seq1", 30, 40 ) + setRef3 = Set( 3 , "set1", "seq1", 50, 60 ) + + lRef = [setRef1, setRef2, setRef3] + + setSubj1 = Set( 1, "set1", "seq1", 15, 35 ) + setSubj2 = Set( 2, "set1", "seq1", 36, 55 ) + setSubj3 = Set( 3, "set1", "seq1", 56, 65 ) + + lSubj = [setSubj1, setSubj2, setSubj3] + + setRef1merged = Set( 1, "set1", "seq1", 10, 65 ) + + nextId = 4 + + lExp = ([setRef1merged], nextId) + lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfMergedSetsAndNextId_all_items_overlap_between_lists_with_different_length(self): + setRef1 = Set( 1, "set1", "seq1", 10, 20 ) + setRef2 = Set( 2, "set1", "seq1", 30, 40 ) + setRef3 = Set( 3 , "set1", "seq1", 50, 60 ) + + lRef = [setRef1, setRef2, setRef3] + + setSubj1 = Set( 1, "set1", "seq1", 15, 35 ) + setSubj2 = Set( 2, "set1", "seq1", 36, 55 ) + + lSubj = [setSubj1, setSubj2] + + setRef1merged = Set( 1, "set1", "seq1", 10, 60 ) + + nextId = 4 + + lExp = ([setRef1merged], nextId) + lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj) + + self.assertEquals(lObs, lExp) + + def test_getListOfSetWithoutOverlappingBetweenTwoListOfSet(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + set3 = Set( 3, "set1", "seq1", 50, 60 ) + + lSet1 = [set1, set2, set3] + + set4 = Set( 1, "set1", "seq1", 15, 35 ) + set5 = Set( 2, "set1", "seq1", 36, 55 ) + set6 = Set( 3, "set1", "seq1", 66, 95 ) + + lSet2 = [set4, set5, set6] + + expLSet = [set6] + obsLSet = SetUtils.getListOfSetWithoutOverlappingBetweenTwoListOfSet(lSet1, lSet2) + + self.assertEquals(expLSet, obsLSet) + + def test_getListOfSetWithoutOverlappingBetweenTwoListOfSet_Empty_Result(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + set3 = Set( 3, "set1", "seq1", 50, 60 ) + + lSet1 = [set1, set2, set3] + + set4 = Set( 1, "set1", "seq1", 15, 35 ) + set5 = Set( 2, "set1", "seq1", 36, 55 ) + + lSet2 = [set4, set5] + + expLSet = [] + obsLSet = SetUtils.getListOfSetWithoutOverlappingBetweenTwoListOfSet(lSet1, lSet2) + + self.assertEquals(expLSet, obsLSet) + + def test_getListOfSetWithoutOverlappingBetweenTwoListOfSet_Empty_Result_Length_Condition(self): + set1 = Set( 1, "set1", "seq1", 10, 20 ) + set2 = Set( 2, "set1", "seq1", 30, 40 ) + set3 = Set( 3, "set1", "seq1", 50, 60 ) + + lSet1 = [set1, set2, set3] + + set4 = Set( 1, "set1", "seq1", 15, 35 ) + set5 = Set( 2, "set1", "seq1", 36, 55 ) + set6 = Set( 3, "set1", "seq1", 66, 68 ) + + lSet2 = [set4, set5, set6] + + expLSet = [] + obsLSet = SetUtils.getListOfSetWithoutOverlappingBetweenTwoListOfSet(lSet1, lSet2) + + self.assertEquals(expLSet, obsLSet) + + + def test_getSetListFromFile(self): + file = "dummyFile_%s_%s" % ( time.strftime("%Y%m%d%H%M%S"), os.getpid() ) + fileHandler = open( file, "w" ) + fileHandler.write( "1\tseq1\tchr1\t151\t250\n" ) + fileHandler.write( "2\tseq2\tchr2\t301\t500\n" ) + fileHandler.close() + s1 = Set() + s1.setFromTuple( ( "1", "seq1", "chr1", "151", "250" ) ) + s2 = Set() + s2.setFromTuple( ( "2", "seq2", "chr2", "301", "500" ) ) + expLSet = [ s1, s2 ] + obsLSet = SetUtils.getSetListFromFile(file) + os.remove(file) + self.assertEqual( expLSet, obsLSet ) + + + def test_convertSetFileIntoMapFile( self ): + setFile = "dummySetFile" + setFileHandler = open( setFile, "w" ) + setFileHandler.write( "1\tseq31\tchr1\t151\t250\n" ) + setFileHandler.write( "2\tseq27\tchr2\t301\t500\n" ) + setFileHandler.close() + + expFile = "dummyExpFile" + expFileHandler = open( expFile, "w" ) + expFileHandler.write( "seq31\tchr1\t151\t250\n" ) + expFileHandler.write( "seq27\tchr2\t301\t500\n" ) + expFileHandler.close() + + obsFile = "dummyObsFile" + + SetUtils.convertSetFileIntoMapFile( setFile, obsFile ) + + self.assertTrue( FileUtils.are2FilesIdentical( expFile, obsFile ) ) + + for f in [ setFile, expFile, obsFile ]: + os.remove( f ) + + + def test_getDictOfListsWithSeqnameAsKey_empty( self ): + lSets = [] + dExp = {} + dObs = SetUtils.getDictOfListsWithSeqnameAsKey( lSets ) + self.assertEquals( dExp, dObs ) + + + def test_getDictOfListsWithSeqnameAsKey( self ): + lSets = [ Set( 1, "TE3", "chr2", 10, 50 ), + Set( 2, "gene74", "chr1", 31, 800 ), + Set( 3, "TE1", "chr1", 1, 30 ) ] + dExp = { "chr1": [ Set( 2, "gene74", "chr1", 31, 800 ), + Set( 3, "TE1", "chr1", 1, 30 ) ], + "chr2": [ Set( 1, "TE3", "chr2", 10, 50 ) ] } + dObs = SetUtils.getDictOfListsWithSeqnameAsKey( lSets ) + self.assertEquals( dExp, dObs ) + + + def test_filterOnLength( self ): + lSets = [ Set( 1, "TE3", "chr2", 10, 50 ), + Set( 2, "gene74", "chr1", 31, 800 ), + Set( 3, "TE1", "chr1", 1, 30 ) ] + lExp = [ Set( 2, "gene74", "chr1", 31, 800 ) ] + lObs = SetUtils.filterOnLength( lSets, 100 ) + self.assertEqual( lExp, lObs ) + + + def test_getListOfNames( self ): + setFile = "dummySetFile" + setFileHandler = open( setFile, "w" ) + setFileHandler.write( "1\tseq31\tchr1\t151\t250\n" ) + setFileHandler.write( "2\tseq27\tchr2\t301\t500\n" ) + setFileHandler.close() + + lExp = [ "seq31", "seq27" ] + lObs = SetUtils.getListOfNames( setFile ) + + self.assertEquals( lExp, lObs ) + + os.remove( setFile ) + + + def test_getDictOfDictsWithNamesThenIdAsKeyFromFile( self ): + setFile = "dummySetFile" + setFileHandler = open( setFile, "w" ) + setFileHandler.write( "1\tseq31\tchr1\t151\t250\n" ) + setFileHandler.write( "3\tseq27\tchr3\t1\t100\n" ) + setFileHandler.write( "2\tseq27\tchr2\t301\t500\n" ) + setFileHandler.write( "2\tseq27\tchr2\t601\t650\n" ) + setFileHandler.close() + + dExp = { "seq31": { 1: [ Set( 1, "seq31", "chr1", 151, 250 ) ] }, + "seq27": { 2: [ Set( 2, "seq27", "chr2", 301, 500 ), + Set( 2, "seq27", "chr2", 601, 650 ) ], + 3: [ Set( 3, "seq27", "chr3", 1, 100 ) ] + } + } + dObs = SetUtils.getDictOfDictsWithNamesThenIdAsKeyFromFile( setFile ) + + self.assertEquals( dExp, dObs ) + + os.remove( setFile ) + + + def _makeSetListFromTupleList (self, tupleList): + setList = [] + for tuple in tupleList: + set = Set() + set.setFromTuple(tuple) + setList.append(set) + return setList + + +test_suite = unittest.TestSuite() +test_suite.addTest( unittest.makeSuite( Test_SetUtils ) ) +if __name__ == "__main__": + unittest.TextTestRunner(verbosity=2).run( test_suite )