Mercurial > repos > yufei-luo > s_mart

comparison smart_toolShed/commons/core/coord/test/Test_Range.py @ 0:e0f8dcca02ed

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Uploaded S-MART tool. A toolbox manages RNA-Seq and ChIP-Seq data.
author yufei-luo
date Thu, 17 Jan 2013 10:52:14 -0500
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:e0f8dcca02ed
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 )