Mercurial > repos > yufei-luo > s_mart
comparison commons/core/coord/test/Test_Range.py @ 6:769e306b7933
Change the repository level.
author | yufei-luo |
---|---|
date | Fri, 18 Jan 2013 04:54:14 -0500 |
parents | |
children | 94ab73e8a190 |
comparison
equal
deleted
inserted
replaced
5:ea3082881bf8 | 6:769e306b7933 |
---|---|
1 # Copyright INRA (Institut National de la Recherche Agronomique) | |
2 # http://www.inra.fr | |
3 # http://urgi.versailles.inra.fr | |
4 # | |
5 # This software is governed by the CeCILL license under French law and | |
6 # abiding by the rules of distribution of free software. You can use, | |
7 # modify and/ or redistribute the software under the terms of the CeCILL | |
8 # license as circulated by CEA, CNRS and INRIA at the following URL | |
9 # "http://www.cecill.info". | |
10 # | |
11 # As a counterpart to the access to the source code and rights to copy, | |
12 # modify and redistribute granted by the license, users are provided only | |
13 # with a limited warranty and the software's author, the holder of the | |
14 # economic rights, and the successive licensors have only limited | |
15 # liability. | |
16 # | |
17 # In this respect, the user's attention is drawn to the risks associated | |
18 # with loading, using, modifying and/or developing or reproducing the | |
19 # software by the user in light of its specific status of free software, | |
20 # that may mean that it is complicated to manipulate, and that also | |
21 # therefore means that it is reserved for developers and experienced | |
22 # professionals having in-depth computer knowledge. Users are therefore | |
23 # encouraged to load and test the software's suitability as regards their | |
24 # requirements in conditions enabling the security of their systems and/or | |
25 # data to be ensured and, more generally, to use and operate it in the | |
26 # same conditions as regards security. | |
27 # | |
28 # The fact that you are presently reading this means that you have had | |
29 # knowledge of the CeCILL license and that you accept its terms. | |
30 | |
31 | |
32 import unittest | |
33 from commons.core.coord.Range import Range | |
34 from commons.core.coord.Range import getBin, getIdx | |
35 | |
36 | |
37 class Test_Range( unittest.TestCase ): | |
38 | |
39 def setUp(self): | |
40 self._range = Range() | |
41 | |
42 def test_setFromString(self): | |
43 line = "chunk1\t190000\t390000" | |
44 self._range.setFromString( line ) | |
45 self.assertEqual( self._range.seqname, "chunk1" ) | |
46 self.assertEqual( self._range.start, 190000 ) | |
47 self.assertEqual( self._range.end, 390000 ) | |
48 | |
49 line = "chunk1\t190000\t390000\n" | |
50 self._range.setFromString( line ) | |
51 self.assertEqual( self._range.seqname, "chunk1" ) | |
52 self.assertEqual( self._range.start, 190000 ) | |
53 self.assertEqual( self._range.end, 390000 ) | |
54 | |
55 line = "chunk1;190000;390000" | |
56 self._range.setFromString( line, ";" ) | |
57 self.assertEqual( self._range.seqname, "chunk1" ) | |
58 self.assertEqual( self._range.start, 190000 ) | |
59 self.assertEqual( self._range.end, 390000 ) | |
60 | |
61 def test_setFromTuple(self): | |
62 tuple = ("chunk1","190000","390000") | |
63 self._range.setFromTuple( tuple) | |
64 | |
65 self.assertEqual( self._range.seqname, "chunk1" ) | |
66 self.assertEqual( self._range.start, 190000 ) | |
67 self.assertEqual( self._range.end, 390000 ) | |
68 | |
69 def test___eq__(self): | |
70 self._range.setFromString( "chunk1\t190000\t390000\n" ) | |
71 o = Range() | |
72 o.setFromString( "chunk1\t190000\t390000\n" ) | |
73 self.assertEqual( self._range, o ) | |
74 | |
75 o.setFromString( "chunk1\t190000\t39" ) | |
76 self.assertNotEquals( self._range, o ) | |
77 | |
78 o.setFromString( "chromosome1\t190000\t390000" ) | |
79 self.assertNotEquals( self._range, o ) | |
80 | |
81 o.setFromString( "chunk1\t390000\t190000" ) | |
82 self.assertNotEquals( self._range, o ) | |
83 | |
84 o.setFromString( "chromosome1\t390000\t190000" ) | |
85 self.assertNotEquals( self._range, o ) | |
86 | |
87 def test_getMin(self): | |
88 self._range.setFromTuple( ("chunk1", 190000, 390000) ) | |
89 expMin = 190000 | |
90 obsMin = self._range.getMin() | |
91 self.assertTrue(expMin, obsMin) | |
92 | |
93 def test_getMax(self): | |
94 self._range.setFromTuple( ("chunk1", 190000, 390000) ) | |
95 expMax = 390000 | |
96 obsMax = self._range.getMax() | |
97 self.assertTrue(expMax, obsMax) | |
98 | |
99 def test_isOnDirectStrand_true(self): | |
100 self._range.setFromTuple( ("chunk1", 190000, 390000) ) | |
101 self.assertTrue(self._range.isOnDirectStrand()) | |
102 | |
103 def test_isOnDirectStrand_false(self): | |
104 self._range.setFromTuple( ("chunk1", 390000, 190000) ) | |
105 self.assertFalse(self._range.isOnDirectStrand()) | |
106 | |
107 def test_isOnReverseStrand_true(self): | |
108 self._range.setFromTuple( ("chunk1", 390000, 190000) ) | |
109 self.assertTrue(self._range.isOnReverseStrand()) | |
110 | |
111 def test_isOnReverseStrand_false(self): | |
112 self._range.setFromTuple( ("chunk1", 190000, 390000) ) | |
113 self.assertFalse(self._range.isOnReverseStrand()) | |
114 | |
115 def test_getStrand_direct(self): | |
116 self._range.setFromTuple( ("chunk1", 190000, 390000) ) | |
117 expStrand = '+' | |
118 obsStrand = self._range.getStrand() | |
119 self.assertEqual(expStrand, obsStrand) | |
120 | |
121 def test_getStrand_reverse(self): | |
122 self._range.setFromTuple( ("chunk1", 390000, 190000) ) | |
123 expStrand = '-' | |
124 obsStrand = self._range.getStrand() | |
125 self.assertEqual(expStrand, obsStrand) | |
126 | |
127 def test_reverse(self): | |
128 obsRange = Range("chunk1", 190000, 390000) | |
129 expRange = Range("chunk1", 390000, 190000) | |
130 obsRange.reverse() | |
131 self.assertEquals(expRange, obsRange) | |
132 | |
133 def test_getLength(self): | |
134 self._range.setFromTuple( ("chunk1", 190000, 390000) ) | |
135 expLength = 200001 | |
136 obsLength = self._range.getLength() | |
137 self.assertEquals(expLength, obsLength) | |
138 | |
139 def test_isEmpty_true( self ): | |
140 exp = True | |
141 obs = self._range.isEmpty() | |
142 self.assertEquals( exp, obs ) | |
143 | |
144 def test_isEmpty_false( self ): | |
145 self._range.setFromTuple( ( "seq1", 1, 10 ) ) | |
146 exp = False | |
147 obs = self._range.isEmpty() | |
148 self.assertEquals( exp, obs ) | |
149 | |
150 def test_merge_diff_sequences( self ): | |
151 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
152 range2 = Range( "seq2", 6, 12 ) | |
153 expReturn = None | |
154 expRange = Range( "seq1", 6, 10 ) | |
155 obsReturn = self._range.merge( range2 ) | |
156 obsRange = self._range | |
157 self.assertEquals( expReturn, obsReturn ) | |
158 self.assertEquals( expRange, obsRange ) | |
159 | |
160 def test_merge_no_overlapping_ranges( self ): | |
161 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
162 range2 = Range( "seq1", 12, 20 ) | |
163 expReturn = None | |
164 expRange = Range( "seq1", 6, 20 ) | |
165 obsReturn = self._range.merge( range2 ) | |
166 obsRange = self._range | |
167 self.assertEquals( expReturn, obsReturn ) | |
168 self.assertEquals( expRange, obsRange ) | |
169 | |
170 def test_merge_no_overlapping_ranges_range1_on_neg_strand( self ): | |
171 self._range.setFromTuple( ( "seq1", 10, 6 ) ) | |
172 range2 = Range( "seq1", 12, 20 ) | |
173 expReturn = None | |
174 expRange = Range( "seq1", 20, 6 ) | |
175 obsReturn = self._range.merge( range2 ) | |
176 obsRange = self._range | |
177 self.assertEquals( expReturn, obsReturn ) | |
178 self.assertEquals( expRange, obsRange ) | |
179 | |
180 def test_merge_overlapping_ranges_range1_and_range2_on_neg_strand( self ): | |
181 self._range.setFromTuple( ( "seq1", 10, 6 ) ) | |
182 range2 = Range( "seq1", 20, 12 ) | |
183 expReturn = None | |
184 expRange = Range( "seq1", 20, 6 ) | |
185 obsReturn = self._range.merge( range2 ) | |
186 obsRange = self._range | |
187 self.assertEquals( expReturn, obsReturn ) | |
188 self.assertEquals( expRange, obsRange ) | |
189 | |
190 def test_merge_on_overlapping_ranges_range1_and_range2( self ): | |
191 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
192 range2 = Range( "seq1", 8, 20 ) | |
193 expReturn = None | |
194 expRange = Range( "seq1", 6, 20 ) | |
195 obsReturn = self._range.merge( range2 ) | |
196 obsRange = self._range | |
197 self.assertEquals( expReturn, obsReturn ) | |
198 self.assertEquals( expRange, obsRange ) | |
199 | |
200 def test_isOverlapping_diff_sequences( self ): | |
201 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
202 r2 = Range( "seq2", 6, 10 ) | |
203 exp = False | |
204 obs = self._range.isOverlapping( r2 ) | |
205 self.assertEquals( exp, obs ) | |
206 | |
207 def test_isOverlapping_no( self ): | |
208 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
209 r2 = Range( "seq1", 16, 20 ) | |
210 exp = False | |
211 obs = self._range.isOverlapping( r2 ) | |
212 self.assertEquals( exp, obs ) | |
213 | |
214 def test_isOverlapping_yes( self ): | |
215 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
216 r2 = Range( "seq1", 1, 15 ) | |
217 exp = True | |
218 obs = self._range.isOverlapping( r2 ) | |
219 self.assertEquals( exp, obs ) | |
220 | |
221 def test_isOverlapping_yes_range2_on_neg_strand( self ): | |
222 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
223 r2 = Range( "seq1", 15, 1 ) | |
224 exp = True | |
225 obs = self._range.isOverlapping( r2 ) | |
226 self.assertEquals( exp, obs ) | |
227 | |
228 def test_isOverlapping_range1_before_range2( self ): | |
229 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
230 r2 = Range( "seq1", 8, 15 ) | |
231 exp = True | |
232 obs = self._range.isOverlapping( r2 ) | |
233 self.assertEquals( exp, obs ) | |
234 | |
235 def test_isOverlapping_range1_after_range2( self ): | |
236 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
237 r2 = Range( "seq1", 1, 8 ) | |
238 exp = True | |
239 obs = self._range.isOverlapping( r2 ) | |
240 self.assertEquals( exp, obs ) | |
241 | |
242 def test_isOverlapping_range1_equal_range2( self ): | |
243 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
244 r2 = Range( "seq1", 6, 10 ) | |
245 exp = True | |
246 obs = self._range.isOverlapping( r2 ) | |
247 self.assertEquals( exp, obs ) | |
248 | |
249 def test_isOverlapping_yes_edges_left( self ): | |
250 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
251 r2 = Range( "seq1", 1, 6 ) | |
252 exp = True | |
253 obs = self._range.isOverlapping( r2 ) | |
254 self.assertEquals( exp, obs ) | |
255 | |
256 def test_isOverlapping_yes_edges_right( self ): | |
257 self._range.setFromTuple( ( "seq1", 6, 10 ) ) | |
258 r2 = Range( "seq1", 10, 20 ) | |
259 exp = True | |
260 obs = self._range.isOverlapping( r2 ) | |
261 self.assertEquals( exp, obs ) | |
262 | |
263 def test_isOverlapping_yes_one_nt( self ): | |
264 self._range.setFromTuple( ( "seq1", 10, 10 ) ) | |
265 r2 = Range( "seq1", 10, 20 ) | |
266 exp = True | |
267 obs = self._range.isOverlapping( r2 ) | |
268 self.assertEquals( exp, obs ) | |
269 | |
270 | |
271 def test_getOverlapLength_on_different_range( self ): | |
272 range1 = Range( "chunk1", 190000, 390000 ) | |
273 range2 = Range( "chunk2", 290000, 590000 ) | |
274 expSize = 0 | |
275 obsSize = range1.getOverlapLength( range2 ) | |
276 self.assertEquals( expSize, obsSize ) | |
277 | |
278 | |
279 def test_getOverlapLength_on_no_overalping_range( self ): | |
280 range1 =Range( "chunk1", 190000, 390000 ) | |
281 range2 =Range( "chunk1", 490000, 590000 ) | |
282 expSize = 0 | |
283 obsSize = range1.getOverlapLength( range2 ) | |
284 self.assertEquals( expSize, obsSize ) | |
285 | |
286 | |
287 def test_getOverlapLength_range2_included_in_range1( self ): | |
288 range1 = Range( "chunk1", 19, 39 ) | |
289 range2 = Range( "chunk1", 22, 25 ) | |
290 expSize = 4 | |
291 obsSize = range1.getOverlapLength( range2 ) | |
292 self.assertEquals( expSize, obsSize ) | |
293 obsSize = range2.getOverlapLength( range1 ) | |
294 self.assertEquals( expSize, obsSize ) | |
295 | |
296 | |
297 def test_getOverlapLength_range1_included_in_range2( self ): | |
298 range1 = Range( "chunk1", 220000, 250000 ) | |
299 range2 = Range( "chunk1", 190000, 390000 ) | |
300 expSize = 30001 | |
301 obsSize = range1.getOverlapLength( range2 ) | |
302 self.assertEquals( expSize, obsSize ) | |
303 | |
304 | |
305 def test_getOverlapLength_range1_before_range2( self ): | |
306 range1 = Range( "chunk1", 190000, 390000 ) | |
307 range2 = Range( "chunk1", 290000, 590000 ) | |
308 expSize = 100001 | |
309 obsSize = range1.getOverlapLength( range2 ) | |
310 self.assertEquals( expSize, obsSize ) | |
311 | |
312 | |
313 def test_getOverlapLength_range1_after_range2( self ): | |
314 range1 = Range( "chunk1", 390000, 790000 ) | |
315 range2 = Range( "chunk1", 290000, 590000 ) | |
316 expSize = 200001 | |
317 obsSize = range1.getOverlapLength( range2 ) | |
318 self.assertEquals( expSize, obsSize ) | |
319 | |
320 | |
321 def test_isIncludedIn( self ): | |
322 iRange1 = Range( "chunk1", 21, 30 ) | |
323 iRange2 = Range( "chunk1", 11, 40 ) | |
324 self.assertTrue( iRange1.isIncludedIn( iRange2 ) ) | |
325 | |
326 | |
327 def test_isIncludedIn_diffStrand( self ): | |
328 iRange1 = Range( "chunk1", 21, 30 ) | |
329 iRange2 = Range( "chunk1", 40, 11 ) | |
330 self.assertTrue( iRange1.isIncludedIn( iRange2 ) ) | |
331 | |
332 | |
333 def test_isIncludedIn_onlyOverlap( self ): | |
334 iRange1 = Range( "chunk1", 21, 50 ) | |
335 iRange2 = Range( "chunk1", 11, 40 ) | |
336 self.assertFalse( iRange1.isIncludedIn( iRange2 ) ) | |
337 | |
338 | |
339 def test_isIncludedIn_diffSeqname( self ): | |
340 iRange1 = Range( "chunk1", 21, 30 ) | |
341 iRange2 = Range( "chunk2", 11, 40 ) | |
342 self.assertFalse( iRange1.isIncludedIn( iRange2 ) ) | |
343 | |
344 | |
345 def test_getDistance_on_overlapping_range(self): | |
346 overlapTuple1 = ("chunk1", 220000, 250000) | |
347 overlapRange1 = Range() | |
348 overlapRange1.setFromTuple(overlapTuple1) | |
349 | |
350 overlapTuple2 = ("chunk1", 190000, 390000) | |
351 overlapRange2 = Range() | |
352 overlapRange2.setFromTuple(overlapTuple2) | |
353 | |
354 expDistance = 0 | |
355 obsDistance = overlapRange1.getDistance(overlapRange2) | |
356 | |
357 self.assertEquals(expDistance, obsDistance) | |
358 | |
359 def test_getDistance_on_range1_on_plus_strand_included_in_range2_on_neg_strand(self): | |
360 tuple1 = ("chunk1", 220000, 250000) | |
361 range1 = Range() | |
362 range1.setFromTuple(tuple1) | |
363 | |
364 tuple2 = ("chunk1", 390000, 190000) | |
365 range2 = Range() | |
366 range1.setFromTuple(tuple2) | |
367 | |
368 expDistance = -1 | |
369 obsDistance = range1.getDistance(range2) | |
370 | |
371 self.assertEquals(expDistance, obsDistance) | |
372 | |
373 def test_getDistance_range1_after_range2(self): | |
374 tuple1 = ("chunk1", 390000, 590000) | |
375 range1 = Range() | |
376 range1.setFromTuple(tuple1) | |
377 | |
378 tuple2 = ("chunk1", 190000, 290000) | |
379 range2 = Range() | |
380 range2.setFromTuple(tuple2) | |
381 | |
382 expDistance = 100000 | |
383 obsDistance = range1.getDistance(range2) | |
384 | |
385 self.assertEquals(expDistance, obsDistance) | |
386 | |
387 def test_getDistance_range1_before_range2(self): | |
388 tuple1 = ("chunk1", 190000, 290000) | |
389 range1 = Range() | |
390 range1.setFromTuple(tuple1) | |
391 | |
392 tuple2 = ("chunk1", 390000, 590000) | |
393 range2 = Range() | |
394 range2.setFromTuple(tuple2) | |
395 | |
396 expDistance = 100000 | |
397 obsDistance = range1.getDistance(range2) | |
398 | |
399 self.assertEquals(expDistance, obsDistance) | |
400 | |
401 def test_getDistance_range1_after_range2_both_on_neg_strand(self): | |
402 tuple1 = ("chunk1", 590000, 390000) | |
403 range1 = Range() | |
404 range1.setFromTuple(tuple1) | |
405 | |
406 tuple2 = ("chunk1", 290000, 190000) | |
407 range2 = Range() | |
408 range2.setFromTuple(tuple2) | |
409 | |
410 expDistance = 100000 | |
411 obsDistance = range1.getDistance(range2) | |
412 | |
413 self.assertEquals(expDistance, obsDistance) | |
414 | |
415 def test_getDistance_range1_before_range2_both_on_neg_strand(self): | |
416 tuple1 = ("chunk1", 290000, 190000) | |
417 range1 = Range() | |
418 range1.setFromTuple(tuple1) | |
419 | |
420 tuple2 = ("chunk1", 590000, 390000) | |
421 range2 = Range() | |
422 range2.setFromTuple(tuple2) | |
423 | |
424 expDistance = 100000 | |
425 obsDistance = range1.getDistance(range2) | |
426 | |
427 self.assertEquals(expDistance, obsDistance) | |
428 | |
429 def test_diff_on_no_overlapping_range(self): | |
430 range1 = Range("chunk1", 190000, 390000) | |
431 range2 = Range("chunk1", 490000, 590000) | |
432 | |
433 expRange1 = Range("chunk1",190000,390000) | |
434 expReturnedRange = Range("chunk1") | |
435 | |
436 obsReturnedRange = range1.diff(range2) | |
437 obsRange1 = range1 | |
438 | |
439 self.assertEquals(expRange1, obsRange1) | |
440 self.assertEquals(expReturnedRange, obsReturnedRange) | |
441 | |
442 def test_diff_on_different_chunks(self): | |
443 range1 = Range("chunk1", 190000, 390000) | |
444 range2 = Range("chunk2", 290000, 590000) | |
445 | |
446 expRange1 = Range("chunk1", 190000, 390000) | |
447 expReturnedRange = Range("chunk1") | |
448 | |
449 obsReturnedRange = range1.diff(range2) | |
450 obsRange1 = range1 | |
451 | |
452 self.assertEquals(expRange1, obsRange1) | |
453 self.assertEquals(expReturnedRange, obsReturnedRange) | |
454 | |
455 def test_diff_range1_before_range2(self): | |
456 range1 = Range("chunk1", 190000, 390000) | |
457 range2 = Range("chunk1", 290000, 590000) | |
458 | |
459 expRange1 = Range("chunk1", 190000, 289999) | |
460 expReturnedRange = Range("chunk1") | |
461 | |
462 obsReturnedRange = range1.diff(range2) | |
463 obsRange1 = range1 | |
464 | |
465 self.assertEquals(expRange1, obsRange1) | |
466 self.assertEquals(expReturnedRange, obsReturnedRange) | |
467 | |
468 def test_diff_range1_before_range2_range1_on_neg_strand(self): | |
469 range1 = Range("chunk1", 390000, 190000) | |
470 range2 = Range("chunk1", 290000, 590000) | |
471 | |
472 expRange1 = Range("chunk1", 289999, 190000) | |
473 expReturnedRange = Range("chunk1") | |
474 | |
475 obsReturnedRange = range1.diff(range2) | |
476 obsRange1 = range1 | |
477 | |
478 self.assertEquals(expRange1, obsRange1) | |
479 self.assertEquals(expReturnedRange, obsReturnedRange) | |
480 | |
481 def test_diff_range2_included_in_range1(self): | |
482 range1 = Range("chunk1", 190000, 590000) | |
483 range2 = Range("chunk1", 290000, 390000) | |
484 | |
485 expRange1 = Range("chunk1", 190000, 289999) | |
486 expReturnedRange = Range("chunk1", 390001, 590000) | |
487 | |
488 obsReturnedRange = range1.diff(range2) | |
489 obsRange1 = range1 | |
490 | |
491 self.assertEquals(expRange1, obsRange1) | |
492 self.assertEquals(expReturnedRange, obsReturnedRange) | |
493 | |
494 def test_diff_range2_included_in_range1_range1_on_reverse_strand(self): | |
495 range1 = Range("chunk1", 590000, 190000) | |
496 range2 = Range("chunk1", 290000, 390000) | |
497 | |
498 expRange1 = Range("chunk1", 289999, 190000) | |
499 expReturnedRange = Range("chunk1", 590000, 390001) | |
500 | |
501 obsReturnedRange = range1.diff(range2) | |
502 obsRange1 = range1 | |
503 | |
504 self.assertEquals(expRange1, obsRange1) | |
505 self.assertEquals(expReturnedRange, obsReturnedRange) | |
506 | |
507 def test_diff_range1_included_in_range2(self): | |
508 range1 = Range("chunk1", 390000, 490000) | |
509 range2 = Range("chunk1", 290000, 590000) | |
510 | |
511 expRange1 = Range("chunk1",0,0) | |
512 expReturnedRange = Range("chunk1") | |
513 | |
514 obsReturnedRange = range1.diff(range2) | |
515 obsRange1 = range1 | |
516 | |
517 self.assertEquals(expRange1, obsRange1) | |
518 self.assertEquals(expReturnedRange, obsReturnedRange) | |
519 | |
520 def test_diff_range1_after_range2(self): | |
521 range1 = Range("chunk1", 390000, 590000) | |
522 range2 = Range("chunk1", 290000, 490000) | |
523 | |
524 expRange1 = Range("chunk1", 490001, 590000) | |
525 expReturnedRange = Range("chunk1") | |
526 | |
527 obsReturnedRange = range1.diff(range2) | |
528 obsRange1 = range1 | |
529 | |
530 self.assertEquals(expRange1, obsRange1) | |
531 self.assertEquals(expReturnedRange, obsReturnedRange) | |
532 | |
533 def test_diff_range1_after_range2_range1_on_neg_strand(self): | |
534 range1 = Range("chunk1", 590000, 390000) | |
535 range2 = Range("chunk1", 290000, 490000) | |
536 | |
537 expRange1 = Range("chunk1", 590000, 490001) | |
538 expReturnedRange = Range("chunk1") | |
539 | |
540 obsReturnedRange = range1.diff(range2) | |
541 obsRange1 = range1 | |
542 | |
543 self.assertEquals(expRange1, obsRange1) | |
544 self.assertEquals(expReturnedRange, obsReturnedRange) | |
545 | |
546 def test_getIdx(self): | |
547 self.assertEqual(getIdx(1000,3),1000001) | |
548 self.assertEqual(getIdx(999,3),1000000) | |
549 self.assertEqual(getIdx(2000,3),1000002) | |
550 self.assertEqual(getIdx(2000,4),2000000) | |
551 self.assertEqual(getIdx(2000,5),3000000) | |
552 self.assertEqual(getIdx(20000000,6),4000000) | |
553 self.assertEqual(getIdx(20000000,5),3000200) | |
554 self.assertEqual(getIdx(20000000,4),2002000) | |
555 self.assertEqual(getIdx(20000000,3),1020000) | |
556 | |
557 def test_getBin_bin_level_9(self): | |
558 tuple1 = ("chunk1", 190000000, 390000000) | |
559 range1 =Range() | |
560 range1.setFromTuple(tuple1) | |
561 | |
562 expRes = 100000000.0 | |
563 obsRes = range1.getBin() | |
564 | |
565 self.assertEquals(expRes, obsRes) | |
566 | |
567 def test_getBin_bin_level_8(self): | |
568 tuple1 = ("chunk1", 19000000, 39000000) | |
569 range1 =Range() | |
570 range1.setFromTuple(tuple1) | |
571 | |
572 expRes = 100000000.0 | |
573 obsRes = range1.getBin() | |
574 | |
575 self.assertEquals(expRes, obsRes) | |
576 | |
577 def test_getBin_bin_level_7(self): | |
578 tuple1 = ("chunk1", 1900000, 3900000) | |
579 range1 =Range() | |
580 range1.setFromTuple(tuple1) | |
581 | |
582 expRes = 10000000.0 | |
583 obsRes = range1.getBin() | |
584 | |
585 self.assertEquals(expRes, obsRes) | |
586 | |
587 def test_getBin_bin_level_6(self): | |
588 tuple1 = ("chunk1", 190000, 390000) | |
589 range1 =Range() | |
590 range1.setFromTuple(tuple1) | |
591 | |
592 expRes = 1000000.0 | |
593 obsRes = range1.getBin() | |
594 | |
595 self.assertEquals(expRes, obsRes) | |
596 | |
597 def test_getBin_bin_level_5(self): | |
598 tuple = ("chunk1", 19000, 39000) | |
599 range =Range() | |
600 range.setFromTuple(tuple) | |
601 expRes = 100000.0 | |
602 obsRes = range.getBin() | |
603 | |
604 self.assertEquals(expRes, obsRes) | |
605 | |
606 def test_getBin_bin_level_4(self): | |
607 tuple = ("chunk1", 1900, 3900) | |
608 range =Range() | |
609 range.setFromTuple(tuple) | |
610 | |
611 expRes = 10000.0 | |
612 obsRes = range.getBin() | |
613 | |
614 self.assertEquals(expRes, obsRes) | |
615 | |
616 def test_getBin_bin_level_3(self): | |
617 tuple = ("chunk1", 190, 390) | |
618 range =Range() | |
619 range.setFromTuple(tuple) | |
620 | |
621 expRes = 1000.0 | |
622 obsRes = range.getBin() | |
623 | |
624 self.assertEquals(expRes, obsRes) | |
625 | |
626 def test_getBin_bin_level_2(self): | |
627 tuple = ("chunk1", 19, 39) | |
628 range =Range() | |
629 range.setFromTuple(tuple) | |
630 | |
631 expRes = 1000.0 | |
632 obsRes = range.getBin() | |
633 | |
634 self.assertEquals(expRes, obsRes) | |
635 | |
636 def test_getBin_bin_level_1(self): | |
637 tuple = ("chunk1", 1, 3) | |
638 range =Range() | |
639 range.setFromTuple(tuple) | |
640 | |
641 expRes = 1000.0 | |
642 obsRes = range.getBin() | |
643 | |
644 self.assertEquals(expRes, obsRes) | |
645 | |
646 | |
647 def test_getBin_function(self): | |
648 expBin = 2L | |
649 obsBin = getBin(200, 2) | |
650 | |
651 self.assertEquals(expBin, obsBin) | |
652 | |
653 def test_findIdx(self): | |
654 o = Range() | |
655 o.setFromString( "chunk1\t1000\t2000\n" ) | |
656 self.assertEqual(o.findIdx(),2000000) | |
657 | |
658 o.setFromString( "chunk1\t2000\t1000\n" ) | |
659 self.assertEqual(o.findIdx(),2000000) | |
660 | |
661 o.setFromString( "chunk1\t200\t999\n" ) | |
662 self.assertEqual(o.findIdx(),1000000) | |
663 | |
664 o.setFromString( "chunk1\t1\t20000000\n" ) | |
665 self.assertEqual(o.findIdx(),4000000) | |
666 | |
667 | |
668 test_suite = unittest.TestSuite() | |
669 test_suite.addTest( unittest.makeSuite( Test_Range ) ) | |
670 if __name__ == "__main__": | |
671 unittest.TextTestRunner(verbosity=2).run( test_suite ) |