--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commons/core/coord/test/Test_Range.py	Fri Jan 18 04:54:14 2013 -0500
@@ -0,0 +1,671 @@
+# Copyright INRA (Institut National de la Recherche Agronomique)
+# http://www.inra.fr
+# http://urgi.versailles.inra.fr
+#
+# This software is governed by the CeCILL license under French law and
+# abiding by the rules of distribution of free software.  You can  use, 
+# modify and/ or redistribute the software under the terms of the CeCILL
+# license as circulated by CEA, CNRS and INRIA at the following URL
+# "http://www.cecill.info". 
+#
+# As a counterpart to the access to the source code and  rights to copy,
+# modify and redistribute granted by the license, users are provided only
+# with a limited warranty  and the software's author,  the holder of the
+# economic rights,  and the successive licensors  have only  limited
+# liability. 
+#
+# In this respect, the user's attention is drawn to the risks associated
+# with loading,  using,  modifying and/or developing or reproducing the
+# software by the user in light of its specific status of free software,
+# that may mean  that it is complicated to manipulate,  and  that  also
+# therefore means  that it is reserved for developers  and  experienced
+# professionals having in-depth computer knowledge. Users are therefore
+# encouraged to load and test the software's suitability as regards their
+# requirements in conditions enabling the security of their systems and/or 
+# data to be ensured and,  more generally, to use and operate it in the 
+# same conditions as regards security. 
+#
+# The fact that you are presently reading this means that you have had
+# knowledge of the CeCILL license and that you accept its terms.
+
+
+import unittest
+from commons.core.coord.Range import Range
+from commons.core.coord.Range import getBin, getIdx
+
+
+class Test_Range( unittest.TestCase ):
+    
+    def setUp(self):
+        self._range = Range()
+        
+    def test_setFromString(self):
+        line = "chunk1\t190000\t390000"
+        self._range.setFromString( line )
+        self.assertEqual( self._range.seqname, "chunk1" )
+        self.assertEqual( self._range.start, 190000 )
+        self.assertEqual( self._range.end, 390000 )
+        
+        line = "chunk1\t190000\t390000\n"
+        self._range.setFromString( line )
+        self.assertEqual( self._range.seqname, "chunk1" )
+        self.assertEqual( self._range.start, 190000 )
+        self.assertEqual( self._range.end, 390000 )
+        
+        line = "chunk1;190000;390000"
+        self._range.setFromString( line, ";" )
+        self.assertEqual( self._range.seqname, "chunk1" )
+        self.assertEqual( self._range.start, 190000 )
+        self.assertEqual( self._range.end, 390000 )
+        
+    def test_setFromTuple(self):
+        tuple = ("chunk1","190000","390000")
+        self._range.setFromTuple( tuple)
+        
+        self.assertEqual( self._range.seqname, "chunk1" )
+        self.assertEqual( self._range.start, 190000 )
+        self.assertEqual( self._range.end, 390000 )
+        
+    def test___eq__(self):
+        self._range.setFromString( "chunk1\t190000\t390000\n" )
+        o = Range()
+        o.setFromString( "chunk1\t190000\t390000\n" )
+        self.assertEqual( self._range, o )
+        
+        o.setFromString( "chunk1\t190000\t39" )
+        self.assertNotEquals( self._range, o )
+        
+        o.setFromString( "chromosome1\t190000\t390000" )
+        self.assertNotEquals( self._range, o )
+        
+        o.setFromString( "chunk1\t390000\t190000" )
+        self.assertNotEquals( self._range, o )
+        
+        o.setFromString( "chromosome1\t390000\t190000" )
+        self.assertNotEquals( self._range, o )
+        
+    def test_getMin(self):
+        self._range.setFromTuple( ("chunk1", 190000, 390000) )
+        expMin = 190000
+        obsMin = self._range.getMin() 
+        self.assertTrue(expMin, obsMin)
+        
+    def test_getMax(self):
+        self._range.setFromTuple( ("chunk1", 190000, 390000) )
+        expMax = 390000
+        obsMax = self._range.getMax() 
+        self.assertTrue(expMax, obsMax)
+        
+    def test_isOnDirectStrand_true(self):
+        self._range.setFromTuple( ("chunk1", 190000, 390000) )
+        self.assertTrue(self._range.isOnDirectStrand())
+        
+    def test_isOnDirectStrand_false(self):
+        self._range.setFromTuple( ("chunk1", 390000, 190000) )
+        self.assertFalse(self._range.isOnDirectStrand())
+        
+    def test_isOnReverseStrand_true(self):
+        self._range.setFromTuple( ("chunk1", 390000, 190000) )
+        self.assertTrue(self._range.isOnReverseStrand())
+        
+    def test_isOnReverseStrand_false(self):
+        self._range.setFromTuple( ("chunk1", 190000, 390000) )
+        self.assertFalse(self._range.isOnReverseStrand())
+        
+    def test_getStrand_direct(self):
+        self._range.setFromTuple( ("chunk1", 190000, 390000) )
+        expStrand = '+'
+        obsStrand = self._range.getStrand()
+        self.assertEqual(expStrand, obsStrand)
+        
+    def test_getStrand_reverse(self):
+        self._range.setFromTuple( ("chunk1", 390000, 190000) )
+        expStrand = '-'
+        obsStrand = self._range.getStrand()
+        self.assertEqual(expStrand, obsStrand)
+        
+    def test_reverse(self):
+        obsRange = Range("chunk1", 190000, 390000)
+        expRange = Range("chunk1", 390000, 190000)
+        obsRange.reverse()
+        self.assertEquals(expRange, obsRange)
+        
+    def test_getLength(self):
+        self._range.setFromTuple( ("chunk1", 190000, 390000) )
+        expLength = 200001 
+        obsLength = self._range.getLength()
+        self.assertEquals(expLength, obsLength)
+        
+    def test_isEmpty_true( self ):
+        exp = True
+        obs = self._range.isEmpty()
+        self.assertEquals( exp, obs )
+        
+    def test_isEmpty_false( self ):
+        self._range.setFromTuple( ( "seq1", 1, 10 ) )
+        exp = False
+        obs = self._range.isEmpty()
+        self.assertEquals( exp, obs )
+        
+    def test_merge_diff_sequences( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        range2 = Range( "seq2", 6, 12 )
+        expReturn = None
+        expRange = Range( "seq1", 6, 10 )
+        obsReturn = self._range.merge( range2 )
+        obsRange = self._range
+        self.assertEquals( expReturn, obsReturn )
+        self.assertEquals( expRange, obsRange )
+        
+    def test_merge_no_overlapping_ranges( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        range2 = Range( "seq1", 12, 20 )
+        expReturn = None
+        expRange = Range( "seq1", 6, 20 )
+        obsReturn = self._range.merge( range2 )
+        obsRange = self._range
+        self.assertEquals( expReturn, obsReturn )
+        self.assertEquals( expRange, obsRange )
+        
+    def test_merge_no_overlapping_ranges_range1_on_neg_strand( self ):
+        self._range.setFromTuple( ( "seq1", 10, 6 ) )
+        range2 = Range( "seq1", 12, 20 )
+        expReturn = None
+        expRange = Range( "seq1", 20, 6 )
+        obsReturn = self._range.merge( range2 )
+        obsRange = self._range
+        self.assertEquals( expReturn, obsReturn )
+        self.assertEquals( expRange, obsRange )
+        
+    def test_merge_overlapping_ranges_range1_and_range2_on_neg_strand( self ):
+        self._range.setFromTuple( ( "seq1", 10, 6 ) )
+        range2 = Range( "seq1", 20, 12 )
+        expReturn = None
+        expRange = Range( "seq1", 20, 6 )
+        obsReturn = self._range.merge( range2 )
+        obsRange = self._range
+        self.assertEquals( expReturn, obsReturn )
+        self.assertEquals( expRange, obsRange )
+        
+    def test_merge_on_overlapping_ranges_range1_and_range2( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        range2 = Range( "seq1", 8, 20 )
+        expReturn = None
+        expRange = Range( "seq1", 6, 20 )
+        obsReturn = self._range.merge( range2 )
+        obsRange = self._range
+        self.assertEquals( expReturn, obsReturn )
+        self.assertEquals( expRange, obsRange )
+        
+    def test_isOverlapping_diff_sequences( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        r2 = Range( "seq2", 6, 10 )
+        exp = False
+        obs = self._range.isOverlapping( r2 )
+        self.assertEquals( exp, obs )
+        
+    def test_isOverlapping_no( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        r2 = Range( "seq1", 16, 20 )
+        exp = False
+        obs = self._range.isOverlapping( r2 )
+        self.assertEquals( exp, obs )
+        
+    def test_isOverlapping_yes( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        r2 = Range( "seq1", 1, 15 )
+        exp = True
+        obs = self._range.isOverlapping( r2 )
+        self.assertEquals( exp, obs )
+        
+    def test_isOverlapping_yes_range2_on_neg_strand( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        r2 = Range( "seq1", 15, 1 )
+        exp = True
+        obs = self._range.isOverlapping( r2 )
+        self.assertEquals( exp, obs )
+        
+    def test_isOverlapping_range1_before_range2( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        r2 = Range( "seq1", 8, 15 )
+        exp = True
+        obs = self._range.isOverlapping( r2 )
+        self.assertEquals( exp, obs )
+        
+    def test_isOverlapping_range1_after_range2( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        r2 = Range( "seq1", 1, 8 )
+        exp = True
+        obs = self._range.isOverlapping( r2 )
+        self.assertEquals( exp, obs )
+        
+    def test_isOverlapping_range1_equal_range2( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        r2 = Range( "seq1", 6, 10 )
+        exp = True
+        obs = self._range.isOverlapping( r2 )
+        self.assertEquals( exp, obs )
+        
+    def test_isOverlapping_yes_edges_left( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        r2 = Range( "seq1", 1, 6 )
+        exp = True
+        obs = self._range.isOverlapping( r2 )
+        self.assertEquals( exp, obs )
+        
+    def test_isOverlapping_yes_edges_right( self ):
+        self._range.setFromTuple( ( "seq1", 6, 10 ) )
+        r2 = Range( "seq1", 10, 20 )
+        exp = True
+        obs = self._range.isOverlapping( r2 )
+        self.assertEquals( exp, obs )
+        
+    def test_isOverlapping_yes_one_nt( self ):
+        self._range.setFromTuple( ( "seq1", 10, 10 ) )
+        r2 = Range( "seq1", 10, 20 )
+        exp = True
+        obs = self._range.isOverlapping( r2 )
+        self.assertEquals( exp, obs )
+        
+        
+    def test_getOverlapLength_on_different_range( self ):
+        range1 = Range( "chunk1", 190000, 390000 )
+        range2 = Range( "chunk2", 290000, 590000 )
+        expSize = 0
+        obsSize = range1.getOverlapLength( range2 )
+        self.assertEquals( expSize, obsSize )
+        
+        
+    def test_getOverlapLength_on_no_overalping_range( self ):
+        range1 =Range( "chunk1", 190000, 390000 )
+        range2 =Range( "chunk1", 490000, 590000 )
+        expSize = 0
+        obsSize = range1.getOverlapLength( range2 )
+        self.assertEquals( expSize, obsSize )
+        
+        
+    def test_getOverlapLength_range2_included_in_range1( self ):
+        range1 = Range( "chunk1", 19, 39 )
+        range2 = Range( "chunk1", 22, 25 )
+        expSize = 4
+        obsSize = range1.getOverlapLength( range2 )
+        self.assertEquals( expSize, obsSize )
+        obsSize = range2.getOverlapLength( range1 )
+        self.assertEquals( expSize, obsSize )
+        
+        
+    def test_getOverlapLength_range1_included_in_range2( self ):
+        range1 = Range( "chunk1", 220000, 250000 )
+        range2 = Range( "chunk1", 190000, 390000 )
+        expSize = 30001
+        obsSize = range1.getOverlapLength( range2 )
+        self.assertEquals( expSize, obsSize )
+        
+        
+    def test_getOverlapLength_range1_before_range2( self ):
+        range1 = Range( "chunk1", 190000, 390000 )
+        range2 = Range( "chunk1", 290000, 590000 )
+        expSize = 100001
+        obsSize = range1.getOverlapLength( range2 )
+        self.assertEquals( expSize, obsSize )
+        
+        
+    def test_getOverlapLength_range1_after_range2( self ):
+        range1 = Range( "chunk1", 390000, 790000 )
+        range2 = Range( "chunk1", 290000, 590000 )
+        expSize = 200001
+        obsSize = range1.getOverlapLength( range2 )
+        self.assertEquals( expSize, obsSize )
+        
+        
+    def test_isIncludedIn( self ):
+        iRange1 = Range( "chunk1", 21, 30 )
+        iRange2 = Range( "chunk1", 11, 40 )
+        self.assertTrue( iRange1.isIncludedIn( iRange2 ) )
+        
+        
+    def test_isIncludedIn_diffStrand( self ):
+        iRange1 = Range( "chunk1", 21, 30 )
+        iRange2 = Range( "chunk1", 40, 11 )
+        self.assertTrue( iRange1.isIncludedIn( iRange2 ) )
+        
+        
+    def test_isIncludedIn_onlyOverlap( self ):
+        iRange1 = Range( "chunk1", 21, 50 )
+        iRange2 = Range( "chunk1", 11, 40 )
+        self.assertFalse( iRange1.isIncludedIn( iRange2 ) )
+        
+        
+    def test_isIncludedIn_diffSeqname( self ):
+        iRange1 = Range( "chunk1", 21, 30 )
+        iRange2 = Range( "chunk2", 11, 40 )
+        self.assertFalse( iRange1.isIncludedIn( iRange2 ) )
+        
+        
+    def test_getDistance_on_overlapping_range(self):
+        overlapTuple1 = ("chunk1", 220000, 250000)
+        overlapRange1 = Range()
+        overlapRange1.setFromTuple(overlapTuple1)
+        
+        overlapTuple2 = ("chunk1", 190000, 390000)
+        overlapRange2 = Range()
+        overlapRange2.setFromTuple(overlapTuple2)
+        
+        expDistance = 0
+        obsDistance = overlapRange1.getDistance(overlapRange2)
+        
+        self.assertEquals(expDistance, obsDistance)
+        
+    def test_getDistance_on_range1_on_plus_strand_included_in_range2_on_neg_strand(self):
+        tuple1 = ("chunk1", 220000, 250000)
+        range1 = Range()
+        range1.setFromTuple(tuple1)
+        
+        tuple2 = ("chunk1", 390000, 190000)
+        range2 = Range()
+        range1.setFromTuple(tuple2)
+        
+        expDistance = -1
+        obsDistance = range1.getDistance(range2)
+        
+        self.assertEquals(expDistance, obsDistance)
+        
+    def test_getDistance_range1_after_range2(self):
+        tuple1 = ("chunk1", 390000, 590000)
+        range1 = Range()
+        range1.setFromTuple(tuple1)
+        
+        tuple2 = ("chunk1", 190000, 290000)
+        range2 = Range()
+        range2.setFromTuple(tuple2)
+        
+        expDistance = 100000
+        obsDistance = range1.getDistance(range2)
+        
+        self.assertEquals(expDistance, obsDistance)
+        
+    def test_getDistance_range1_before_range2(self):
+        tuple1 = ("chunk1", 190000, 290000)
+        range1 = Range()
+        range1.setFromTuple(tuple1)
+        
+        tuple2 = ("chunk1", 390000, 590000)
+        range2 = Range()
+        range2.setFromTuple(tuple2)
+        
+        expDistance = 100000
+        obsDistance = range1.getDistance(range2)
+        
+        self.assertEquals(expDistance, obsDistance)
+        
+    def test_getDistance_range1_after_range2_both_on_neg_strand(self):   
+        tuple1 = ("chunk1", 590000, 390000)
+        range1 = Range()
+        range1.setFromTuple(tuple1)
+        
+        tuple2 = ("chunk1", 290000, 190000)
+        range2 = Range()
+        range2.setFromTuple(tuple2)
+        
+        expDistance = 100000
+        obsDistance = range1.getDistance(range2)
+        
+        self.assertEquals(expDistance, obsDistance)
+        
+    def test_getDistance_range1_before_range2_both_on_neg_strand(self):   
+        tuple1 = ("chunk1", 290000, 190000)
+        range1 = Range()
+        range1.setFromTuple(tuple1)
+        
+        tuple2 = ("chunk1", 590000, 390000)
+        range2 = Range()
+        range2.setFromTuple(tuple2)
+        
+        expDistance = 100000
+        obsDistance = range1.getDistance(range2)
+        
+        self.assertEquals(expDistance, obsDistance)
+        
+    def test_diff_on_no_overlapping_range(self):
+        range1 = Range("chunk1", 190000, 390000)
+        range2 = Range("chunk1", 490000, 590000)
+        
+        expRange1 = Range("chunk1",190000,390000)
+        expReturnedRange = Range("chunk1")
+        
+        obsReturnedRange = range1.diff(range2)
+        obsRange1 = range1
+        
+        self.assertEquals(expRange1, obsRange1)
+        self.assertEquals(expReturnedRange, obsReturnedRange)
+        
+    def test_diff_on_different_chunks(self):
+        range1 = Range("chunk1", 190000, 390000)
+        range2 = Range("chunk2", 290000, 590000)
+        
+        expRange1 = Range("chunk1", 190000, 390000)
+        expReturnedRange = Range("chunk1")
+        
+        obsReturnedRange = range1.diff(range2)
+        obsRange1 = range1
+        
+        self.assertEquals(expRange1, obsRange1)
+        self.assertEquals(expReturnedRange, obsReturnedRange)
+        
+    def test_diff_range1_before_range2(self):
+        range1 = Range("chunk1", 190000, 390000)
+        range2 = Range("chunk1", 290000, 590000)
+        
+        expRange1 = Range("chunk1", 190000, 289999)
+        expReturnedRange = Range("chunk1")
+        
+        obsReturnedRange = range1.diff(range2)
+        obsRange1 = range1
+        
+        self.assertEquals(expRange1, obsRange1)
+        self.assertEquals(expReturnedRange, obsReturnedRange)
+        
+    def test_diff_range1_before_range2_range1_on_neg_strand(self):
+        range1 = Range("chunk1", 390000, 190000)
+        range2 = Range("chunk1", 290000, 590000)
+        
+        expRange1 = Range("chunk1", 289999, 190000)
+        expReturnedRange = Range("chunk1")
+        
+        obsReturnedRange = range1.diff(range2)
+        obsRange1 = range1
+        
+        self.assertEquals(expRange1, obsRange1)
+        self.assertEquals(expReturnedRange, obsReturnedRange)
+        
+    def test_diff_range2_included_in_range1(self):
+        range1 = Range("chunk1", 190000, 590000)
+        range2 = Range("chunk1", 290000, 390000)
+        
+        expRange1 = Range("chunk1", 190000, 289999)
+        expReturnedRange = Range("chunk1", 390001, 590000)
+        
+        obsReturnedRange = range1.diff(range2)
+        obsRange1 = range1
+        
+        self.assertEquals(expRange1, obsRange1)
+        self.assertEquals(expReturnedRange, obsReturnedRange)
+        
+    def test_diff_range2_included_in_range1_range1_on_reverse_strand(self):
+        range1 = Range("chunk1", 590000, 190000)
+        range2 = Range("chunk1", 290000, 390000)
+        
+        expRange1 = Range("chunk1", 289999, 190000)
+        expReturnedRange = Range("chunk1", 590000, 390001)
+        
+        obsReturnedRange = range1.diff(range2)
+        obsRange1 = range1
+        
+        self.assertEquals(expRange1, obsRange1)
+        self.assertEquals(expReturnedRange, obsReturnedRange)
+        
+    def test_diff_range1_included_in_range2(self):
+        range1 = Range("chunk1", 390000, 490000)
+        range2 = Range("chunk1", 290000, 590000)
+        
+        expRange1 = Range("chunk1",0,0)
+        expReturnedRange = Range("chunk1")
+        
+        obsReturnedRange = range1.diff(range2)
+        obsRange1 = range1
+        
+        self.assertEquals(expRange1, obsRange1)
+        self.assertEquals(expReturnedRange, obsReturnedRange)
+        
+    def test_diff_range1_after_range2(self):
+        range1 = Range("chunk1", 390000, 590000)
+        range2 = Range("chunk1", 290000, 490000)
+        
+        expRange1 = Range("chunk1", 490001, 590000)
+        expReturnedRange = Range("chunk1")
+        
+        obsReturnedRange = range1.diff(range2)
+        obsRange1 = range1
+        
+        self.assertEquals(expRange1, obsRange1)
+        self.assertEquals(expReturnedRange, obsReturnedRange)
+        
+    def test_diff_range1_after_range2_range1_on_neg_strand(self):
+        range1 = Range("chunk1", 590000, 390000)
+        range2 = Range("chunk1", 290000, 490000)
+        
+        expRange1 = Range("chunk1", 590000, 490001)
+        expReturnedRange = Range("chunk1")
+        
+        obsReturnedRange = range1.diff(range2)
+        obsRange1 = range1
+        
+        self.assertEquals(expRange1, obsRange1)
+        self.assertEquals(expReturnedRange, obsReturnedRange)
+        
+    def test_getIdx(self):
+        self.assertEqual(getIdx(1000,3),1000001)
+        self.assertEqual(getIdx(999,3),1000000)
+        self.assertEqual(getIdx(2000,3),1000002)
+        self.assertEqual(getIdx(2000,4),2000000)
+        self.assertEqual(getIdx(2000,5),3000000)
+        self.assertEqual(getIdx(20000000,6),4000000)
+        self.assertEqual(getIdx(20000000,5),3000200)
+        self.assertEqual(getIdx(20000000,4),2002000)
+        self.assertEqual(getIdx(20000000,3),1020000)
+        
+    def test_getBin_bin_level_9(self):
+        tuple1 = ("chunk1", 190000000, 390000000)
+        range1 =Range()
+        range1.setFromTuple(tuple1)
+        
+        expRes = 100000000.0
+        obsRes = range1.getBin()
+        
+        self.assertEquals(expRes, obsRes)
+        
+    def test_getBin_bin_level_8(self):
+        tuple1 = ("chunk1", 19000000, 39000000)
+        range1 =Range()
+        range1.setFromTuple(tuple1)
+        
+        expRes = 100000000.0
+        obsRes = range1.getBin()
+        
+        self.assertEquals(expRes, obsRes)
+        
+    def test_getBin_bin_level_7(self):
+        tuple1 = ("chunk1", 1900000, 3900000)
+        range1 =Range()
+        range1.setFromTuple(tuple1)
+        
+        expRes = 10000000.0
+        obsRes = range1.getBin()
+        
+        self.assertEquals(expRes, obsRes)
+        
+    def test_getBin_bin_level_6(self):
+        tuple1 = ("chunk1", 190000, 390000)
+        range1 =Range()
+        range1.setFromTuple(tuple1)
+        
+        expRes = 1000000.0
+        obsRes = range1.getBin()
+        
+        self.assertEquals(expRes, obsRes)
+        
+    def test_getBin_bin_level_5(self):
+        tuple = ("chunk1", 19000, 39000)
+        range =Range()
+        range.setFromTuple(tuple)
+        expRes = 100000.0
+        obsRes = range.getBin()
+        
+        self.assertEquals(expRes, obsRes)
+        
+    def test_getBin_bin_level_4(self):
+        tuple = ("chunk1", 1900, 3900)
+        range =Range()
+        range.setFromTuple(tuple)
+        
+        expRes = 10000.0
+        obsRes = range.getBin()
+        
+        self.assertEquals(expRes, obsRes)
+        
+    def test_getBin_bin_level_3(self):
+        tuple = ("chunk1", 190, 390)
+        range =Range()
+        range.setFromTuple(tuple)
+        
+        expRes = 1000.0
+        obsRes = range.getBin()
+        
+        self.assertEquals(expRes, obsRes)
+        
+    def test_getBin_bin_level_2(self):
+        tuple = ("chunk1", 19, 39)
+        range =Range()
+        range.setFromTuple(tuple)
+        
+        expRes = 1000.0
+        obsRes = range.getBin()
+        
+        self.assertEquals(expRes, obsRes)
+        
+    def test_getBin_bin_level_1(self):
+        tuple = ("chunk1", 1, 3)
+        range =Range()
+        range.setFromTuple(tuple)
+        
+        expRes = 1000.0
+        obsRes = range.getBin()
+        
+        self.assertEquals(expRes, obsRes)
+        
+        
+    def test_getBin_function(self):
+        expBin = 2L
+        obsBin = getBin(200, 2)
+        
+        self.assertEquals(expBin, obsBin)
+        
+    def test_findIdx(self):
+        o = Range()
+        o.setFromString( "chunk1\t1000\t2000\n" )
+        self.assertEqual(o.findIdx(),2000000)
+        
+        o.setFromString( "chunk1\t2000\t1000\n" )       
+        self.assertEqual(o.findIdx(),2000000)
+        
+        o.setFromString( "chunk1\t200\t999\n" )       
+        self.assertEqual(o.findIdx(),1000000)
+        
+        o.setFromString( "chunk1\t1\t20000000\n" )       
+        self.assertEqual(o.findIdx(),4000000)
+        
+        
+test_suite = unittest.TestSuite()
+test_suite.addTest( unittest.makeSuite( Test_Range ) )
+if __name__ == "__main__":
+    unittest.TextTestRunner(verbosity=2).run( test_suite )