|
6
|
1 # Copyright INRA (Institut National de la Recherche Agronomique)
|
|
|
2 # http://www.inra.fr
|
|
|
3 # http://urgi.versailles.inra.fr
|
|
|
4 #
|
|
|
5 # This software is governed by the CeCILL license under French law and
|
|
|
6 # abiding by the rules of distribution of free software. You can use,
|
|
|
7 # modify and/ or redistribute the software under the terms of the CeCILL
|
|
|
8 # license as circulated by CEA, CNRS and INRIA at the following URL
|
|
|
9 # "http://www.cecill.info".
|
|
|
10 #
|
|
|
11 # As a counterpart to the access to the source code and rights to copy,
|
|
|
12 # modify and redistribute granted by the license, users are provided only
|
|
|
13 # with a limited warranty and the software's author, the holder of the
|
|
|
14 # economic rights, and the successive licensors have only limited
|
|
|
15 # liability.
|
|
|
16 #
|
|
|
17 # In this respect, the user's attention is drawn to the risks associated
|
|
|
18 # with loading, using, modifying and/or developing or reproducing the
|
|
|
19 # software by the user in light of its specific status of free software,
|
|
|
20 # that may mean that it is complicated to manipulate, and that also
|
|
|
21 # therefore means that it is reserved for developers and experienced
|
|
|
22 # professionals having in-depth computer knowledge. Users are therefore
|
|
|
23 # encouraged to load and test the software's suitability as regards their
|
|
|
24 # requirements in conditions enabling the security of their systems and/or
|
|
|
25 # data to be ensured and, more generally, to use and operate it in the
|
|
|
26 # same conditions as regards security.
|
|
|
27 #
|
|
|
28 # The fact that you are presently reading this means that you have had
|
|
|
29 # knowledge of the CeCILL license and that you accept its terms.
|
|
|
30
|
|
|
31
|
|
|
32 import unittest
|
|
|
33 import os
|
|
|
34 import time
|
|
|
35 from commons.core.coord.Set import Set
|
|
|
36 from commons.core.coord.Map import Map
|
|
|
37 from commons.core.coord.SetUtils import SetUtils
|
|
|
38 from commons.core.utils.FileUtils import FileUtils
|
|
|
39
|
|
|
40
|
|
|
41 class Test_SetUtils( unittest.TestCase ):
|
|
|
42
|
|
|
43 def test_changeIdInList_on_empty_list(self):
|
|
|
44 lSets = []
|
|
|
45 SetUtils.changeIdInList( lSets , 1 )
|
|
|
46 obsLSets = lSets
|
|
|
47 expLSets = []
|
|
|
48 self.assertEquals( expLSets , obsLSets )
|
|
|
49
|
|
|
50 def test_changeIdInList_on_list_size_one(self):
|
|
|
51 set1 = Set( 1, "set1", "seq1", 1, 2 )
|
|
|
52 lSets = [ set1 ]
|
|
|
53 SetUtils.changeIdInList( lSets , 9 )
|
|
|
54 obsLSets = lSets
|
|
|
55 set1 = Set( 9, "set1", "seq1", 1, 2 )
|
|
|
56 expLSets = [ set1 ]
|
|
|
57 self.assertEquals( expLSets , obsLSets )
|
|
|
58
|
|
|
59 def test_changeIdInList(self):
|
|
|
60 set1 = Set( 1, "set1", "seq1", 1, 2 )
|
|
|
61 set2 = Set( 2, "set2", "seq2", 2, 3 )
|
|
|
62 lSets = [ set1, set2 ]
|
|
|
63 SetUtils.changeIdInList( lSets , 9 )
|
|
|
64 obsLSets = lSets
|
|
|
65 set1 = Set( 9, "set1", "seq1", 1, 2 )
|
|
|
66 set2 = Set( 9, "set2", "seq2", 2, 3 )
|
|
|
67 expLSets = [ set1, set2 ]
|
|
|
68
|
|
|
69 self.assertEquals( expLSets , obsLSets )
|
|
|
70
|
|
|
71 def test_getOverlapLengthBetweenLists_all_list_are_empty (self):
|
|
|
72 lSets1 = []
|
|
|
73 lSets2 = []
|
|
|
74
|
|
|
75 expOverlapSize = 0
|
|
|
76 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
77
|
|
|
78 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
79
|
|
|
80 def test_getOverlapLengthBetweenLists_list1_empty_list2_size_one (self):
|
|
|
81 lSets1 = []
|
|
|
82 lSets2 = [ Set( 9, "set1", "seq1", 1, 2 ) ]
|
|
|
83
|
|
|
84 expOverlapSize = 0
|
|
|
85 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
86
|
|
|
87 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
88
|
|
|
89 def test_getOverlapLengthBetweenLists_list1_empty_list2_size_two (self):
|
|
|
90 lSets1 = []
|
|
|
91 lSets2 = [ Set( 9, "set1", "seq1", 1, 2 ), Set( 9, "set2", "seq2", 2, 3 ) ]
|
|
|
92
|
|
|
93 expOverlapSize = 0
|
|
|
94 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
95
|
|
|
96 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
97
|
|
|
98 def test_getOverlapLengthBetweenLists_list1_size_one_list2_empty (self):
|
|
|
99 lSets1 = [ Set( 9, "set1", "seq1", 1, 2 ) ]
|
|
|
100 lSets2 = []
|
|
|
101
|
|
|
102 expOverlapSize = 0
|
|
|
103 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
104
|
|
|
105 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
106
|
|
|
107 def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_one_without_overlapp (self):
|
|
|
108 lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ) ]
|
|
|
109 lSets2 = [ Set( 2, "set2", "seq2", 2, 3 ) ]
|
|
|
110
|
|
|
111 expOverlapSize = 0
|
|
|
112 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
113
|
|
|
114 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
115
|
|
|
116 def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_one_with_overlap_size_1 (self):
|
|
|
117 lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ) ]
|
|
|
118 lSets2 = [ Set( 2, "set1", "seq1", 2, 3 ) ]
|
|
|
119
|
|
|
120 expOverlapSize = 1
|
|
|
121 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
122
|
|
|
123 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
124
|
|
|
125 def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_one_with_overlap_size_2 (self):
|
|
|
126 lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ) ]
|
|
|
127 lSets2 = [ Set( 2, "set1", "seq1", 1, 3 ) ]
|
|
|
128
|
|
|
129 expOverlapSize = 2
|
|
|
130 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
131
|
|
|
132 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
133
|
|
|
134 def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_two_without_overlap_sets_in_list1_greater_than_sets_in_list2 (self):
|
|
|
135 lSets1 = [ Set( 1, "set1", "seq1", 4, 6 ) ]
|
|
|
136 lSets2 = [ Set( 2, "set2", "seq1", 2, 3 ), Set( 3, "set3", "seq3", 1, 2 ) ]
|
|
|
137
|
|
|
138 expOverlapSize = 0
|
|
|
139 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
140
|
|
|
141 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
142
|
|
|
143 def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_two_with_overlap_sets_in_list1_greater_than_sets_in_list2 (self):
|
|
|
144 lSets1 = [ Set( 1, "set1", "seq1", 4, 6 ) ]
|
|
|
145 lSets2 = [ Set( 2, "set2", "seq2", 2, 3 ), Set( 3, "set3", "seq1", 4, 5 ) ]
|
|
|
146
|
|
|
147 expOverlapSize = 2
|
|
|
148 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
149
|
|
|
150 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
151
|
|
|
152 def test_getOverlapLengthBetweenLists_list1_size_one_list2_size_two_with_overlap_on_redundant_position (self):
|
|
|
153 lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ) ]
|
|
|
154 lSets2 = [ Set( 2, "set2", "seq1", 2, 3 ), Set( 3, "set1", "seq1", 1, 2 ) ]
|
|
|
155
|
|
|
156 expOverlapSize = 3
|
|
|
157 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
158
|
|
|
159 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
160
|
|
|
161 def test_getOverlapLengthBetweenLists_list1_size_two_list2_empty (self):
|
|
|
162 lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ), Set( 2, "set2", "seq2", 2, 3 ) ]
|
|
|
163 lSets2 = []
|
|
|
164
|
|
|
165 expOverlapSize = 0
|
|
|
166 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
167
|
|
|
168 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
169
|
|
|
170 def test_getOverlapLengthBetweenLists_on_different_seq_names (self):
|
|
|
171 lSets1 = [ Set( 1, "set1", "seq1", 1, 2 ), Set( 2, "set2", "seq2", 2, 3 ) ]
|
|
|
172 lSets2 = [ Set( 3, "set1", "seq2", 4, 5 ), Set( 5, "set2", "seq4", 2, 3 ) ]
|
|
|
173
|
|
|
174 expOverlapSize = 0
|
|
|
175 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
176
|
|
|
177 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
178
|
|
|
179 def test_getOverlapLengthBetweenLists_list1_size_two_list2_size_two_with_overlap (self):
|
|
|
180 lSets1 = [ Set( 1, "set1", "seq1", 1, 6 ), Set( 2, "set2", "seq2", 2, 3 ) ]
|
|
|
181 lSets2 = [ Set( 3, "set1", "seq1", 1, 2 ), Set( 2, "set2", "seq3", 2, 3 ) ]
|
|
|
182
|
|
|
183 expOverlapSize = 2
|
|
|
184 obsOverlapSize = SetUtils.getOverlapLengthBetweenLists( lSets1, lSets2 )
|
|
|
185
|
|
|
186 self.assertEquals( expOverlapSize, obsOverlapSize )
|
|
|
187
|
|
|
188 def test_areSetsOverlappingBetweenLists_list2_empty(self):
|
|
|
189 tuple1 = ("1","chr1","seq1", "100","110")
|
|
|
190 tuple2 = ("1","chr1","seq1", "200","220")
|
|
|
191 tuple3 = ("1","chr1","seq1", "300","330")
|
|
|
192 setList1 = self._makeSetListFromTupleList([tuple1, tuple2, tuple3])
|
|
|
193
|
|
|
194 setList2 = []
|
|
|
195
|
|
|
196 expRes = False
|
|
|
197 obsRes = SetUtils.areSetsOverlappingBetweenLists( setList1, setList2 )
|
|
|
198
|
|
|
199 self.assertEquals( expRes, obsRes )
|
|
|
200
|
|
|
201 def test_areSetsOverlappingBetweenLists_list2_size1(self):
|
|
|
202 tuple1 = ("1","chr1","seq1", "9","11")
|
|
|
203 tuple2 = ("1","chr1","seq1", "20","22")
|
|
|
204 tuple3 = ("1","chr1","seq1", "30","33")
|
|
|
205 setList1 = self._makeSetListFromTupleList( [ tuple1, tuple2, tuple3 ] )
|
|
|
206
|
|
|
207 tuple11 = ("1","chr1", "seq1", "8","11")
|
|
|
208 setList2 = self._makeSetListFromTupleList( [ tuple11 ] )
|
|
|
209
|
|
|
210 expRes = True
|
|
|
211 obsRes = SetUtils.areSetsOverlappingBetweenLists( setList1, setList2 )
|
|
|
212
|
|
|
213 self.assertEquals( expRes, obsRes )
|
|
|
214
|
|
|
215 def test_areSetsOverlappingBetweenLists_list1_greater_list2(self):
|
|
|
216 tuple1 = ("1","chr1","seq1","100","110")
|
|
|
217 tuple2 = ("1","chr1","seq1","200","220")
|
|
|
218 tuple3 = ("1","chr1","seq1","300","330")
|
|
|
219 setList1 = self._makeSetListFromTupleList( [ tuple1, tuple2, tuple3 ] )
|
|
|
220
|
|
|
221 tuple11 = ("1","chr1","seq1", "10","11")
|
|
|
222 tuple22 = ("1","chr1","seq1", "20","22")
|
|
|
223 tuple33 = ("1","chr1","seq1", "30","33")
|
|
|
224 setList2 = self._makeSetListFromTupleList( [ tuple11, tuple22, tuple33 ] )
|
|
|
225
|
|
|
226 expRes = False
|
|
|
227 obsRes = SetUtils.areSetsOverlappingBetweenLists( setList1, setList2 )
|
|
|
228
|
|
|
229 self.assertEquals( expRes, obsRes )
|
|
|
230
|
|
|
231 def test_areSetsOverlappingBetweenLists_unordered_first_item_of_list1_greater_second_item_smaller(self):
|
|
|
232 tuple1 = ("1","chr1","seq1","400","440")
|
|
|
233 tuple2 = ("1","chr1","seq1","1","11")
|
|
|
234 setList1 = self._makeSetListFromTupleList( [ tuple1, tuple2 ] )
|
|
|
235
|
|
|
236 tuple11 = ("1","chr1","seq1","15","17")
|
|
|
237 tuple22 = ("1","chr1","seq1", "20","22")
|
|
|
238 tuple33 = ("1","chr1","seq1","30","33")
|
|
|
239 setList2 = self._makeSetListFromTupleList( [ tuple11, tuple22, tuple33 ] )
|
|
|
240
|
|
|
241 expRes = False
|
|
|
242 obsRes = SetUtils.areSetsOverlappingBetweenLists( setList1, setList2 )
|
|
|
243
|
|
|
244 self.assertEquals( expRes, obsRes )
|
|
|
245
|
|
|
246 def test_areSetsOverlappingBetweenLists_unorderd_second_item_of_list1_overlap_first_item(self):
|
|
|
247 tuple1 = ("1","chr1","seq1","400","440")
|
|
|
248 tuple2 = ("1","chr1","seq1", "1","18")
|
|
|
249 setList1 = self._makeSetListFromTupleList( [ tuple1, tuple2 ] )
|
|
|
250
|
|
|
251 tuple11 = ("1","chr1","seq1","15","17")
|
|
|
252 tuple22 = ("1","chr1","seq1","20","22")
|
|
|
253 tuple33 = ("1","chr1","seq1","30","33")
|
|
|
254 setList2 = self._makeSetListFromTupleList( [ tuple11, tuple22, tuple33 ] )
|
|
|
255
|
|
|
256 expRes = True
|
|
|
257 obsRes = SetUtils.areSetsOverlappingBetweenLists( setList1, setList2 )
|
|
|
258
|
|
|
259 self.assertEquals( expRes, obsRes )
|
|
|
260
|
|
|
261 def test_areSetsOverlappingBetweenLists_last_item_list1_overlap_last_item_list2(self):
|
|
|
262 tuple1 = ("1","chr1","seq1","400","440")
|
|
|
263 tuple2 = ("1","chr1","seq1","320","340")
|
|
|
264 pathList1 = self._makeSetListFromTupleList( [ tuple1, tuple2 ] )
|
|
|
265
|
|
|
266 tuple11 = ("1","chr1","seq1","100","110")
|
|
|
267 tuple22 = ("1","chr1","seq1","200","220")
|
|
|
268 tuple33 = ("1","chr1","seq1","300","330")
|
|
|
269 pathList2 = self._makeSetListFromTupleList( [ tuple11, tuple22, tuple33 ] )
|
|
|
270
|
|
|
271 expRes = True
|
|
|
272 obsRes = SetUtils.areSetsOverlappingBetweenLists( pathList1, pathList2 )
|
|
|
273
|
|
|
274 self.assertEquals( expRes, obsRes )
|
|
|
275
|
|
|
276 def test_getCumulLength_empty_list(self):
|
|
|
277 lSets = []
|
|
|
278
|
|
|
279 expSize = 0
|
|
|
280 obsSize = SetUtils.getCumulLength( lSets )
|
|
|
281
|
|
|
282 self.assertEquals( expSize, obsSize )
|
|
|
283
|
|
|
284 def test_getCumulLength_1_item(self):
|
|
|
285 lSets = [ Set( 1, "set1", "seq1", 1, 6 ) ]
|
|
|
286
|
|
|
287 expSize = 6
|
|
|
288 obsSize = SetUtils.getCumulLength( lSets )
|
|
|
289
|
|
|
290 self.assertEquals( expSize, obsSize )
|
|
|
291
|
|
|
292 def test_getCumulLength_2_items(self):
|
|
|
293 lSets = [ Set( 1, "set1", "seq1", 1, 6 ), Set( 1, "set1", "seq1", 1, 2 ) ]
|
|
|
294
|
|
|
295 expSize = 8
|
|
|
296 obsSize = SetUtils.getCumulLength( lSets )
|
|
|
297
|
|
|
298 self.assertEquals( expSize, obsSize )
|
|
|
299
|
|
|
300 def test_getCumulLength_complex(self):
|
|
|
301 set8 = Set(498, "(TACATA)25", "Mela_Blaster_Grouper_611_MAP_20", 17, 348)
|
|
|
302 set5 = Set(502, "(GGAGA)2", "Mela_Blaster_Grouper_611_MAP_20", 356, 366)
|
|
|
303 set6 = Set(503, "(TTTAAAGAACCC)2", "Mela_Blaster_Grouper_611_MAP_20", 433, 457)
|
|
|
304 set7 = Set(504, "(TATAA)2", "Mela_Blaster_Grouper_611_MAP_20", 484, 495)
|
|
|
305 lSets = [ set8, set5, set6, set7 ]
|
|
|
306 expSize = 380
|
|
|
307 obsSize = SetUtils.getCumulLength( lSets )
|
|
|
308
|
|
|
309 self.assertEquals( expSize, obsSize )
|
|
|
310
|
|
|
311 def test_getListBoundaries_one_set(self):
|
|
|
312 lSets = [ Set( 1, "set1", "seq1", 3, 8 ) ]
|
|
|
313
|
|
|
314 expTuple = ( 3, 8 )
|
|
|
315 obsTuple = SetUtils.getListBoundaries( lSets )
|
|
|
316
|
|
|
317 self.assertEquals( expTuple, obsTuple )
|
|
|
318
|
|
|
319 def test_getListBoundaries_two_sets(self):
|
|
|
320 lSets = [ Set( 1, "set1", "seq1", 3, 8 ), Set( 2, "set2", "seq2", 5, 10 ) ]
|
|
|
321
|
|
|
322 expTuple = ( 3, 10 )
|
|
|
323 obsTuple = SetUtils.getListBoundaries( lSets )
|
|
|
324
|
|
|
325 self.assertEquals( expTuple, obsTuple )
|
|
|
326
|
|
|
327 def test_writeListInFile_empty_list(self):
|
|
|
328 lSets = [ ]
|
|
|
329 expFileName = "expFileName"
|
|
|
330 fileHandle = open(expFileName, "w")
|
|
|
331 fileHandle.close()
|
|
|
332
|
|
|
333 obsFileName = "obsFileName"
|
|
|
334 fileHandle = open(obsFileName, "w")
|
|
|
335 SetUtils.writeListInFile(lSets, obsFileName, "w")
|
|
|
336 fileHandle.close()
|
|
|
337
|
|
|
338 self.assertTrue( FileUtils.are2FilesIdentical( expFileName, obsFileName ) )
|
|
|
339
|
|
|
340 os.remove(obsFileName)
|
|
|
341 os.remove(expFileName)
|
|
|
342
|
|
|
343 def test_writeListInFile_list_one_set(self):
|
|
|
344 lSets = [ Set( 1, "set1", "seq1", 3, 8 ) ]
|
|
|
345 line = "1\tset1\tseq1\t3\t8\n"
|
|
|
346 expFileName = "expFileName"
|
|
|
347
|
|
|
348 fileHandle = open(expFileName, "w")
|
|
|
349 fileHandle.write(line)
|
|
|
350 fileHandle.close()
|
|
|
351
|
|
|
352 obsFileName = "obsFileName"
|
|
|
353 fileHandle = open(obsFileName, "w")
|
|
|
354 SetUtils.writeListInFile(lSets, obsFileName, "w")
|
|
|
355 fileHandle.close()
|
|
|
356
|
|
|
357 self.assertTrue( FileUtils.are2FilesIdentical( expFileName, obsFileName ) )
|
|
|
358
|
|
|
359 os.remove(obsFileName)
|
|
|
360 os.remove(expFileName)
|
|
|
361
|
|
|
362
|
|
|
363 def test_getDictOfListsWithIdAsKey_empty_list( self ):
|
|
|
364 lSets = []
|
|
|
365 expDic = {}
|
|
|
366 obsDic = SetUtils.getDictOfListsWithIdAsKey( lSets )
|
|
|
367 self.assertEquals( expDic, obsDic )
|
|
|
368
|
|
|
369
|
|
|
370 def test_getDictOfListsWithIdAsKey_one_set( self ):
|
|
|
371 lSets = [ Set( 2, "set2", "seq2", 3, 8 ) ]
|
|
|
372 expDic = { 2: [ Set( 2, "set2", "seq2", 3, 8 ) ] }
|
|
|
373 obsDic = SetUtils.getDictOfListsWithIdAsKey( lSets )
|
|
|
374 self.assertEquals( expDic, obsDic )
|
|
|
375
|
|
|
376
|
|
|
377 def test_getDictOfListsWithIdAsKey_two_sets_with_same_id( self ):
|
|
|
378 lSets = [ Set( 2, "set2", "seq2", 10, 50 ), Set( 2, "set2", "seq2", 3, 8 )]
|
|
|
379 expDic = { 2: [Set( 2, "set2", "seq2", 10, 50 ), Set( 2, "set2", "seq2", 3, 8 )] }
|
|
|
380 obsDic = SetUtils.getDictOfListsWithIdAsKey( lSets )
|
|
|
381 self.assertEquals( expDic, obsDic )
|
|
|
382
|
|
|
383
|
|
|
384 def test_getDictOfListsWithIdAsKey_sets_with_3_different_id( self ):
|
|
|
385 set1 = Set( 1, "set2", "seq2", 10, 50 )
|
|
|
386 set2 = Set( 1, "set2", "seq2", 20, 50 )
|
|
|
387 set3 = Set( 2, "set2", "seq2", 30, 50 )
|
|
|
388 set4 = Set( 2, "set2", "seq2", 40, 50 )
|
|
|
389 set5 = Set( 3, "set2", "seq2", 1, 2 )
|
|
|
390 lSets = [ set1, set2, set3, set4, set5 ]
|
|
|
391 expDic = { 1: [set1, set2],
|
|
|
392 2: [set3, set4],
|
|
|
393 3: [set5] }
|
|
|
394 obsDic = SetUtils.getDictOfListsWithIdAsKey( lSets )
|
|
|
395 self.assertEquals( expDic, obsDic )
|
|
|
396
|
|
|
397
|
|
|
398 def test_getDictOfListsWithIdAsKeyFromFile(self):
|
|
|
399 setFile = "dummySetFile"
|
|
|
400 setFileHandler = open( setFile, "w" )
|
|
|
401 setFileHandler.write( "1\tseq31\tchr1\t151\t250\n" )
|
|
|
402 setFileHandler.write( "2\tseq27\tchr2\t301\t500\n" )
|
|
|
403 setFileHandler.write( "2\tseq27\tchr2\t601\t650\n" )
|
|
|
404 setFileHandler.close()
|
|
|
405
|
|
|
406 dExp = { 1: [ Set( 1, "seq31", "chr1", 151, 250 ) ],
|
|
|
407 2: [ Set( 2, "seq27", "chr2", 301, 500 ),
|
|
|
408 Set( 2, "seq27", "chr2", 601, 650 ) ] }
|
|
|
409 dObs = SetUtils.getDictOfListsWithIdAsKeyFromFile( setFile )
|
|
|
410
|
|
|
411 self.assertEquals( dExp, dObs )
|
|
|
412
|
|
|
413 os.remove( setFile )
|
|
|
414
|
|
|
415
|
|
|
416 def test_getMapListFromSetList_empty_list(self):
|
|
|
417 lSets = []
|
|
|
418
|
|
|
419 expLMap = []
|
|
|
420 obsLMap = SetUtils.getMapListFromSetList(lSets)
|
|
|
421
|
|
|
422 self.assertEquals(expLMap, obsLMap)
|
|
|
423
|
|
|
424 def test_getMapListFromSetList_one_set(self):
|
|
|
425 lSets = [ Set( 1, "set", "seq1", 1, 6 )]
|
|
|
426 map1 = Map("set::1","seq1",1,6)
|
|
|
427
|
|
|
428 expLMap = [ map1 ]
|
|
|
429 obsLMap = SetUtils.getMapListFromSetList(lSets)
|
|
|
430
|
|
|
431 self.assertEquals(expLMap, obsLMap)
|
|
|
432
|
|
|
433 def test_getMapListFromSetList_two_sets(self):
|
|
|
434 lSets = [ Set( 1, "set", "seq1", 1, 6 ), Set( 2, "set", "seq2", 3, 8 ) ]
|
|
|
435 map1 = Map("set::1","seq1",1,6)
|
|
|
436 map2 = Map("set::2","seq2",3,8)
|
|
|
437
|
|
|
438 expLMap = [ map1, map2 ]
|
|
|
439 obsLMap = SetUtils.getMapListFromSetList(lSets)
|
|
|
440
|
|
|
441 self.assertEquals(expLMap, obsLMap)
|
|
|
442
|
|
|
443 def test_getSetListFromMapList_empty_list(self):
|
|
|
444 lMap =[]
|
|
|
445 expLSets = []
|
|
|
446 obsLSets = SetUtils.getSetListFromMapList(lMap)
|
|
|
447
|
|
|
448 self.assertEquals(expLSets, obsLSets)
|
|
|
449
|
|
|
450 def test_getSetListFromMapList_one_map(self):
|
|
|
451 map1 = Map( "map1","seq1",1,6)
|
|
|
452 lMap =[ map1 ]
|
|
|
453 expLSets = [ Set( 1, "map1", "seq1", 1, 6 ) ]
|
|
|
454 obsLSets = SetUtils.getSetListFromMapList(lMap)
|
|
|
455
|
|
|
456 self.assertEquals(expLSets, obsLSets)
|
|
|
457
|
|
|
458 def test_getSetListFromMapList_two_maps(self):
|
|
|
459 map1 = Map( "map1","seq1",1,6)
|
|
|
460 map2 = Map( "map2","seq2",3,8)
|
|
|
461 lMap =[ map1,map2 ]
|
|
|
462 expLSets = [ Set( 1, "map1", "seq1", 1, 6 ), Set( 2, "map2", "seq2", 3, 8 ) ]
|
|
|
463 obsLSets = SetUtils.getSetListFromMapList(lMap)
|
|
|
464
|
|
|
465 self.assertEquals(expLSets, obsLSets)
|
|
|
466
|
|
|
467 def test_getSetListFromMapList_list_with_one_empty_map(self):
|
|
|
468 map1 = Map( "map1","seq1",1,6)
|
|
|
469 map2 = Map()
|
|
|
470 lMap =[ map1,map2 ]
|
|
|
471 expLSets = [ Set( 1, "map1", "seq1", 1, 6 ), Set(2, ) ]
|
|
|
472 obsLSets = SetUtils.getSetListFromMapList(lMap)
|
|
|
473
|
|
|
474 self.assertEquals(expLSets, obsLSets)
|
|
|
475
|
|
|
476 def test_mergeSetsInList(self):
|
|
|
477 set1 = Set( 1, "set1", "seq1", 1, 6 )
|
|
|
478 set2 = Set( 2, "set2", "seq1", 3, 6 )
|
|
|
479 set3 = Set( 3, "set3", "seq1", 3, 5 )
|
|
|
480 set4 = Set( 4, "set4", "seq1", 1, 2 )
|
|
|
481 lSets = [ set1, set2, set3, set4 ]
|
|
|
482
|
|
|
483 obsList = SetUtils.mergeSetsInList( lSets )
|
|
|
484 expList = [ Set( 1, "set1", "seq1", 1, 6 ) ]
|
|
|
485
|
|
|
486 self.assertEquals( expList, obsList )
|
|
|
487
|
|
|
488
|
|
|
489 def test_mergeSetsInList_with_reverse_only(self):
|
|
|
490 set1 = Set( 1, "set1", "seq1", 6, 1 )
|
|
|
491 set2 = Set( 2, "set2", "seq1", 6, 3 )
|
|
|
492 set3 = Set( 3, "set3", "seq1", 5, 3 )
|
|
|
493 set4 = Set( 4, "set4", "seq1", 2, 1 )
|
|
|
494 lSets = [ set1, set2, set3, set4 ]
|
|
|
495
|
|
|
496 obsList = SetUtils.mergeSetsInList( lSets )
|
|
|
497 expList = [ Set( 1, "set1", "seq1", 6, 1 ) ]
|
|
|
498
|
|
|
499 self.assertEquals( expList, obsList )
|
|
|
500
|
|
|
501
|
|
|
502 def test_mergeSetsInList_with_direct_and_reverse(self):
|
|
|
503 set1 = Set( 1, "set1", "seq1", 6, 1 )
|
|
|
504 set2 = Set( 2, "set2", "seq1", 6, 3 )
|
|
|
505 set3 = Set( 3, "set3", "seq1", 3, 5 )
|
|
|
506 set4 = Set( 4, "set4", "seq1", 2, 1 )
|
|
|
507 lSets = [ set1, set2, set3, set4 ]
|
|
|
508
|
|
|
509 obsList = SetUtils.mergeSetsInList( lSets )
|
|
|
510 expList = [ set1 ]
|
|
|
511
|
|
|
512 self.assertEquals( expList, obsList )
|
|
|
513
|
|
|
514
|
|
|
515 def test_mergeSetsInList_with_empty_set(self):
|
|
|
516 set1 = Set( 1, "set1", "seq1", 1, 6 )
|
|
|
517 set2 = Set()
|
|
|
518 set3 = Set( 3, "set3", "seq1", 3, 5 )
|
|
|
519 set4 = Set( 4, "set4", "seq1", 1, 2 )
|
|
|
520 lSets = [ set1, set2, set3, set4 ]
|
|
|
521
|
|
|
522 obsList = SetUtils.mergeSetsInList( lSets )
|
|
|
523 expList = [ set2, set1 ]
|
|
|
524
|
|
|
525 self.assertEquals( expList, obsList )
|
|
|
526
|
|
|
527
|
|
|
528 def test_mergeSetsInList_empty_list(self):
|
|
|
529 lSets = []
|
|
|
530
|
|
|
531 obsList = SetUtils.mergeSetsInList( lSets )
|
|
|
532 expList = []
|
|
|
533
|
|
|
534 self.assertEquals( expList, obsList )
|
|
|
535
|
|
|
536
|
|
|
537 def test_mergeSetsInList_one_set (self):
|
|
|
538 set1 = Set( 1, "set1", "seq1", 1, 6 )
|
|
|
539 lSets = [ set1 ]
|
|
|
540
|
|
|
541 obsLSets = SetUtils.mergeSetsInList( lSets )
|
|
|
542 expLSets = [ set1 ]
|
|
|
543
|
|
|
544 self.assertEquals( expLSets, obsLSets )
|
|
|
545
|
|
|
546
|
|
|
547 def test_mergeSetsInList_diffSeqnames_without_overlapping(self):
|
|
|
548 set1 = Set( 1, "set1", "seq1", 1, 6 )
|
|
|
549 set2 = Set( 1, "set2", "seq2", 11, 16 )
|
|
|
550 lSets = [ set1, set2 ]
|
|
|
551
|
|
|
552 obsLSets = SetUtils.mergeSetsInList( lSets )
|
|
|
553 expLSets = [ set1, set2 ]
|
|
|
554
|
|
|
555 self.assertEquals( expLSets, obsLSets )
|
|
|
556
|
|
|
557
|
|
|
558 def test_mergeSetsInList_diffSeqnames_overlapping(self):
|
|
|
559 set1 = Set( 1, "set1", "seq1", 1, 6 )
|
|
|
560 set2 = Set( 1, "set2", "seq2", 2, 5 )
|
|
|
561 lSets = [ set1, set2 ]
|
|
|
562
|
|
|
563 obsLSets = SetUtils.mergeSetsInList( lSets )
|
|
|
564 expLSets = [ set1, set2 ]
|
|
|
565
|
|
|
566 self.assertEquals( expLSets, obsLSets )
|
|
|
567
|
|
|
568
|
|
|
569 def test_mergeSetsInList_sameSeqnames_without_overlapping(self):
|
|
|
570 set1 = Set( 1, "set1", "seq1", 1, 6 )
|
|
|
571 set2 = Set( 1, "set2", "seq1", 11, 16 )
|
|
|
572 lSets = [ set1, set2 ]
|
|
|
573
|
|
|
574 obsLSets = SetUtils.mergeSetsInList( lSets )
|
|
|
575 expLSets = [ set1, set2 ]
|
|
|
576
|
|
|
577 self.assertEquals( expLSets, obsLSets )
|
|
|
578
|
|
|
579 def test_mergeSetsInList_complex(self):
|
|
|
580 set1 = Set(498, "(ACATATAATAA)10", "Mela_Blaster_Grouper_611_MAP_20", 77, 181)
|
|
|
581 set2 = Set(499, "(TACATA)25", "Mela_Blaster_Grouper_611_MAP_20", 17, 166)
|
|
|
582 set3 = Set(500, "(ATAAAATAC)26", "Mela_Blaster_Grouper_611_MAP_20", 94, 348)
|
|
|
583 set4 = Set(501, "(TAA)15", "Mela_Blaster_Grouper_611_MAP_20", 257, 303)
|
|
|
584 set5 = Set(502, "(GGAGA)2", "Mela_Blaster_Grouper_611_MAP_20", 356, 366)
|
|
|
585 set6 = Set(503, "(TTTAAAGAACCC)2", "Mela_Blaster_Grouper_611_MAP_20", 433, 457)
|
|
|
586 set7 = Set(504, "(TATAA)2", "Mela_Blaster_Grouper_611_MAP_20", 484, 495)
|
|
|
587 lSets = [ set1, set2, set3, set4, set5, set6, set7 ]
|
|
|
588 obsLSets = SetUtils.mergeSetsInList( lSets )
|
|
|
589
|
|
|
590 set8 = Set(498, "(TACATA)25", "Mela_Blaster_Grouper_611_MAP_20", 17, 348)
|
|
|
591
|
|
|
592 expLSets = [ set8, set5, set6, set7 ]
|
|
|
593
|
|
|
594 self.assertEquals( expLSets, obsLSets )
|
|
|
595
|
|
|
596 def test_getSetListUnjoined_listToKeep_empty_listToUnjoin_empty (self):
|
|
|
597 setListToKeep = []
|
|
|
598 setListToUnjoin = []
|
|
|
599
|
|
|
600 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
601 expLSets = []
|
|
|
602
|
|
|
603 self.assertEquals(expLSets, obsLSets)
|
|
|
604
|
|
|
605 def test_getSetListUnjoined_listToKeep_empty (self):
|
|
|
606 setListToKeep = []
|
|
|
607
|
|
|
608 setUnjoin1 = Set( 1, "set", "seq", 1, 3 )
|
|
|
609 setUnjoin2 = Set( 1, "set", "seq", 2, 3 )
|
|
|
610 setUnjoin3 = Set( 1, "set", "seq", 5, 7 )
|
|
|
611 setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3 ]
|
|
|
612
|
|
|
613 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
614 expLSets = [ setListToUnjoin ]
|
|
|
615
|
|
|
616 self.assertEquals(expLSets, obsLSets)
|
|
|
617
|
|
|
618 def test_getSetListUnjoined_listToKeep_empty_listToUnjoin_size1 (self):
|
|
|
619 setListToKeep = []
|
|
|
620
|
|
|
621 setUnjoin = Set( 1, "set", "seq", 1, 3 )
|
|
|
622 setListToUnjoin = [ setUnjoin ]
|
|
|
623
|
|
|
624 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
625 expLSets = [ setListToUnjoin ]
|
|
|
626
|
|
|
627 self.assertEquals(expLSets, obsLSets)
|
|
|
628
|
|
|
629 def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_empty (self):
|
|
|
630 setKeep = Set( 1, "set", "seq", 1, 3 )
|
|
|
631 setListToKeep = [ setKeep ]
|
|
|
632
|
|
|
633 setListToUnjoin = []
|
|
|
634
|
|
|
635 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
636 expLSets = []
|
|
|
637
|
|
|
638 self.assertEquals(expLSets, obsLSets)
|
|
|
639
|
|
|
640 def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_size1 (self):
|
|
|
641 setKeep = Set( 1, "set", "seq", 1, 3 )
|
|
|
642 setListToKeep = [ setKeep ]
|
|
|
643
|
|
|
644 setUnjoin = Set( 1, "set", "seq", 5, 9 )
|
|
|
645 setListToUnjoin = [ setUnjoin ]
|
|
|
646
|
|
|
647 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
648 expLSets = [ setListToUnjoin ]
|
|
|
649
|
|
|
650 self.assertEquals(expLSets, obsLSets)
|
|
|
651
|
|
|
652 def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_size2_noSplit_item_in_listToKeep_smaller_item_in_listToUnjoin (self):
|
|
|
653 setKeep = Set( 1, "set", "seq", 1, 3 )
|
|
|
654 setListToKeep = [ setKeep ]
|
|
|
655
|
|
|
656 setUnjoin1 = Set( 1, "set", "seq", 5, 9 )
|
|
|
657 setUnjoin2 = Set( 1, "set", "seq", 11, 16 )
|
|
|
658 setListToUnjoin = [ setUnjoin1, setUnjoin2 ]
|
|
|
659
|
|
|
660 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
661 expLSets = [ setListToUnjoin ]
|
|
|
662
|
|
|
663 self.assertEquals(expLSets, obsLSets)
|
|
|
664
|
|
|
665 def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_size3_noSplit_item_in_listToKeep_smaller_item_in_listToUnjoin (self):
|
|
|
666 setKeep = Set( 1, "set", "seq", 1, 3 )
|
|
|
667 setListToKeep = [ setKeep ]
|
|
|
668
|
|
|
669 setUnjoin1 = Set( 1, "set", "seq", 5, 9 )
|
|
|
670 setUnjoin2 = Set( 1, "set", "seq", 11, 16 )
|
|
|
671 setUnjoin3 = Set( 1, "set", "seq", 21, 26 )
|
|
|
672 setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3 ]
|
|
|
673
|
|
|
674 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
675 expLSets = [ setListToUnjoin ]
|
|
|
676
|
|
|
677 self.assertEquals(expLSets, obsLSets)
|
|
|
678
|
|
|
679 def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_size2_noSplit_item_in_listToUnjoin_smaller_item_in_listToKeep (self):
|
|
|
680 setKeep = Set( 1, "set", "seq", 10, 13 )
|
|
|
681 setListToKeep = [ setKeep ]
|
|
|
682
|
|
|
683 setUnjoin1 = Set( 1, "set", "seq", 5, 9 )
|
|
|
684 setUnjoin2 = Set( 1, "set", "seq", 1, 3 )
|
|
|
685 setListToUnjoin = [ setUnjoin1, setUnjoin2 ]
|
|
|
686
|
|
|
687 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
688 expLSets = [ SetUtils.getSetListSortedByIncreasingMinThenMax( setListToUnjoin ) ]
|
|
|
689
|
|
|
690 self.assertEquals(expLSets, obsLSets)
|
|
|
691
|
|
|
692 def test_getSetListUnjoined_listToKeep_size3_listToUnjoin_size2_oneSplit_item_in_listToKeep_smaller_item_in_listToUnjoin (self):
|
|
|
693 setKeep1 = Set( 1, "set", "seq", 1, 1 )
|
|
|
694 setKeep2 = Set( 1, "set", "seq", 21, 30 )
|
|
|
695 setKeep3 = Set( 1, "set", "seq", 61, 70 )
|
|
|
696 setListToKeep = [ setKeep1, setKeep2, setKeep3 ]
|
|
|
697
|
|
|
698 setUnjoin1 = Set( 1, "set", "seq", 41, 50 )
|
|
|
699 setUnjoin2 = Set( 2, "set", "seq", 81, 90 )
|
|
|
700 setListToUnjoin = [ setUnjoin1, setUnjoin2 ]
|
|
|
701
|
|
|
702 expLSets = [ [ setUnjoin1 ], [ setUnjoin2 ] ]
|
|
|
703
|
|
|
704 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
705
|
|
|
706 self.assertEquals(expLSets, obsLSets)
|
|
|
707
|
|
|
708 def test_getSetListUnjoined_listToKeep_size3_listToUnjoin_size3_twoSplits_item_in_listToUnjoin_smaller_item_in_listToKeep(self):
|
|
|
709 setKeep1 = Set( 1, "set", "seq", 21, 30 )
|
|
|
710 setKeep2 = Set( 1, "set", "seq", 41, 50 )
|
|
|
711 setKeep3 = Set( 1, "set", "seq", 81, 90 )
|
|
|
712 setListToKeep = [ setKeep1, setKeep2, setKeep3 ]
|
|
|
713
|
|
|
714 setUnjoin1 = Set( 1, "set", "seq", 1, 10 )
|
|
|
715 setUnjoin2 = Set( 2, "set", "seq", 61, 70 )
|
|
|
716 setUnjoin3 = Set( 2, "set", "seq", 101, 110 )
|
|
|
717 setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3 ]
|
|
|
718
|
|
|
719 expLSets = [ [ setUnjoin1 ], [ setUnjoin2 ], [ setUnjoin3 ] ]
|
|
|
720
|
|
|
721 obsLSets = SetUtils.getSetListUnjoined( setListToKeep, setListToUnjoin )
|
|
|
722
|
|
|
723 self.assertEquals(expLSets, obsLSets)
|
|
|
724
|
|
|
725 def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_size2_split(self):
|
|
|
726 setKeep1 = Set( 1, "set", "seq", 51, 80 )
|
|
|
727 setListToKeep = [ setKeep1 ]
|
|
|
728
|
|
|
729 setUnjoin1 = Set( 1, "set", "seq", 21, 40 )
|
|
|
730 setUnjoin2 = Set( 1, "set", "seq", 101, 150 )
|
|
|
731 setListToUnjoin = [ setUnjoin1, setUnjoin2 ]
|
|
|
732
|
|
|
733 expLSets = [ [setUnjoin1] , [setUnjoin2] ]
|
|
|
734
|
|
|
735 obsLSets = SetUtils.getSetListUnjoined( setListToKeep, setListToUnjoin )
|
|
|
736
|
|
|
737 self.assertEquals( expLSets, obsLSets )
|
|
|
738
|
|
|
739 def test_getSetListUnjoined_listToKeep_size2_listToUnjoin_size2_split(self):
|
|
|
740 setKeep1 = Set( 1, "set", "seq", 1, 15 )
|
|
|
741 setKeep2 = Set( 1, "set", "seq", 81, 130 )
|
|
|
742 setListToKeep = [ setKeep1, setKeep2 ]
|
|
|
743
|
|
|
744 setUnjoin1 = Set( 1, "set", "seq", 21, 40 )
|
|
|
745 setUnjoin2 = Set( 1, "set", "seq", 201, 250 )
|
|
|
746 setListToUnjoin = [ setUnjoin1, setUnjoin2 ]
|
|
|
747
|
|
|
748 expLSets = [ [setUnjoin1] , [setUnjoin2] ]
|
|
|
749
|
|
|
750 obsLSets = SetUtils.getSetListUnjoined( setListToKeep, setListToUnjoin )
|
|
|
751
|
|
|
752 self.assertEquals( expLSets, obsLSets )
|
|
|
753
|
|
|
754 def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_ordered_OneSplit(self):
|
|
|
755 setKeep = Set( 1, "set", "seq", 120, 180 )
|
|
|
756 setListToKeep = [ setKeep ]
|
|
|
757
|
|
|
758 setUnjoin1 = Set( 1, "set", "seq", 100, 110 )
|
|
|
759 setUnjoin2 = Set( 1, "set", "seq", 200, 210 )
|
|
|
760 setUnjoin3 = Set( 1, "set", "seq", 250, 280 )
|
|
|
761 setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3 ]
|
|
|
762
|
|
|
763 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
764 expLSets = [ [setUnjoin1], [setUnjoin2, setUnjoin3] ]
|
|
|
765
|
|
|
766 self.assertEquals(expLSets, obsLSets)
|
|
|
767
|
|
|
768 def test_getSetListUnjoined_listToKeep_size1_listToUnjoin_unordered_OneSplit(self):
|
|
|
769 setKeep = Set( 1, "set", "seq", 120, 180 )
|
|
|
770 setListToKeep = [ setKeep ]
|
|
|
771
|
|
|
772 setUnjoin1 = Set( 1, "set", "seq", 200, 210 )
|
|
|
773 setUnjoin2 = Set( 1, "set", "seq", 250, 280 )
|
|
|
774 setUnjoin3 = Set( 1, "set", "seq", 100, 110 )
|
|
|
775 setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3 ]
|
|
|
776
|
|
|
777 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
778 expLSets = [ [setUnjoin3], [setUnjoin1, setUnjoin2] ]
|
|
|
779
|
|
|
780 self.assertEquals(expLSets, obsLSets)
|
|
|
781
|
|
|
782 def test_getSetListUnjoined_listToKeep_size2_listToUnjoin_size4_twoSplits(self):
|
|
|
783 setKeep1 = Set( 1, "set", "seq", 21, 30 )
|
|
|
784 setKeep2 = Set( 1, "set", "seq", 81, 90 )
|
|
|
785 setListToKeep = [ setKeep1, setKeep2 ]
|
|
|
786
|
|
|
787 setUnjoin1 = Set( 1, "set", "seq", 1, 10 )
|
|
|
788 setUnjoin2 = Set( 1, "set", "seq", 41, 50 )
|
|
|
789 setUnjoin3 = Set( 1, "set", "seq", 61, 70 )
|
|
|
790 setUnjoin4 = Set( 1, "set", "seq", 101, 110 )
|
|
|
791 setListToUnjoin = [ setUnjoin1, setUnjoin2, setUnjoin3, setUnjoin4 ]
|
|
|
792
|
|
|
793 expLSets = [ [setUnjoin1], [ setUnjoin2, setUnjoin3 ], [setUnjoin4] ]
|
|
|
794
|
|
|
795 obsLSets = SetUtils.getSetListUnjoined(setListToKeep, setListToUnjoin)
|
|
|
796
|
|
|
797 self.assertEquals( expLSets, obsLSets )
|
|
|
798
|
|
|
799 def test_getSetListWithoutDuplicates_empty_list(self):
|
|
|
800 lSets = []
|
|
|
801 obsLSets = SetUtils.getSetListWithoutDuplicates( lSets )
|
|
|
802 expLSets = []
|
|
|
803 self.assertEquals( expLSets, obsLSets )
|
|
|
804
|
|
|
805 def test_getSetListWithoutDuplicates_list_size1(self):
|
|
|
806 set = Set( 1, "set", "seq", 100, 110 )
|
|
|
807 lSets = [ set ]
|
|
|
808 obsLSets = SetUtils.getSetListWithoutDuplicates( lSets )
|
|
|
809 expLSets = lSets
|
|
|
810 self.assertEquals( expLSets, obsLSets )
|
|
|
811
|
|
|
812 def test_getSetListWithoutDuplicates_list_with_only_doublons(self):
|
|
|
813 set1 = Set( 1, "set", "seq", 100, 110 )
|
|
|
814 set2 = Set( 1, "set", "seq", 100, 110 )
|
|
|
815 set3 = Set( 1, "set", "seq", 100, 110 )
|
|
|
816 set4 = Set( 1, "set", "seq", 100, 110 )
|
|
|
817 lSets = [set1, set2, set3, set4]
|
|
|
818
|
|
|
819 obsLSets = SetUtils.getSetListWithoutDuplicates( lSets )
|
|
|
820
|
|
|
821 expLSets = [ set1 ]
|
|
|
822
|
|
|
823 self.assertEquals( expLSets, obsLSets )
|
|
|
824
|
|
|
825 def test_getSetListWithoutDuplicates_list_with_doublons_at_start_and_at_end(self):
|
|
|
826 set1 = Set( 1, "set", "seq", 200, 210 )
|
|
|
827 set2 = Set( 1, "set", "seq", 100, 110 )
|
|
|
828 set3 = Set( 1, "set", "seq", 300, 310 )
|
|
|
829 set4 = Set( 1, "set", "seq", 100, 110 )
|
|
|
830 lSets = [set1, set2, set3, set4]
|
|
|
831
|
|
|
832 obsLSets = SetUtils.getSetListWithoutDuplicates( lSets )
|
|
|
833
|
|
|
834 expLSets = [ set1, set2, set3 ]
|
|
|
835 expLSets = SetUtils.getSetListSortedByIncreasingMinThenMax(expLSets)
|
|
|
836
|
|
|
837 self.assertEquals( expLSets, obsLSets )
|
|
|
838
|
|
|
839 def test_getSetListWithoutDuplicates_list_with_contiguous_doublons(self):
|
|
|
840 set1 = Set( 1, "set", "seq", 200, 210 )
|
|
|
841 set2 = Set( 1, "set", "seq", 100, 110 )
|
|
|
842 set3 = Set( 1, "set", "seq", 100, 110 )
|
|
|
843 set4 = Set( 1, "set", "seq", 300, 310 )
|
|
|
844 lSets = [set1, set2, set3, set4]
|
|
|
845
|
|
|
846 obsLSets = SetUtils.getSetListWithoutDuplicates( lSets )
|
|
|
847
|
|
|
848 expLSets = [ set1, set2, set4 ]
|
|
|
849 expLSets = SetUtils.getSetListSortedByIncreasingMinThenMax(expLSets)
|
|
|
850
|
|
|
851 self.assertEquals( expLSets, obsLSets )
|
|
|
852
|
|
|
853 def test_getSetListWithoutDuplicates_list_with_one_doublon(self):
|
|
|
854 set1 = Set( 1, "set", "seq", 200, 210 )
|
|
|
855 set2 = Set( 1, "set", "seq", 100, 110 )
|
|
|
856 set3 = Set( 1, "set", "seq", 210, 250 )
|
|
|
857 set4 = Set( 1, "set", "seq", 100, 110 )
|
|
|
858 set5 = Set( 1, "set", "seq", 300, 310 )
|
|
|
859 lSets = [set1, set2, set3, set4, set5]
|
|
|
860
|
|
|
861 obsLSets = SetUtils.getSetListWithoutDuplicates( lSets )
|
|
|
862
|
|
|
863 expLSets = [ set1, set2, set3, set5 ]
|
|
|
864 expLSets = SetUtils.getSetListSortedByIncreasingMinThenMax(expLSets)
|
|
|
865
|
|
|
866 self.assertEquals( expLSets, obsLSets )
|
|
|
867
|
|
|
868 def test_getSetListWithoutDuplicates_list_with_two_doublons(self):
|
|
|
869 set1 = Set( 1, "set", "seq", 200, 210 )
|
|
|
870 set2 = Set( 1, "set", "seq", 100, 110 )
|
|
|
871 set3 = Set( 1, "set", "seq", 210, 250 )
|
|
|
872 set4 = Set( 1, "set", "seq", 230, 250 )
|
|
|
873 set5 = Set( 1, "set", "seq", 210, 250 )
|
|
|
874 set6 = Set( 1, "set", "seq", 100, 110 )
|
|
|
875 set7 = Set( 1, "set", "seq", 300, 310 )
|
|
|
876 lSets = [set1, set2, set3, set4, set5, set6, set7]
|
|
|
877
|
|
|
878 obsLSets = SetUtils.getSetListWithoutDuplicates( lSets )
|
|
|
879
|
|
|
880 expLSets = [ set1, set2, set3, set4, set7 ]
|
|
|
881 expLSets = SetUtils.getSetListSortedByIncreasingMinThenMax(expLSets)
|
|
|
882
|
|
|
883 self.assertEquals( expLSets, obsLSets )
|
|
|
884
|
|
|
885 def test_getSetListSortedByIncreasingMinThenMax_alreadyOrdered_diffIdentifier(self):
|
|
|
886 set1 = Set( 1, "set1", "seq1", 1, 10 )
|
|
|
887 set2 = Set( 2, "set1", "seq1", 21, 30 )
|
|
|
888 lSets = [ set1, set2 ]
|
|
|
889
|
|
|
890 expList = [ set1, set2 ]
|
|
|
891
|
|
|
892 obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets )
|
|
|
893
|
|
|
894 self.assertEqual( expList, obsList )
|
|
|
895
|
|
|
896
|
|
|
897 def test_getSetListSortedByIncreasingMinThenMax_unordered_diffIdentifier(self):
|
|
|
898 set1 = Set( 1, "set1", "seq1", 21, 30 )
|
|
|
899 set2 = Set( 2, "set1", "seq1", 1, 10 )
|
|
|
900 lSets = [ set1, set2 ]
|
|
|
901
|
|
|
902 expList = [ set2, set1 ]
|
|
|
903
|
|
|
904 obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets )
|
|
|
905
|
|
|
906 self.assertEqual( expList, obsList )
|
|
|
907
|
|
|
908
|
|
|
909 def test_getSetListSortedByIncreasingMinThenMax_unordered_sameIdentifier(self):
|
|
|
910 set1 = Set( 1, "set1", "seq1", 21, 30 )
|
|
|
911 set2 = Set( 1, "set1", "seq1", 1, 10 )
|
|
|
912 lSets = [ set1, set2 ]
|
|
|
913
|
|
|
914 expList = [ set2, set1 ]
|
|
|
915
|
|
|
916 obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets )
|
|
|
917
|
|
|
918 self.assertEqual( expList, obsList )
|
|
|
919
|
|
|
920
|
|
|
921 def test_getSetListSortedByIncreasingMinThenMax_unordered_overlapping(self):
|
|
|
922 set1 = Set( 2, "set1", "seq1", 6, 15 )
|
|
|
923 set2 = Set( 1, "set1", "seq1", 1, 10 )
|
|
|
924 lSets = [ set1, set2 ]
|
|
|
925
|
|
|
926 expList = [ set2, set1 ]
|
|
|
927
|
|
|
928 obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets )
|
|
|
929
|
|
|
930 self.assertEqual( expList, obsList )
|
|
|
931
|
|
|
932 def test_getSetListSortedByIncreasingMinThenMax_unordered_sameMin_threeSets(self):
|
|
|
933 set1 = Set( 1, "set1", "seq1", 1, 15 )
|
|
|
934 set2 = Set( 2, "set2", "seq1", 1, 10 )
|
|
|
935 set3 = Set( 3, "set3", "seq1", 1, 12 )
|
|
|
936 lSets = [ set1, set2, set3 ]
|
|
|
937
|
|
|
938 expList = [ set2, set3, set1 ]
|
|
|
939
|
|
|
940 obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets )
|
|
|
941
|
|
|
942 self.assertEqual( expList, obsList )
|
|
|
943
|
|
|
944
|
|
|
945 def test_getSetListSortedByIncreasingMinThenMax_unordered_included(self):
|
|
|
946 set1 = Set( 1, "set1", "seq1", 2, 4 )
|
|
|
947 set2 = Set( 2, "set2", "seq1", 1, 5 )
|
|
|
948 lSets = [ set1, set2 ]
|
|
|
949
|
|
|
950 expList = [ set2, set1 ]
|
|
|
951
|
|
|
952 obsList = SetUtils.getSetListSortedByIncreasingMinThenMax( lSets )
|
|
|
953
|
|
|
954 self.assertEqual( expList, obsList )
|
|
|
955
|
|
|
956
|
|
|
957 def test_getSetListSortedByIncreasingMinThenInvLength_alreadyOrdered_diffIdentifier(self):
|
|
|
958 set1 = Set( 1, "set1", "seq1", 1, 10 )
|
|
|
959 set2 = Set( 2, "set1", "seq1", 21, 30 )
|
|
|
960 lSets = [ set1, set2 ]
|
|
|
961
|
|
|
962 expList = [ set1, set2 ]
|
|
|
963
|
|
|
964 obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets )
|
|
|
965
|
|
|
966 self.assertEqual( expList, obsList )
|
|
|
967
|
|
|
968
|
|
|
969 def test_getSetListSortedByIncreasingMinThenInvLength_unordered_diffIdentifier(self):
|
|
|
970 set1 = Set( 1, "set1", "seq1", 21, 30 )
|
|
|
971 set2 = Set( 2, "set1", "seq1", 1, 10 )
|
|
|
972 lSets = [ set1, set2 ]
|
|
|
973
|
|
|
974 expList = [ set2, set1 ]
|
|
|
975
|
|
|
976 obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets )
|
|
|
977
|
|
|
978 self.assertEqual( expList, obsList )
|
|
|
979
|
|
|
980
|
|
|
981 def test_getSetListSortedByIncreasingMinThenInvLength_unordered_sameIdentifier(self):
|
|
|
982 set1 = Set( 1, "set1", "seq1", 21, 30 )
|
|
|
983 set2 = Set( 1, "set1", "seq1", 1, 10 )
|
|
|
984 lSets = [ set1, set2 ]
|
|
|
985
|
|
|
986 expList = [ set2, set1 ]
|
|
|
987
|
|
|
988 obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets )
|
|
|
989
|
|
|
990 self.assertEqual( expList, obsList )
|
|
|
991
|
|
|
992
|
|
|
993 def test_getSetListSortedByIncreasingMinThenInvLength_unordered_overlapping(self):
|
|
|
994 set1 = Set( 2, "set1", "seq1", 6, 15 )
|
|
|
995 set2 = Set( 1, "set1", "seq1", 1, 10 )
|
|
|
996 lSets = [ set1, set2 ]
|
|
|
997
|
|
|
998 expList = [ set2, set1 ]
|
|
|
999
|
|
|
1000 obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets )
|
|
|
1001
|
|
|
1002 self.assertEqual( expList, obsList )
|
|
|
1003
|
|
|
1004
|
|
|
1005 def test_getSetListSortedByIncreasingMinThenInvLength_unordered_sameMin_threeSets(self):
|
|
|
1006 set1 = Set( 1, "set1", "seq1", 1, 10 )
|
|
|
1007 set2 = Set( 2, "set2", "seq1", 3, 8 )
|
|
|
1008 set3 = Set( 3, "set3", "seq1", 3, 17 )
|
|
|
1009 lSets = [ set1, set2, set3 ]
|
|
|
1010
|
|
|
1011 expList = [ set1, set3, set2 ]
|
|
|
1012
|
|
|
1013 obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets )
|
|
|
1014
|
|
|
1015 self.assertEqual( expList, obsList )
|
|
|
1016
|
|
|
1017 def test_getSetListSortedByIncreasingMinThenInvLength_unordered_included(self):
|
|
|
1018 set1 = Set( 1, "set1", "seq1", 2, 4 )
|
|
|
1019 set2 = Set( 2, "set2", "seq1", 1, 5 )
|
|
|
1020 lSets = [ set1, set2 ]
|
|
|
1021
|
|
|
1022 expList = [ set2, set1 ]
|
|
|
1023
|
|
|
1024 obsList = SetUtils.getSetListSortedByIncreasingMinThenInvLength( lSets )
|
|
|
1025
|
|
|
1026 self.assertEqual( expList, obsList )
|
|
|
1027
|
|
|
1028 def test_getSetListSortedBySeqThenRegionThenMinThenMax_already_sorted(self):
|
|
|
1029 set1 = Set(1, "set1", "seq1", 2, 4)
|
|
|
1030 set2 = Set(2, "set2", "seq2", 1, 5)
|
|
|
1031 set3 = Set(3, "set3", "seq2", 8, 10)
|
|
|
1032 lSets = [set1, set2, set3]
|
|
|
1033
|
|
|
1034 expList = [set1, set2, set3]
|
|
|
1035
|
|
|
1036 obsList = SetUtils.getSetListSortedBySeqThenRegionThenMinThenMax(lSets)
|
|
|
1037
|
|
|
1038 self.assertEqual(expList, obsList)
|
|
|
1039
|
|
|
1040 def test_getSetListSortedBySeqThenRegionThenMinThenMax_not_sorted_by_seqname(self):
|
|
|
1041 set1 = Set(1, "set1", "seq1", 2, 4)
|
|
|
1042 set2 = Set(2, "set2", "seq2", 1, 5)
|
|
|
1043 set3 = Set(3, "set3", "seq2", 8, 10)
|
|
|
1044 lSets = [set2, set1, set3]
|
|
|
1045
|
|
|
1046 expList = [set1, set2, set3]
|
|
|
1047
|
|
|
1048 obsList = SetUtils.getSetListSortedBySeqThenRegionThenMinThenMax(lSets)
|
|
|
1049
|
|
|
1050 self.assertEqual(expList, obsList)
|
|
|
1051
|
|
|
1052 def test_getSetListSortedBySeqThenRegionThenMinThenMax_not_sorted_by_region_and_start(self):
|
|
|
1053 set1 = Set(1, "set1", "seq1", 2, 4)
|
|
|
1054 set2 = Set(2, "set2", "seq2", 1, 5)
|
|
|
1055 set3 = Set(3, "set3", "seq2", 8, 10)
|
|
|
1056 lSets = [set3, set2, set1]
|
|
|
1057
|
|
|
1058 expList = [set1, set2, set3]
|
|
|
1059
|
|
|
1060 obsList = SetUtils.getSetListSortedBySeqThenRegionThenMinThenMax(lSets)
|
|
|
1061
|
|
|
1062 self.assertEqual(expList, obsList)
|
|
|
1063
|
|
|
1064 def test_getSetListSortedBySeqThenRegionThenMinThenMax_not_sorted_with_overlap(self):
|
|
|
1065 set1 = Set(1, "set1", "seq1", 2, 4)
|
|
|
1066 set2 = Set(2, "set2", "seq2", 1, 5)
|
|
|
1067 set3 = Set(3, "set2", "seq2", 8, 10)
|
|
|
1068 set4 = Set(4, "set2", "seq3", 7, 9)
|
|
|
1069 set5 = Set(5, "set3", "seq3", 8, 12)
|
|
|
1070 lSets = [set3, set2, set1, set5, set4]
|
|
|
1071
|
|
|
1072 expList = [set1, set2, set3, set4, set5]
|
|
|
1073
|
|
|
1074 obsList = SetUtils.getSetListSortedBySeqThenRegionThenMinThenMax(lSets)
|
|
|
1075
|
|
|
1076 self.assertEqual(expList, obsList)
|
|
|
1077
|
|
|
1078 def test_getSetListSortedBySeqThenRegionThenMinThenMax_not_sorted_with_reverse(self):
|
|
|
1079 set1 = Set(1, "set1", "seq1", 2, 4)
|
|
|
1080 set2 = Set(2, "set2", "seq2", 1, 5)
|
|
|
1081 set3 = Set(3, "set2", "seq2", 8, 10)
|
|
|
1082 set4 = Set(4, "set3", "seq3", 7, 9)
|
|
|
1083 set5 = Set(5, "set3", "seq3", 12, 5)
|
|
|
1084 lSets = [set3, set2, set5, set1, set4]
|
|
|
1085
|
|
|
1086 expList = [set1, set2, set3, set5, set4]
|
|
|
1087
|
|
|
1088 obsList = SetUtils.getSetListSortedBySeqThenRegionThenMinThenMax(lSets)
|
|
|
1089
|
|
|
1090 self.assertEqual(expList, obsList)
|
|
|
1091
|
|
|
1092 def test_getListOfIdListOfOverlappingSets_2_item_in_reference_list_overlaps_with_one_item_in_subject_list(self):
|
|
|
1093 set1 = Set( 1, "set1", "seq1", 10, 30 )
|
|
|
1094 set2 = Set( 2, "set2", "seq1", 40, 60 )
|
|
|
1095
|
|
|
1096 lRef = [set1, set2]
|
|
|
1097
|
|
|
1098 set3 = Set( 3, "set2", "seq1", 25, 45 )
|
|
|
1099 lSubj = [set3]
|
|
|
1100
|
|
|
1101 lExp = [[1,-3,2]]
|
|
|
1102 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1103
|
|
|
1104 self.assertEquals(lExp, lObs)
|
|
|
1105
|
|
|
1106 def test_getListOfIdListOfOverlappingSets_one_item_in_reference_list_overlaps_with_2_item_in_subject_list(self):
|
|
|
1107 set1 = Set( 1, "set2", "seq1", 25, 45 )
|
|
|
1108 lRef = [set1]
|
|
|
1109
|
|
|
1110 set2 = Set( 2, "set1", "seq1", 10, 30 )
|
|
|
1111 set3 = Set( 3, "set2", "seq1", 40, 60 )
|
|
|
1112
|
|
|
1113 lSubj = [set2, set3]
|
|
|
1114
|
|
|
1115 lExp = [[1,-2,-3]]
|
|
|
1116 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1117
|
|
|
1118 self.assertEquals(lExp, lObs)
|
|
|
1119
|
|
|
1120 def test_getListOfIdListOfOverlappingSets_all_item_in_reference_list_overlaps_with_items_in_subject_list(self):
|
|
|
1121 set1 = Set( 1, "set1", "seq1", 10, 30 )
|
|
|
1122 set2 = Set( 2, "set2", "seq1", 40, 60 )
|
|
|
1123 set3 = Set( 3, "set2", "seq1", 70, 90 )
|
|
|
1124
|
|
|
1125 lRef = [set1, set2, set3]
|
|
|
1126
|
|
|
1127 set4 = Set( 4, "set1", "seq1", 5, 9 )
|
|
|
1128 set5 = Set( 5, "set1", "seq1", 15, 29 )
|
|
|
1129 set6 = Set( 6, "set2", "seq1", 45, 55 )
|
|
|
1130 set7 = Set( 7, "set2", "seq1", 57, 68 )
|
|
|
1131 set8 = Set( 8, "set2", "seq1", 73, 85 )
|
|
|
1132 set9 = Set( 9, "set2", "seq1", 100, 115 )
|
|
|
1133
|
|
|
1134 lSubj = [set4, set5, set6, set7, set8, set9]
|
|
|
1135
|
|
|
1136 lExp = [[1,-5], [2,-6,-7], [3,-8]]
|
|
|
1137 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1138
|
|
|
1139 self.assertEquals(lObs, lExp)
|
|
|
1140
|
|
|
1141 def test_getListOfIdListOfOverlappingSets_all_item_in_subject_list_overlaps_with_items_in_reference_list(self):
|
|
|
1142 set1 = Set( 1, "set1", "seq1", 5, 9 )
|
|
|
1143 set2 = Set( 2, "set1", "seq1", 15, 29 )
|
|
|
1144 set3 = Set( 3, "set2", "seq1", 45, 55 )
|
|
|
1145 set4 = Set( 4, "set2", "seq1", 57, 68 )
|
|
|
1146 set5 = Set( 5, "set2", "seq1", 73, 85 )
|
|
|
1147 set6 = Set( 6, "set2", "seq1", 100, 115 )
|
|
|
1148
|
|
|
1149 lRef = [set1, set2, set3, set4, set5, set6]
|
|
|
1150
|
|
|
1151 set7 = Set( 7, "set1", "seq1", 10, 30 )
|
|
|
1152 set8 = Set( 8, "set2", "seq1", 40, 60 )
|
|
|
1153 set9 = Set( 9, "set2", "seq1", 70, 90 )
|
|
|
1154
|
|
|
1155 lSubj = [set7, set8, set9]
|
|
|
1156
|
|
|
1157 lExp = [[2, -7], [3, -8, 4], [5, -9]]
|
|
|
1158 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1159
|
|
|
1160 self.assertEquals(lObs, lExp)
|
|
|
1161
|
|
|
1162 def test_getListOfIdListOfOverlappingSets_all_item_overlaps_one_by_one(self):
|
|
|
1163 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1164 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1165 set3 = Set( 3, "set2", "seq1", 50, 60 )
|
|
|
1166
|
|
|
1167 lRef = [set1, set2, set3]
|
|
|
1168
|
|
|
1169 lSubj = [set1, set2, set3]
|
|
|
1170
|
|
|
1171 lExp = [[1, -1], [2, -2], [3, -3]]
|
|
|
1172 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1173
|
|
|
1174 self.assertEquals(lObs, lExp)
|
|
|
1175
|
|
|
1176 def test_getListOfIdListOfOverlappingSets_continuus_overlap_between_item_in_reference_list_and_item_in_subject_list(self):
|
|
|
1177 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1178 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1179 set3 = Set( 3, "set2", "seq1", 50, 60 )
|
|
|
1180 set4 = Set( 4, "set2", "seq1", 70, 80 )
|
|
|
1181
|
|
|
1182 lRef = [set1, set2, set3, set4]
|
|
|
1183
|
|
|
1184 set5 = Set( 5, "set1", "seq1", 15, 32 )
|
|
|
1185 set6 = Set( 6, "set2", "seq1", 35, 52 )
|
|
|
1186 set7 = Set( 7, "set2", "seq1", 55, 75 )
|
|
|
1187
|
|
|
1188 lSubj = [set5, set6, set7]
|
|
|
1189
|
|
|
1190 lExp = [[ 1, -5, 2, -6, 3, -7, 4 ]]
|
|
|
1191 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1192
|
|
|
1193 self.assertEquals(lObs, lExp)
|
|
|
1194
|
|
|
1195
|
|
|
1196 def test_getListOfIdListOfOverlappingSets_first_item_in_reference_overlap_with_one_item_in_subject_list(self):
|
|
|
1197 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1198 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1199
|
|
|
1200 lRef = [set1, set2]
|
|
|
1201
|
|
|
1202 set3 = Set( 3, "set1", "seq1", 5, 9 )
|
|
|
1203 set4 = Set( 4, "set2", "seq1", 12, 25 )
|
|
|
1204 set5 = Set( 5, "set2", "seq1", 55, 75 )
|
|
|
1205
|
|
|
1206 lSubj = [set3, set4, set5]
|
|
|
1207
|
|
|
1208 lExp = [[1, -4]]
|
|
|
1209 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1210
|
|
|
1211 self.assertEquals(lObs, lExp)
|
|
|
1212
|
|
|
1213 def test_getListOfIdListOfOverlappingSets_last_item_in_reference_overlap_with_one_item_in_subject_list(self):
|
|
|
1214 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1215 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1216
|
|
|
1217 lRef = [set1, set2]
|
|
|
1218
|
|
|
1219 set3 = Set( 3, "set1", "seq1", 5, 9 )
|
|
|
1220 set4 = Set( 4, "set2", "seq1", 32, 45 )
|
|
|
1221 set5 = Set( 5, "set2", "seq1", 55, 75 )
|
|
|
1222
|
|
|
1223 lSubj = [set3, set4, set5]
|
|
|
1224
|
|
|
1225 lExp = [[2, -4]]
|
|
|
1226 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1227
|
|
|
1228 self.assertEquals(lObs, lExp)
|
|
|
1229
|
|
|
1230 def test_getListOfIdListOfOverlappingSets_one_item_in_reference_in_the_middle_overlap_with_one_item_in_subject_list(self):
|
|
|
1231 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1232 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1233 set3 = Set( 3, "set1", "seq1", 50, 60 )
|
|
|
1234 set4 = Set( 4, "set1", "seq1", 70, 80 )
|
|
|
1235
|
|
|
1236 lRef = [set1, set2, set3, set4]
|
|
|
1237
|
|
|
1238 set5 = Set( 5, "set1", "seq1", 2, 9 )
|
|
|
1239 set6 = Set( 6, "set2", "seq1", 55, 65 )
|
|
|
1240 set7 = Set( 7, "set2", "seq1", 90, 100 )
|
|
|
1241
|
|
|
1242 lSubj = [set5, set6, set7]
|
|
|
1243
|
|
|
1244 lExp = [[3, -6]]
|
|
|
1245 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1246
|
|
|
1247 self.assertEquals(lObs, lExp)
|
|
|
1248
|
|
|
1249 def test_getListOfIdListOfOverlappingSets_first_item_in_subject_overlap_with_one_item_in_reference_list(self):
|
|
|
1250 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1251 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1252
|
|
|
1253 lRef = [set1, set2]
|
|
|
1254
|
|
|
1255 set3 = Set( 3, "set1", "seq1", 15, 25 )
|
|
|
1256 set4 = Set( 4, "set2", "seq1", 45, 50 )
|
|
|
1257 set5 = Set( 5, "set2", "seq1", 55, 75 )
|
|
|
1258
|
|
|
1259 lSubj = [set3, set4, set5]
|
|
|
1260
|
|
|
1261 lExp = [[1, -3]]
|
|
|
1262 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1263
|
|
|
1264 self.assertEquals(lObs, lExp)
|
|
|
1265
|
|
|
1266 def test_getListOfIdListOfOverlappingSets_last_item_in_subject_overlap_with_one_item_in_reference_list(self):
|
|
|
1267 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1268 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1269
|
|
|
1270 lRef = [set1, set2]
|
|
|
1271
|
|
|
1272 set3 = Set( 3, "set1", "seq1", 1, 9 )
|
|
|
1273 set4 = Set( 4, "set2", "seq1", 21, 29 )
|
|
|
1274 set5 = Set( 5, "set2", "seq1", 35, 50 )
|
|
|
1275
|
|
|
1276 lSubj = [set3, set4, set5]
|
|
|
1277
|
|
|
1278 lExp = [[2, -5]]
|
|
|
1279 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1280
|
|
|
1281 self.assertEquals(lObs, lExp)
|
|
|
1282
|
|
|
1283 def test_getListOfIdListOfOverlappingSets_one_item_in_subject_in_the_middle_overlap_with_one_item_in_reference_list(self):
|
|
|
1284 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1285 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1286
|
|
|
1287 lRef = [set1, set2]
|
|
|
1288
|
|
|
1289 set3 = Set( 3, "set1", "seq1", 1, 9 )
|
|
|
1290 set4 = Set( 4, "set2", "seq1", 21, 29 )
|
|
|
1291 set5 = Set( 5, "set2", "seq1", 35, 50 )
|
|
|
1292 set6 = Set( 6, "set2", "seq1", 60, 70 )
|
|
|
1293
|
|
|
1294 lSubj = [set3, set4, set5, set6]
|
|
|
1295
|
|
|
1296 lExp = [[2, -5]]
|
|
|
1297 lObs = SetUtils.getListOfIdListOfOverlappingSets(lRef, lSubj)
|
|
|
1298
|
|
|
1299 self.assertEquals(lObs, lExp)
|
|
|
1300
|
|
|
1301 def test_getListOfMergedSetsAndNextId_each_item_in_reference_list_overlap_with_one_different_item_in_subject_list(self):
|
|
|
1302 setRef1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1303 setRef2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1304 setRef3 = Set( 3, "set1", "seq1", 50, 60 )
|
|
|
1305
|
|
|
1306 lRef = [setRef1, setRef2, setRef3]
|
|
|
1307
|
|
|
1308 setSubj1 = Set( 1, "set1", "seq1", 12, 25 )
|
|
|
1309 setSubj2 = Set( 2, "set1", "seq1", 31, 45 )
|
|
|
1310 setSubj3 = Set( 3, "set1", "seq1", 55, 80 )
|
|
|
1311
|
|
|
1312 lSubj = [setSubj1, setSubj2, setSubj3]
|
|
|
1313
|
|
|
1314 setRef1merged = Set( 1, "set1", "seq1", 10, 25 )
|
|
|
1315 setRef2merged = Set( 2, "set1", "seq1", 30, 45 )
|
|
|
1316 setRef3merged = Set( 3, "set1", "seq1", 50, 80 )
|
|
|
1317
|
|
|
1318 nextId = 4
|
|
|
1319
|
|
|
1320 lExp = ([setRef1merged, setRef2merged, setRef3merged], nextId)
|
|
|
1321 lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj)
|
|
|
1322
|
|
|
1323 self.assertEquals(lObs, lExp)
|
|
|
1324
|
|
|
1325 def test_getListOfMergedSetsAndNextId_all_items_in_reference_list_overlap_with_the_same_item_in_subject_list(self):
|
|
|
1326 setRef1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1327 setRef2 = Set( 2, "set1", "seq1", 15, 25 )
|
|
|
1328 setRef3 = Set( 3, "set1", "seq1", 20, 30 )
|
|
|
1329
|
|
|
1330 lRef = [setRef1, setRef2, setRef3]
|
|
|
1331
|
|
|
1332 setSubj1 = Set( 1, "set1", "seq1", 12, 35 )
|
|
|
1333 setSubj2 = Set( 2, "set1", "seq1", 40, 45 )
|
|
|
1334 setSubj3 = Set( 3, "set1", "seq1", 55, 80 )
|
|
|
1335
|
|
|
1336 lSubj = [setSubj1, setSubj2, setSubj3]
|
|
|
1337
|
|
|
1338 setRef1merged = Set( 1, "set1", "seq1", 10, 35 )
|
|
|
1339 setSubj2Exp = Set( 4, "set1", "seq1", 40, 45 )
|
|
|
1340 setSubj3Exp = Set( 5, "set1", "seq1", 55, 80 )
|
|
|
1341
|
|
|
1342 nextId = 6
|
|
|
1343
|
|
|
1344 lExp = ([setRef1merged, setSubj2Exp, setSubj3Exp], nextId)
|
|
|
1345 lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj)
|
|
|
1346
|
|
|
1347 self.assertEquals(lObs, lExp)
|
|
|
1348
|
|
|
1349 def test_getListOfMergedSetsAndNextId_two_last_ref_items_overlap_with_last_subject_item(self):
|
|
|
1350 setRef1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1351 setRef2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1352 setRef3 = Set( 3, "set1", "seq1", 50, 60 )
|
|
|
1353
|
|
|
1354 lRef = [setRef1, setRef2, setRef3]
|
|
|
1355
|
|
|
1356 setSubj1 = Set( 1, "set1", "seq1", 1, 5 )
|
|
|
1357 setSubj2 = Set( 2, "set1", "seq1", 6, 9 )
|
|
|
1358 setSubj3 = Set( 3, "set1", "seq1", 35, 55 )
|
|
|
1359
|
|
|
1360 lSubj = [setSubj1, setSubj2, setSubj3]
|
|
|
1361
|
|
|
1362 setRef1Exp = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1363 setRef2merged = Set( 2, "set1", "seq1", 30, 60 )
|
|
|
1364 setSubj1Exp = Set( 4, "set1", "seq1", 1, 5 )
|
|
|
1365 setSubj2Exp = Set( 5, "set1", "seq1", 6, 9 )
|
|
|
1366
|
|
|
1367 nextId = 6
|
|
|
1368
|
|
|
1369 lExp = ([setRef2merged, setRef1Exp, setSubj1Exp, setSubj2Exp], nextId)
|
|
|
1370 lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj)
|
|
|
1371
|
|
|
1372 self.assertEquals(lObs, lExp)
|
|
|
1373
|
|
|
1374 def test_getListOfMergedSetsAndNextId_all_items_in_reference_list_overlap_with_all_items_in_subject_list(self):
|
|
|
1375 setRef1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1376 setRef2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1377
|
|
|
1378 lRef = [setRef1, setRef2]
|
|
|
1379
|
|
|
1380 setSubj1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1381 setSubj2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1382
|
|
|
1383 lSubj = [setSubj1, setSubj2]
|
|
|
1384
|
|
|
1385 setRef1merged = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1386 setRef2merged = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1387
|
|
|
1388 nextId = 3
|
|
|
1389
|
|
|
1390 lExp = ([setRef1merged, setRef2merged], nextId)
|
|
|
1391 lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj)
|
|
|
1392
|
|
|
1393 self.assertEquals(lObs, lExp)
|
|
|
1394
|
|
|
1395 def test_getListOfMergedSetsAndNextId_one_item_in_reference_list_overlap_with_all_items_in_subject_list(self):
|
|
|
1396 setRef1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1397 setRef2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1398 setRef3 = Set( 3, "set1", "seq1", 50, 60 )
|
|
|
1399
|
|
|
1400 lRef = [setRef1, setRef2, setRef3]
|
|
|
1401
|
|
|
1402 setSubj1 = Set( 1, "set1", "seq1", 11, 13 )
|
|
|
1403 setSubj2 = Set( 2, "set1", "seq1", 14, 16 )
|
|
|
1404 setSubj3 = Set( 3, "set1", "seq1", 17, 25 )
|
|
|
1405
|
|
|
1406 lSubj = [setSubj1, setSubj2, setSubj3]
|
|
|
1407
|
|
|
1408 setRef1merged = Set( 1, "set1", "seq1", 10, 25 )
|
|
|
1409 setRef2Exp = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1410 setRef3Exp = Set( 3, "set1", "seq1", 50, 60 )
|
|
|
1411
|
|
|
1412 nextId = 4
|
|
|
1413
|
|
|
1414 lExp = ([setRef1merged, setRef2Exp, setRef3Exp], nextId)
|
|
|
1415 lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj)
|
|
|
1416
|
|
|
1417 self.assertEquals(lObs, lExp)
|
|
|
1418
|
|
|
1419 def test_getListOfMergedSetsAndNextId_one_item_in_reference_list_overlap_with_one_item_in_subject_list(self):
|
|
|
1420 setRef1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1421 setRef2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1422 setRef3 = Set( 3, "set1", "seq1", 50, 60 )
|
|
|
1423
|
|
|
1424 lRef = [setRef1, setRef2, setRef3]
|
|
|
1425
|
|
|
1426 setSubj1 = Set( 1, "set1", "seq1", 1, 9 )
|
|
|
1427 setSubj2 = Set( 2, "set1", "seq1", 31, 45 )
|
|
|
1428 setSubj3 = Set( 3, "set1", "seq1", 70, 80 )
|
|
|
1429
|
|
|
1430 lSubj = [setSubj1, setSubj2, setSubj3]
|
|
|
1431
|
|
|
1432 setRef1Exp = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1433 setRef2merged = Set( 2, "set1", "seq1", 30, 45 )
|
|
|
1434 setRef3Exp = Set( 3, "set1", "seq1", 50, 60 )
|
|
|
1435 setSubj1Exp = Set( 4, "set1", "seq1", 1, 9 )
|
|
|
1436 setSubj3Exp = Set( 5, "set1", "seq1", 70, 80 )
|
|
|
1437
|
|
|
1438 nextId = 6
|
|
|
1439
|
|
|
1440 lExp = ([setRef2merged, setRef1Exp, setRef3Exp, setSubj1Exp, setSubj3Exp], nextId)
|
|
|
1441
|
|
|
1442 lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj)
|
|
|
1443
|
|
|
1444 self.assertEquals(lObs, lExp)
|
|
|
1445
|
|
|
1446 def test_getListOfMergedSetsAndNextId_one_item_in_reference_list_overlap_with_one_item_in_subject_list_with_strange_output_order(self):
|
|
|
1447 setRef1 = Set( 5, "set1", "seq1", 10, 20 )
|
|
|
1448 setRef2 = Set( 6, "set1", "seq1", 30, 40 )
|
|
|
1449 setRef3 = Set( 7, "set1", "seq1", 50, 60 )
|
|
|
1450 setRef4 = Set( 8, "set1", "seq1", 90, 92 )
|
|
|
1451
|
|
|
1452 lRef = [setRef1, setRef2, setRef3, setRef4]
|
|
|
1453
|
|
|
1454 setSubj1 = Set( 1, "set1", "seq1", 1, 9 )
|
|
|
1455 setSubj2 = Set( 2, "set1", "seq1", 35, 45 )
|
|
|
1456 setSubj3 = Set( 3, "set1", "seq1", 70, 80 )
|
|
|
1457 setSubj4 = Set( 4, "set1", "seq1", 130, 140 )
|
|
|
1458
|
|
|
1459 lSubj = [setSubj1, setSubj2, setSubj3, setSubj4]
|
|
|
1460
|
|
|
1461 setRef1Exp = Set( 5, "set1", "seq1", 10, 20 )
|
|
|
1462 setRef2merged = Set( 6, "set1", "seq1", 30, 45 )
|
|
|
1463 setRef3Exp = Set( 7, "set1", "seq1", 50, 60 )
|
|
|
1464 setRef4Exp = Set( 8, "set1", "seq1", 90, 92 )
|
|
|
1465 setSubj1Exp = Set( 9, "set1", "seq1", 1, 9 )
|
|
|
1466 setSubj3Exp = Set( 10, "set1", "seq1", 70, 80 )
|
|
|
1467 setSubj4Exp = Set( 11, "set1", "seq1", 130, 140 )
|
|
|
1468
|
|
|
1469 nextId = 12
|
|
|
1470
|
|
|
1471 lExp = ([setRef2merged, setRef4Exp, setRef1Exp, setRef3Exp, setSubj1Exp, setSubj3Exp, setSubj4Exp], nextId)
|
|
|
1472
|
|
|
1473 lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj)
|
|
|
1474
|
|
|
1475 self.assertEquals(lObs, lExp)
|
|
|
1476
|
|
|
1477 def test_getListOfMergedSetsAndNextId_all_items_overlap_between_lists_with_same_length(self):
|
|
|
1478 setRef1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1479 setRef2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1480 setRef3 = Set( 3 , "set1", "seq1", 50, 60 )
|
|
|
1481
|
|
|
1482 lRef = [setRef1, setRef2, setRef3]
|
|
|
1483
|
|
|
1484 setSubj1 = Set( 1, "set1", "seq1", 15, 35 )
|
|
|
1485 setSubj2 = Set( 2, "set1", "seq1", 36, 55 )
|
|
|
1486 setSubj3 = Set( 3, "set1", "seq1", 56, 65 )
|
|
|
1487
|
|
|
1488 lSubj = [setSubj1, setSubj2, setSubj3]
|
|
|
1489
|
|
|
1490 setRef1merged = Set( 1, "set1", "seq1", 10, 65 )
|
|
|
1491
|
|
|
1492 nextId = 4
|
|
|
1493
|
|
|
1494 lExp = ([setRef1merged], nextId)
|
|
|
1495 lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj)
|
|
|
1496
|
|
|
1497 self.assertEquals(lObs, lExp)
|
|
|
1498
|
|
|
1499 def test_getListOfMergedSetsAndNextId_all_items_overlap_between_lists_with_different_length(self):
|
|
|
1500 setRef1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1501 setRef2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1502 setRef3 = Set( 3 , "set1", "seq1", 50, 60 )
|
|
|
1503
|
|
|
1504 lRef = [setRef1, setRef2, setRef3]
|
|
|
1505
|
|
|
1506 setSubj1 = Set( 1, "set1", "seq1", 15, 35 )
|
|
|
1507 setSubj2 = Set( 2, "set1", "seq1", 36, 55 )
|
|
|
1508
|
|
|
1509 lSubj = [setSubj1, setSubj2]
|
|
|
1510
|
|
|
1511 setRef1merged = Set( 1, "set1", "seq1", 10, 60 )
|
|
|
1512
|
|
|
1513 nextId = 4
|
|
|
1514
|
|
|
1515 lExp = ([setRef1merged], nextId)
|
|
|
1516 lObs = SetUtils.getListOfMergedSetsAndNextId(lRef, lSubj)
|
|
|
1517
|
|
|
1518 self.assertEquals(lObs, lExp)
|
|
|
1519
|
|
|
1520 def test_getListOfSetWithoutOverlappingBetweenTwoListOfSet(self):
|
|
|
1521 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1522 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1523 set3 = Set( 3, "set1", "seq1", 50, 60 )
|
|
|
1524
|
|
|
1525 lSet1 = [set1, set2, set3]
|
|
|
1526
|
|
|
1527 set4 = Set( 1, "set1", "seq1", 15, 35 )
|
|
|
1528 set5 = Set( 2, "set1", "seq1", 36, 55 )
|
|
|
1529 set6 = Set( 3, "set1", "seq1", 66, 95 )
|
|
|
1530
|
|
|
1531 lSet2 = [set4, set5, set6]
|
|
|
1532
|
|
|
1533 expLSet = [set6]
|
|
|
1534 obsLSet = SetUtils.getListOfSetWithoutOverlappingBetweenTwoListOfSet(lSet1, lSet2)
|
|
|
1535
|
|
|
1536 self.assertEquals(expLSet, obsLSet)
|
|
|
1537
|
|
|
1538 def test_getListOfSetWithoutOverlappingBetweenTwoListOfSet_Empty_Result(self):
|
|
|
1539 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1540 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1541 set3 = Set( 3, "set1", "seq1", 50, 60 )
|
|
|
1542
|
|
|
1543 lSet1 = [set1, set2, set3]
|
|
|
1544
|
|
|
1545 set4 = Set( 1, "set1", "seq1", 15, 35 )
|
|
|
1546 set5 = Set( 2, "set1", "seq1", 36, 55 )
|
|
|
1547
|
|
|
1548 lSet2 = [set4, set5]
|
|
|
1549
|
|
|
1550 expLSet = []
|
|
|
1551 obsLSet = SetUtils.getListOfSetWithoutOverlappingBetweenTwoListOfSet(lSet1, lSet2)
|
|
|
1552
|
|
|
1553 self.assertEquals(expLSet, obsLSet)
|
|
|
1554
|
|
|
1555 def test_getListOfSetWithoutOverlappingBetweenTwoListOfSet_Empty_Result_Length_Condition(self):
|
|
|
1556 set1 = Set( 1, "set1", "seq1", 10, 20 )
|
|
|
1557 set2 = Set( 2, "set1", "seq1", 30, 40 )
|
|
|
1558 set3 = Set( 3, "set1", "seq1", 50, 60 )
|
|
|
1559
|
|
|
1560 lSet1 = [set1, set2, set3]
|
|
|
1561
|
|
|
1562 set4 = Set( 1, "set1", "seq1", 15, 35 )
|
|
|
1563 set5 = Set( 2, "set1", "seq1", 36, 55 )
|
|
|
1564 set6 = Set( 3, "set1", "seq1", 66, 68 )
|
|
|
1565
|
|
|
1566 lSet2 = [set4, set5, set6]
|
|
|
1567
|
|
|
1568 expLSet = []
|
|
|
1569 obsLSet = SetUtils.getListOfSetWithoutOverlappingBetweenTwoListOfSet(lSet1, lSet2)
|
|
|
1570
|
|
|
1571 self.assertEquals(expLSet, obsLSet)
|
|
|
1572
|
|
|
1573
|
|
|
1574 def test_getSetListFromFile(self):
|
|
|
1575 file = "dummyFile_%s_%s" % ( time.strftime("%Y%m%d%H%M%S"), os.getpid() )
|
|
|
1576 fileHandler = open( file, "w" )
|
|
|
1577 fileHandler.write( "1\tseq1\tchr1\t151\t250\n" )
|
|
|
1578 fileHandler.write( "2\tseq2\tchr2\t301\t500\n" )
|
|
|
1579 fileHandler.close()
|
|
|
1580 s1 = Set()
|
|
|
1581 s1.setFromTuple( ( "1", "seq1", "chr1", "151", "250" ) )
|
|
|
1582 s2 = Set()
|
|
|
1583 s2.setFromTuple( ( "2", "seq2", "chr2", "301", "500" ) )
|
|
|
1584 expLSet = [ s1, s2 ]
|
|
|
1585 obsLSet = SetUtils.getSetListFromFile(file)
|
|
|
1586 os.remove(file)
|
|
|
1587 self.assertEqual( expLSet, obsLSet )
|
|
|
1588
|
|
|
1589
|
|
|
1590 def test_convertSetFileIntoMapFile( self ):
|
|
|
1591 setFile = "dummySetFile"
|
|
|
1592 setFileHandler = open( setFile, "w" )
|
|
|
1593 setFileHandler.write( "1\tseq31\tchr1\t151\t250\n" )
|
|
|
1594 setFileHandler.write( "2\tseq27\tchr2\t301\t500\n" )
|
|
|
1595 setFileHandler.close()
|
|
|
1596
|
|
|
1597 expFile = "dummyExpFile"
|
|
|
1598 expFileHandler = open( expFile, "w" )
|
|
|
1599 expFileHandler.write( "seq31\tchr1\t151\t250\n" )
|
|
|
1600 expFileHandler.write( "seq27\tchr2\t301\t500\n" )
|
|
|
1601 expFileHandler.close()
|
|
|
1602
|
|
|
1603 obsFile = "dummyObsFile"
|
|
|
1604
|
|
|
1605 SetUtils.convertSetFileIntoMapFile( setFile, obsFile )
|
|
|
1606
|
|
|
1607 self.assertTrue( FileUtils.are2FilesIdentical( expFile, obsFile ) )
|
|
|
1608
|
|
|
1609 for f in [ setFile, expFile, obsFile ]:
|
|
|
1610 os.remove( f )
|
|
|
1611
|
|
|
1612
|
|
|
1613 def test_getDictOfListsWithSeqnameAsKey_empty( self ):
|
|
|
1614 lSets = []
|
|
|
1615 dExp = {}
|
|
|
1616 dObs = SetUtils.getDictOfListsWithSeqnameAsKey( lSets )
|
|
|
1617 self.assertEquals( dExp, dObs )
|
|
|
1618
|
|
|
1619
|
|
|
1620 def test_getDictOfListsWithSeqnameAsKey( self ):
|
|
|
1621 lSets = [ Set( 1, "TE3", "chr2", 10, 50 ),
|
|
|
1622 Set( 2, "gene74", "chr1", 31, 800 ),
|
|
|
1623 Set( 3, "TE1", "chr1", 1, 30 ) ]
|
|
|
1624 dExp = { "chr1": [ Set( 2, "gene74", "chr1", 31, 800 ),
|
|
|
1625 Set( 3, "TE1", "chr1", 1, 30 ) ],
|
|
|
1626 "chr2": [ Set( 1, "TE3", "chr2", 10, 50 ) ] }
|
|
|
1627 dObs = SetUtils.getDictOfListsWithSeqnameAsKey( lSets )
|
|
|
1628 self.assertEquals( dExp, dObs )
|
|
|
1629
|
|
|
1630
|
|
|
1631 def test_filterOnLength( self ):
|
|
|
1632 lSets = [ Set( 1, "TE3", "chr2", 10, 50 ),
|
|
|
1633 Set( 2, "gene74", "chr1", 31, 800 ),
|
|
|
1634 Set( 3, "TE1", "chr1", 1, 30 ) ]
|
|
|
1635 lExp = [ Set( 2, "gene74", "chr1", 31, 800 ) ]
|
|
|
1636 lObs = SetUtils.filterOnLength( lSets, 100 )
|
|
|
1637 self.assertEqual( lExp, lObs )
|
|
|
1638
|
|
|
1639
|
|
|
1640 def test_getListOfNames( self ):
|
|
|
1641 setFile = "dummySetFile"
|
|
|
1642 setFileHandler = open( setFile, "w" )
|
|
|
1643 setFileHandler.write( "1\tseq31\tchr1\t151\t250\n" )
|
|
|
1644 setFileHandler.write( "2\tseq27\tchr2\t301\t500\n" )
|
|
|
1645 setFileHandler.close()
|
|
|
1646
|
|
|
1647 lExp = [ "seq31", "seq27" ]
|
|
|
1648 lObs = SetUtils.getListOfNames( setFile )
|
|
|
1649
|
|
|
1650 self.assertEquals( lExp, lObs )
|
|
|
1651
|
|
|
1652 os.remove( setFile )
|
|
|
1653
|
|
|
1654
|
|
|
1655 def test_getDictOfDictsWithNamesThenIdAsKeyFromFile( self ):
|
|
|
1656 setFile = "dummySetFile"
|
|
|
1657 setFileHandler = open( setFile, "w" )
|
|
|
1658 setFileHandler.write( "1\tseq31\tchr1\t151\t250\n" )
|
|
|
1659 setFileHandler.write( "3\tseq27\tchr3\t1\t100\n" )
|
|
|
1660 setFileHandler.write( "2\tseq27\tchr2\t301\t500\n" )
|
|
|
1661 setFileHandler.write( "2\tseq27\tchr2\t601\t650\n" )
|
|
|
1662 setFileHandler.close()
|
|
|
1663
|
|
|
1664 dExp = { "seq31": { 1: [ Set( 1, "seq31", "chr1", 151, 250 ) ] },
|
|
|
1665 "seq27": { 2: [ Set( 2, "seq27", "chr2", 301, 500 ),
|
|
|
1666 Set( 2, "seq27", "chr2", 601, 650 ) ],
|
|
|
1667 3: [ Set( 3, "seq27", "chr3", 1, 100 ) ]
|
|
|
1668 }
|
|
|
1669 }
|
|
|
1670 dObs = SetUtils.getDictOfDictsWithNamesThenIdAsKeyFromFile( setFile )
|
|
|
1671
|
|
|
1672 self.assertEquals( dExp, dObs )
|
|
|
1673
|
|
|
1674 os.remove( setFile )
|
|
|
1675
|
|
|
1676
|
|
|
1677 def _makeSetListFromTupleList (self, tupleList):
|
|
|
1678 setList = []
|
|
|
1679 for tuple in tupleList:
|
|
|
1680 set = Set()
|
|
|
1681 set.setFromTuple(tuple)
|
|
|
1682 setList.append(set)
|
|
|
1683 return setList
|
|
|
1684
|
|
|
1685
|
|
|
1686 test_suite = unittest.TestSuite()
|
|
|
1687 test_suite.addTest( unittest.makeSuite( Test_SetUtils ) )
|
|
|
1688 if __name__ == "__main__":
|
|
|
1689 unittest.TextTestRunner(verbosity=2).run( test_suite )
|
