6
|
1 # Copyright INRA (Institut National de la Recherche Agronomique)
|
|
2 # http://www.inra.fr
|
|
3 # http://urgi.versailles.inra.fr
|
|
4 #
|
|
5 # This software is governed by the CeCILL license under French law and
|
|
6 # abiding by the rules of distribution of free software. You can use,
|
|
7 # modify and/ or redistribute the software under the terms of the CeCILL
|
|
8 # license as circulated by CEA, CNRS and INRIA at the following URL
|
|
9 # "http://www.cecill.info".
|
|
10 #
|
|
11 # As a counterpart to the access to the source code and rights to copy,
|
|
12 # modify and redistribute granted by the license, users are provided only
|
|
13 # with a limited warranty and the software's author, the holder of the
|
|
14 # economic rights, and the successive licensors have only limited
|
|
15 # liability.
|
|
16 #
|
|
17 # In this respect, the user's attention is drawn to the risks associated
|
|
18 # with loading, using, modifying and/or developing or reproducing the
|
|
19 # software by the user in light of its specific status of free software,
|
|
20 # that may mean that it is complicated to manipulate, and that also
|
|
21 # therefore means that it is reserved for developers and experienced
|
|
22 # professionals having in-depth computer knowledge. Users are therefore
|
|
23 # encouraged to load and test the software's suitability as regards their
|
|
24 # requirements in conditions enabling the security of their systems and/or
|
|
25 # data to be ensured and, more generally, to use and operate it in the
|
|
26 # same conditions as regards security.
|
|
27 #
|
|
28 # The fact that you are presently reading this means that you have had
|
|
29 # knowledge of the CeCILL license and that you accept its terms.
|
|
30
|
|
31
|
|
32 import unittest
|
|
33 import os
|
|
34 import time
|
|
35 from commons.core.coord.Align import Align
|
|
36 from commons.core.coord.Map import Map
|
|
37 from commons.core.utils.FileUtils import FileUtils
|
|
38 from commons.core.coord.Range import Range
|
|
39
|
|
40
|
|
41 class Test_Align( unittest.TestCase ):
|
|
42
|
|
43 def setUp(self):
|
|
44 self._align = Align()
|
|
45 self._uniqId = "%s_%s" % ( time.strftime("%Y%m%d%H%M%S"), os.getpid() )
|
|
46
|
|
47 def tearDown(self):
|
|
48 self._align = None
|
|
49
|
|
50 def test_isEmpty_True(self):
|
|
51 alignInstance = Align()
|
|
52
|
|
53 self.assertTrue(alignInstance.isEmpty())
|
|
54
|
|
55 def test_isEmpty_True_query_is_empty(self):
|
|
56 alignInstance = Align()
|
|
57 line = "\t-1\t-1\tTE2\t3\t10\t1e-20\t30\t90.2\n"
|
|
58 alignInstance.setFromString(line)
|
|
59
|
|
60 self.assertTrue(alignInstance.isEmpty())
|
|
61
|
|
62 def test_isEmpty_True_subject_is_empty(self):
|
|
63 alignInstance = Align()
|
|
64 line = "chr1\t2\t20\t\t-1\t-1\t1e-20\t30\t90.2\n"
|
|
65 alignInstance.setFromString(line)
|
|
66
|
|
67 self.assertTrue(alignInstance.isEmpty())
|
|
68
|
|
69 def test_isEmpty_False(self):
|
|
70 alignInstance = Align()
|
|
71 line = "chr1\t2\t20\tTE2\t3\t10\t1e-20\t30\t90.2\n"
|
|
72 alignInstance.setFromString(line)
|
|
73
|
|
74 self.assertFalse(alignInstance.isEmpty())
|
|
75
|
|
76 def test_read(self):
|
|
77 line = "chr2\t1\t10\tTE3\t11\t17\t1e-20\t30\t90.2\n"
|
|
78 expReturn = 1
|
|
79
|
|
80 dummyMockAlignFile = "dummyMockAlignFile"
|
|
81 mockAlignFileHandle = open(dummyMockAlignFile, "w")
|
|
82 mockAlignFileHandle.write(line)
|
|
83 mockAlignFileHandle.close()
|
|
84
|
|
85 expAlignInstance = Align()
|
|
86 expAlignInstance.setFromString(line)
|
|
87
|
|
88 mockAlignFileHandle = open(dummyMockAlignFile, "r")
|
|
89 obsAlignInstance = Align()
|
|
90 obsReturn = obsAlignInstance.read(mockAlignFileHandle)
|
|
91
|
|
92 mockAlignFileHandle.close()
|
|
93 os.remove(dummyMockAlignFile)
|
|
94
|
|
95 self.assertEquals(expAlignInstance, obsAlignInstance)
|
|
96 self.assertEquals(expReturn, obsReturn)
|
|
97
|
|
98 def test_read_empty_file(self):
|
|
99 expReturn = 0
|
|
100
|
|
101 dummyMockAlignFile = "dummyMockAlignFile"
|
|
102 mockAlignFileHandle = open(dummyMockAlignFile, "w")
|
|
103 mockAlignFileHandle.close()
|
|
104
|
|
105 mockAlignFileHandle = open(dummyMockAlignFile, "r")
|
|
106 obsAlignInstance = Align()
|
|
107 obsReturn = obsAlignInstance.read(mockAlignFileHandle)
|
|
108 os.remove(dummyMockAlignFile)
|
|
109
|
|
110 self.assertEquals(expReturn, obsReturn)
|
|
111
|
|
112 def test_write (self):
|
|
113 expAlignFile = "expMockAlignFile"
|
|
114 expAlignFileHandle = open(expAlignFile, "w")
|
|
115 expLine = "chr1\t1\t10\tTE2\t3\t10\t0\t30\t90.200000\n"
|
|
116 expAlignFileHandle.write(expLine)
|
|
117 expAlignFileHandle.close()
|
|
118
|
|
119 obsAlignFile = "obsAlignFile"
|
|
120 obsAlignFileHandle = open(obsAlignFile, "w")
|
|
121 obsAlignInstance = Align()
|
|
122 obsAlignTuple = ("chr1", 1, 10, "TE2", 3, 10, 0.0, 30, 90.2)
|
|
123 obsAlignInstance.setFromTuple(obsAlignTuple)
|
|
124 obsAlignInstance.write(obsAlignFileHandle)
|
|
125 obsAlignFileHandle.close()
|
|
126
|
|
127 self.assertTrue( FileUtils.are2FilesIdentical( expAlignFile, obsAlignFile ) )
|
|
128 os.remove(expAlignFile)
|
|
129 os.remove(obsAlignFile)
|
|
130
|
|
131 def test_merge (self):
|
|
132 alignInstanceChr1 = Align()
|
|
133 alignInstanceChr2 = Align()
|
|
134
|
|
135 line1 = "chr1\t1\t10\tTE2\t3\t10\t1e-20\t30\t90.2\n"
|
|
136 line2 = "chr2\t1\t10\tTE2\t11\t17\t1e-20\t30\t90.2\n"
|
|
137
|
|
138 alignInstanceChr1.setFromString(line1)
|
|
139 alignInstanceChr2.setFromString(line2)
|
|
140
|
|
141 expResult = None
|
|
142 obsResult = alignInstanceChr1.merge(alignInstanceChr2)
|
|
143
|
|
144 self.assertEquals(expResult, obsResult)
|
|
145
|
|
146 line1 = "chr1\t1\t10\tTE2\t3\t10\t1e-20\t30\t90.2\n"
|
|
147 line2 = "chr1\t1\t10\tTE3\t11\t17\t1e-20\t30\t90.2\n"
|
|
148
|
|
149 alignInstanceTE2 = Align()
|
|
150 alignInstanceTE3 = Align()
|
|
151
|
|
152 alignInstanceTE2.setFromString(line1)
|
|
153 alignInstanceTE3.setFromString(line2)
|
|
154
|
|
155 expResult = None
|
|
156 obsResult = alignInstanceTE2.merge(alignInstanceTE3)
|
|
157
|
|
158 self.assertEquals(expResult, obsResult)
|
|
159
|
|
160 def test_merge_plus_strand1 (self):
|
|
161 alignInstance1 = Align()
|
|
162 alignInstance2 = Align()
|
|
163
|
|
164 line1 = "chr1\t2\t20\tTE2\t3\t10\t1e-20\t30\t90.2\n"
|
|
165 line2 = "chr1\t1\t10\tTE2\t1\t9\t1e-20\t30\t90.2\n"
|
|
166
|
|
167 alignInstance1.setFromString(line1)
|
|
168 alignInstance2.setFromString(line2)
|
|
169
|
|
170 expLine = "chr1\t1\t20\tTE2\t1\t10\t1e-20\t30\t90.2\n"
|
|
171 expAlign = Align()
|
|
172 expAlign.setFromString(expLine)
|
|
173
|
|
174 alignInstance1.merge(alignInstance2)
|
|
175 obsAlign = alignInstance1
|
|
176
|
|
177 self.assertEquals(expAlign, obsAlign)
|
|
178
|
|
179 def test_merge_plus_strand2 (self ):
|
|
180 alignInstance1 = Align()
|
|
181 alignInstance2 = Align()
|
|
182
|
|
183 line1 = "chr1\t2\t20\tTE2\t3\t10\t1e-20\t30\t90.2\n"
|
|
184 line2 = "chr1\t4\t30\tTE2\t4\t12\t1e-20\t30\t90.2\n"
|
|
185
|
|
186 alignInstance1.setFromString(line1)
|
|
187 alignInstance2.setFromString(line2)
|
|
188
|
|
189 expLine = "chr1\t2\t30\tTE2\t3\t12\t1e-20\t30\t90.2\n"
|
|
190 expAlign = Align()
|
|
191 expAlign.setFromString(expLine)
|
|
192
|
|
193 alignInstance1.merge(alignInstance2)
|
|
194 obsAlign = alignInstance1
|
|
195
|
|
196 self.assertEquals(expAlign, obsAlign)
|
|
197
|
|
198 def test_merge_plus_strand3 (self ):
|
|
199 alignInstance1 = Align()
|
|
200 alignInstance2 = Align()
|
|
201
|
|
202 line1 = "chr1\t2\t10\tTE2\t3\t10\t1e-20\t30\t90.2\n"
|
|
203 line2 = "chr1\t1\t20\tTE2\t1\t12\t1e-20\t30\t90.2\n"
|
|
204
|
|
205 alignInstance1.setFromString(line1)
|
|
206 alignInstance2.setFromString(line2)
|
|
207
|
|
208 expLine = "chr1\t1\t20\tTE2\t1\t12\t1e-20\t30\t90.2\n"
|
|
209 expAlign = Align()
|
|
210 expAlign.setFromString(expLine)
|
|
211
|
|
212 alignInstance1.merge(alignInstance2)
|
|
213 obsAlign = alignInstance1
|
|
214
|
|
215 self.assertEquals(expAlign, obsAlign)
|
|
216
|
|
217 def test_merge_plus_strand4 (self ):
|
|
218 alignInstance1 = Align()
|
|
219 alignInstance2 = Align()
|
|
220
|
|
221 line1 = "chr1\t1\t20\tTE2\t1\t12\t1e-20\t30\t90.2\n"
|
|
222 line2 = "chr1\t2\t10\tTE2\t2\t10\t1e-20\t30\t90.2\n"
|
|
223
|
|
224 alignInstance1.setFromString(line1)
|
|
225 alignInstance2.setFromString(line2)
|
|
226
|
|
227 expLine = "chr1\t1\t20\tTE2\t1\t12\t1e-20\t30\t90.2\n"
|
|
228 expAlign = Align()
|
|
229 expAlign.setFromString(expLine)
|
|
230
|
|
231 alignInstance1.merge(alignInstance2)
|
|
232 obsAlign = alignInstance1
|
|
233
|
|
234 self.assertEquals(expAlign, obsAlign)
|
|
235
|
|
236 def test_merge__neg_strand1 (self):
|
|
237
|
|
238 rangeQuery1 = Range("chr1", 20, 2); rangeSubject1 = Range("TE2", 10, 3)
|
|
239 rangeQuery2 = Range("chr1", 1, 10); rangeSubject2 = Range("TE2", 1, 9)
|
|
240
|
|
241 alignInstance1 = Align(rangeQuery1, rangeSubject1, 0, 30, 90.2)
|
|
242 alignInstance2 = Align(rangeQuery2, rangeSubject2, 0, 30, 90.2)
|
|
243
|
|
244 expRangeQuery = Range("chr1", 20, 1); expRangeSubject = Range("TE2", 10, 1)
|
|
245 expAlign = Align(expRangeQuery, expRangeSubject, 0, 30, 90.2)
|
|
246
|
|
247 alignInstance1.merge(alignInstance2)
|
|
248 obsAlign = alignInstance1
|
|
249
|
|
250 self.assertEquals(expAlign, obsAlign)
|
|
251
|
|
252 def test_merge__neg_strand2 (self):
|
|
253 rangeQuery1 = Range("chr1", 20, 2); rangeSubject1 = Range("TE2", 10, 3)
|
|
254 rangeQuery2 = Range("chr1", 4, 30); rangeSubject2 = Range("TE2", 4, 12)
|
|
255
|
|
256 alignInstance1 = Align(rangeQuery1, rangeSubject1, 0, 30, 90.2)
|
|
257 alignInstance2 = Align(rangeQuery2, rangeSubject2, 0, 30, 90.2)
|
|
258
|
|
259 expRangeQuery = Range("chr1", 30, 2); expRangeSubject = Range("TE2", 12, 3)
|
|
260 expAlign = Align(expRangeQuery, expRangeSubject, 0, 30, 90.2)
|
|
261
|
|
262 alignInstance1.merge(alignInstance2)
|
|
263 obsAlign = alignInstance1
|
|
264
|
|
265 self.assertEquals(expAlign, obsAlign)
|
|
266
|
|
267 def test_merge_neg_strand3 (self ):
|
|
268 rangeQuery1 = Range("chr1", 10, 2); rangeSubject1 = Range("TE2", 10, 3)
|
|
269 rangeQuery2 = Range("chr1", 1, 20); rangeSubject2 = Range("TE2", 1, 12)
|
|
270
|
|
271 alignInstance1 = Align(rangeQuery1, rangeSubject1, 0, 30, 90.2)
|
|
272 alignInstance2 = Align(rangeQuery2, rangeSubject2, 0, 30, 90.2)
|
|
273
|
|
274 expRangeQuery = Range("chr1", 20, 1); expRangeSubject = Range("TE2", 12, 1)
|
|
275 expAlign = Align(expRangeQuery, expRangeSubject, 0, 30, 90.2)
|
|
276
|
|
277 alignInstance1.merge(alignInstance2)
|
|
278 obsAlign = alignInstance1
|
|
279
|
|
280 self.assertEquals(expAlign, obsAlign)
|
|
281
|
|
282 def test_merge_neg_strand4 (self ):
|
|
283 rangeQuery1 = Range("chr1", 20, 1); rangeSubject1 = Range("TE2", 12, 1)
|
|
284 rangeQuery2 = Range("chr1", 2, 10); rangeSubject2 = Range("TE2", 2, 10)
|
|
285
|
|
286 alignInstance1 = Align(rangeQuery1, rangeSubject1, 0, 30, 90.2)
|
|
287 alignInstance2 = Align(rangeQuery2, rangeSubject2, 0, 30, 90.2)
|
|
288
|
|
289 expRangeQuery = Range("chr1", 20, 1); expRangeSubject = Range("TE2", 12, 1)
|
|
290 expAlign = Align(expRangeQuery, expRangeSubject, 0, 30, 90.2)
|
|
291
|
|
292 alignInstance1.merge(alignInstance2)
|
|
293 obsAlign = alignInstance1
|
|
294
|
|
295 self.assertEquals(expAlign, obsAlign)
|
|
296
|
|
297 def test_merge_id_score_identity_eValue (self):
|
|
298 rangeQuery1 = Range("chr1", 20, 1); rangeSubject1 = Range("TE2", 12, 1)
|
|
299 rangeQuery2 = Range("chr1", 2, 10); rangeSubject2 = Range("TE2", 2, 10)
|
|
300
|
|
301 alignInstance1 = Align(rangeQuery1, rangeSubject1, 0.05, 20, 90.2)
|
|
302 alignInstance1.id = 1
|
|
303 alignInstance2 = Align(rangeQuery2, rangeSubject2, 0, 30, 90.3)
|
|
304 alignInstance2.id = 2
|
|
305
|
|
306 expRangeQuery = Range("chr1", 20, 1); expRangeSubject = Range("TE2", 12, 1)
|
|
307 expAlign = Align(expRangeQuery, expRangeSubject, 0, 30, 90.3)
|
|
308 expAlign.id = 1
|
|
309
|
|
310 alignInstance1.merge(alignInstance2)
|
|
311 obsAlign = alignInstance1
|
|
312
|
|
313 self.assertEquals(expAlign, obsAlign)
|
|
314 self.assertEquals(expAlign.id, obsAlign.id)
|
|
315
|
|
316 def test_setFromTuple_QryRev(self):
|
|
317 self._align.setFromTuple( ( "qry1", 100, 1, "sbj1", 201, 300, 0.0, 135, 97.2 ) )
|
|
318 self.assertEqual( self._align.range_query.seqname, "qry1" )
|
|
319 self.assertEqual( self._align.range_query.start, 1 )
|
|
320 self.assertEqual( self._align.range_query.end, 100 )
|
|
321 self.assertEqual( self._align.range_subject.seqname, "sbj1" )
|
|
322 self.assertEqual( self._align.range_subject.start, 300 )
|
|
323 self.assertEqual( self._align.range_subject.end, 201 )
|
|
324 self.assertEqual( self._align.e_value, 0.0 )
|
|
325 self.assertEqual( self._align.score, 135 )
|
|
326 self.assertEquals( self._align.identity, 97.2 )
|
|
327
|
|
328 def test_setFromTuple_identityAsFloat(self):
|
|
329 self._align.setFromTuple( ( "qry1", "301", "600", "sbj1", "1", "300", "0.0", "135", 0.0) )
|
|
330 self.assertEqual( self._align.range_query.seqname, "qry1" )
|
|
331 self.assertEqual( self._align.range_query.start, 301 )
|
|
332 self.assertEqual( self._align.range_query.end, 600 )
|
|
333 self.assertEqual( self._align.range_subject.seqname, "sbj1" )
|
|
334 self.assertEqual( self._align.range_subject.start, 1 )
|
|
335 self.assertEqual( self._align.range_subject.end, 300 )
|
|
336 self.assertEqual( self._align.e_value, float("0.0") )
|
|
337 self.assertEqual( self._align.score, float("135") )
|
|
338 self.assertEquals( self._align.identity, 0.0 )
|
|
339
|
|
340 def test_setFromString(self):
|
|
341 line = "chr1\t1\t10\tTE2\t11\t17\t1e-20\t30\t90.2\n"
|
|
342 self._align.setFromString( line )
|
|
343 self.assertEqual( self._align.range_query.seqname, "chr1" )
|
|
344 self.assertEqual( self._align.range_query.start, 1 )
|
|
345 self.assertEqual( self._align.range_query.end, 10 )
|
|
346 self.assertEqual( self._align.range_subject.seqname, "TE2" )
|
|
347 self.assertEqual( self._align.range_subject.start, 11 )
|
|
348 self.assertEqual( self._align.range_subject.end, 17 )
|
|
349 self.assertEqual( self._align.e_value, float("1e-20") )
|
|
350 self.assertEqual( self._align.score, float("30") )
|
|
351 self.assertEquals( float(self._align.identity), float("90.2") )
|
|
352
|
|
353 def test__eq__(self):
|
|
354 self._align.setFromString( "chr1\t1\t6\tTE2\t11\t16\t1e-20\t30\t90.2\n" )
|
|
355 o = Align()
|
|
356 o.setFromString( "chr1\t1\t6\tTE2\t11\t16\t1e-20\t30\t90.2\n" )
|
|
357 self.assertEqual( self._align, o )
|
|
358 o.setFromString( "chromosome1\t1\t6\tTE2\t11\t16\t1e-20\t30\t90.2\n" )
|
|
359 self.assertNotEqual( self._align, o )
|
|
360 o.setFromString( "chr1\t1\t6\ttranspElem2\t11\t16\t1e-20\t30\t90.2\n" )
|
|
361 self.assertNotEqual( self._align, o )
|
|
362 o.setFromString( "chr1\t100\t600\tTE2\t11\t16\t1e-20\t30\t90.2\n" )
|
|
363 self.assertNotEqual( self._align, o )
|
|
364 o.setFromString( "chr1\t1\t6\tTE2\t1100\t1600\t1e-20\t30\t90.2\n" )
|
|
365 self.assertNotEqual( self._align, o )
|
|
366 o.setFromString( "chr1\t1\t6\tTE2\t11\t16\t1e-20\t30000\t90.2\n" )
|
|
367 self.assertNotEqual( self._align, o )
|
|
368
|
|
369 def test_getSubjectAsMapOfQuery_direct(self):
|
|
370 exp = Map( name="TE2", seqname="chr1", start=1, end=6 )
|
|
371 self._align.setFromString( "chr1\t1\t6\tTE2\t11\t16\t1e-20\t30\t90.2\n" )
|
|
372 obs = self._align.getSubjectAsMapOfQuery()
|
|
373 self.assertEqual( obs, exp )
|
|
374
|
|
375 def test_getSubjectAsMapOfQuery_reverse(self):
|
|
376 exp = Map( name="TE2", seqname="chr1", start=6, end=1 )
|
|
377 self._align.setFromString( "chr1\t1\t6\tTE2\t16\t11\t1e-20\t30\t90.2\n" )
|
|
378 obs = self._align.getSubjectAsMapOfQuery()
|
|
379 self.assertEqual( obs, exp )
|
|
380
|
|
381 def test_writeSubjectAsMapOfQuery( self ):
|
|
382 self._align.setFromTuple( ( "chr3", "250", "151", "seq5", "1", "100", "1e-32", "147", "87.9" ) )
|
|
383 expFile = "dummyExpFile_%s" % ( self._uniqId )
|
|
384 expFileHandler = open( expFile, "w" )
|
|
385 expFileHandler.write( "seq5\tchr3\t250\t151\n" )
|
|
386 expFileHandler.close()
|
|
387 obsFile = "dummyObsFile_%s" % ( self._uniqId )
|
|
388 obsFileHandler = open( obsFile, "w" )
|
|
389 self._align.writeSubjectAsMapOfQuery( obsFileHandler )
|
|
390 obsFileHandler.close()
|
|
391 self.assertTrue( FileUtils.are2FilesIdentical( expFile, obsFile ) )
|
|
392 for f in [ expFile, obsFile ]:
|
|
393 if os.path.exists( f ):
|
|
394 os.remove( f )
|
|
395
|
|
396 def test_areQrySbjOnOppositeStrands(self):
|
|
397 self._align.setFromTuple( ( "qry1", "1", "100", "sbj1", "1", "100", "0.0", "135", "95.7" ) )
|
|
398 obs = self._align.areQrySbjOnOppositeStrands()
|
|
399 self.assertFalse( obs )
|
|
400 self._align.setFromTuple( ( "qry1", "600", "301", "sbj1", "1", "300", "0.0", "135", "95.7" ) )
|
|
401 obs = self._align.areQrySbjOnOppositeStrands()
|
|
402 self.assertTrue( obs )
|
|
403
|
|
404 def test_reverse(self):
|
|
405 line = "chr1\t1\t10\tTE2\t11\t17\t1e-20\t30\t90.2"
|
|
406 expLine = "chr1\t10\t1\tTE2\t17\t11\t1e-20\t30\t90.200000"
|
|
407
|
|
408 obsAlignInstance = Align()
|
|
409 obsAlignInstance.setFromString(line)
|
|
410 obsAlignInstance.reverse()
|
|
411 obsLine = obsAlignInstance.toString()
|
|
412
|
|
413 self.assertEquals(expLine, obsLine)
|
|
414
|
|
415 def test_getMapsOfQueryAndSubject(self):
|
|
416 self._align.setFromTuple( ( "qry1", "1", "100", "sbj1", "1", "100", "0.0", "135", "95.7" ) )
|
|
417
|
|
418 expMapQuery = Map()
|
|
419 expMapQuery.setFromTuple( ( "repet", "qry1", "1", "100" ) )
|
|
420 expMapSubject = Map()
|
|
421 expMapSubject.setFromTuple( ( "repet", "sbj1", "1", "100" ) )
|
|
422
|
|
423 obsMapQuery, obsMapSubject = self._align.getMapsOfQueryAndSubject()
|
|
424
|
|
425 self.assertEqual( expMapQuery, obsMapQuery )
|
|
426 self.assertEqual( expMapSubject, obsMapSubject )
|
|
427
|
|
428 def test_getBin_bin_level_9(self):
|
|
429 tuple = ("chr1","190000000","390000000","TE2","11","17","1e-20","30","90.2")
|
|
430 self._align.setFromTuple(tuple)
|
|
431 expRes = 100000000.0
|
|
432 obsRes = self._align.getBin()
|
|
433 self.assertEquals(expRes, obsRes)
|
|
434
|
|
435 def test_getBin_bin_level_8(self):
|
|
436 tuple = ("chr1","19000000","39000000","TE2","11","17","1e-20","30","90.2")
|
|
437 self._align.setFromTuple(tuple)
|
|
438 expRes = 100000000.0
|
|
439 obsRes = self._align.getBin()
|
|
440 self.assertEquals(expRes, obsRes)
|
|
441
|
|
442 def test_getBin_bin_level_7(self):
|
|
443 tuple = ("chr1","1900000","3900000","TE2","11","17","1e-20","30","90.2")
|
|
444 self._align.setFromTuple(tuple)
|
|
445 expRes = 10000000.0
|
|
446 obsRes = self._align.getBin()
|
|
447 self.assertEquals(expRes, obsRes)
|
|
448
|
|
449 def test_getBin_bin_level_6(self):
|
|
450 tuple = ("chr1","190000","390000","TE2","11","17","1e-20","30","90.2")
|
|
451 self._align.setFromTuple(tuple)
|
|
452 obsRes = self._align.getBin()
|
|
453 expRes = 1000000.0
|
|
454 self.assertEquals(expRes, obsRes)
|
|
455
|
|
456 def test_getBin_bin_level_5(self):
|
|
457 tuple = ("chr1","19000","39000","TE2","11","17","1e-20","30","90.2")
|
|
458 self._align.setFromTuple(tuple)
|
|
459 obsRes = self._align.getBin()
|
|
460 expRes = 100000.0
|
|
461 self.assertEquals(expRes, obsRes)
|
|
462
|
|
463 def test_getBin_bin_level_4(self):
|
|
464 tuple = ("chr1","1900","3900","TE2","11","17","1e-20","30","90.2")
|
|
465 self._align.setFromTuple(tuple)
|
|
466 obsRes = self._align.getBin()
|
|
467 expRes = 10000.0
|
|
468 self.assertEquals(expRes, obsRes)
|
|
469
|
|
470 def test_getBin_bin_level_3(self):
|
|
471 tuple = ("chr1","190","390","TE2","11","17","1e-20","30","90.2")
|
|
472 self._align.setFromTuple(tuple)
|
|
473 obsRes = self._align.getBin()
|
|
474 expRes = 1000.0
|
|
475 self.assertEquals(expRes, obsRes)
|
|
476
|
|
477 def test_getBin_bin_level_2(self):
|
|
478 tuple = ("chr1","19","39","TE2","11","17","1e-20","30","90.2")
|
|
479 self._align.setFromTuple(tuple)
|
|
480 obsRes = self._align.getBin()
|
|
481 expRes = 1000.0
|
|
482 self.assertEquals(expRes, obsRes)
|
|
483
|
|
484 def test_getBin_bin_level_1(self):
|
|
485 tuple = ("chr1","1","3","TE2","11","17","1e-20","30","90.2")
|
|
486 self._align.setFromTuple(tuple)
|
|
487 obsRes = self._align.getBin()
|
|
488 expRes = 1000.0
|
|
489 self.assertEquals(expRes, obsRes)
|
|
490
|
|
491
|
|
492 def test_switchQuerySubject_directS( self ):
|
|
493 tuple = ("chr1","1","3","TE2","11","17","1e-20","30","90.2")
|
|
494 self._align.setFromTuple( tuple )
|
|
495 exp = Align( Range("TE2","11","17"), Range("chr1","1","3"), "1e-20", "30", "90.2" )
|
|
496 self._align.switchQuerySubject()
|
|
497 self.assertEquals( exp, self._align )
|
|
498
|
|
499
|
|
500 def test_switchQuerySubject_reverseS( self ):
|
|
501 tuple = ("chr1","1","3","TE2","17","11","1e-20","30","90.2")
|
|
502 self._align.setFromTuple( tuple )
|
|
503 exp = Align( Range("TE2","11","17"), Range("chr1","3","1"), "1e-20", "30", "90.2" )
|
|
504 self._align.switchQuerySubject()
|
|
505 self.assertEquals( exp, self._align )
|
|
506
|
|
507
|
|
508 def test_toStringAsGff( self ):
|
|
509 self._align.setFromString( "chr1\t1\t10\tTE3\t11\t17\t1e-20\t30\t85.2\n" )
|
|
510 exp = "chr1\tREPET\tmatch\t1\t10\t1e-20\t+\t.\tID=23;Target=TE3 11 17"
|
|
511 obs = self._align.toStringAsGff( ID="23" )
|
|
512 self.assertEqual( obs, exp )
|
|
513
|
|
514
|
|
515 test_suite = unittest.TestSuite()
|
|
516 test_suite.addTest( unittest.makeSuite( Test_Align ) )
|
|
517 if __name__ == "__main__":
|
|
518 unittest.TextTestRunner(verbosity=2).run( test_suite )
|