Mercurial > repos > yufei-luo > s_mart

comparison commons/core/coord/test/Test_SetUtils.py @ 6:769e306b7933

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Change the repository level.
author yufei-luo
date Fri, 18 Jan 2013 04:54:14 -0500
parents
children
comparison
equal deleted inserted replaced
5:ea3082881bf8 6:769e306b7933
1 # Copyright INRA (Institut National de la Recherche Agronomique)
2 # http://www.inra.fr
3 # http://urgi.versailles.inra.fr
4 #
5 # This software is governed by the CeCILL license under French law and
6 # abiding by the rules of distribution of free software. You can use,
7 # modify and/ or redistribute the software under the terms of the CeCILL
8 # license as circulated by CEA, CNRS and INRIA at the following URL
9 # "http://www.cecill.info".
10 #
11 # As a counterpart to the access to the source code and rights to copy,
12 # modify and redistribute granted by the license, users are provided only
13 # with a limited warranty and the software's author, the holder of the
14 # economic rights, and the successive licensors have only limited
15 # liability.
16 #
17 # In this respect, the user's attention is drawn to the risks associated
18 # with loading, using, modifying and/or developing or reproducing the
19 # software by the user in light of its specific status of free software,
20 # that may mean that it is complicated to manipulate, and that also
21 # therefore means that it is reserved for developers and experienced
22 # professionals having in-depth computer knowledge. Users are therefore
23 # encouraged to load and test the software's suitability as regards their
24 # requirements in conditions enabling the security of their systems and/or
25 # data to be ensured and, more generally, to use and operate it in the
26 # same conditions as regards security.
27 #
28 # The fact that you are presently reading this means that you have had
29 # knowledge of the CeCILL license and that you accept its terms.
30
31
32 import 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 )