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 import shutil
|
|
36 from commons.core.coord.AlignUtils import AlignUtils
|
|
37 from commons.core.coord.Align import Align
|
|
38 from commons.core.utils.FileUtils import FileUtils
|
|
39 from commons.core.coord.Range import Range
|
|
40
|
|
41
|
|
42 class Test_AlignUtils( unittest.TestCase ):
|
|
43
|
|
44 def setUp( self ):
|
|
45 self._uniqId = "%s_%s" % ( time.strftime("%Y%m%d%H%M%S"), os.getpid() )
|
|
46
|
|
47
|
|
48 def tearDown( self ):
|
|
49 self._uniqId = ""
|
|
50
|
|
51
|
|
52 def test_getAlignListFromFile( self ):
|
|
53 a1 = Align()
|
|
54 a1.setFromTuple( ( "chr1", "1", "100", "seq3", "1", "100", "1e-23", "89", "97.26" ) )
|
|
55 a2 = Align()
|
|
56 a2.setFromTuple( ( "chr2", "121", "210", "seq5", "21", "110", "1e-32", "95", "98.13" ) )
|
|
57
|
|
58 inFileName = "dummyFile_%s" % ( self._uniqId )
|
|
59 inFileHandler = open( inFileName, "w" )
|
|
60 a1.write( inFileHandler )
|
|
61 a2.write( inFileHandler )
|
|
62 inFileHandler.close()
|
|
63
|
|
64 lExp = [ a1, a2 ]
|
|
65 lObs = AlignUtils.getAlignListFromFile( inFileName )
|
|
66
|
|
67 self.assertEqual( lExp, lObs )
|
|
68
|
|
69 if os.path.exists( inFileName ):
|
|
70 os.remove( inFileName )
|
|
71
|
|
72
|
|
73 def test_getListOfScores( self ):
|
|
74 a1 = Align()
|
|
75 a1.setFromTuple( ( "chr1", "1", "100", "seq3", "1", "100", "1e-23", "89", "97.26" ) )
|
|
76 a2 = Align()
|
|
77 a2.setFromTuple( ( "chr2", "121", "210", "seq5", "21", "110", "1e-32", "95", "98.13" ) )
|
|
78 lAligns = [ a1, a2 ]
|
|
79
|
|
80 lExp = [ 89, 95 ]
|
|
81 lObs = AlignUtils.getListOfScores( lAligns )
|
|
82
|
|
83 self.assertEqual( lExp, lObs )
|
|
84
|
|
85
|
|
86 def test_getScoreListFromFile( self ):
|
|
87 alignFile = "dummyAlignFile"
|
|
88 alignFileHandler = open( alignFile, "w" )
|
|
89 alignFileHandler.write( "chr3\t1\t100\tchr5\t11\t110\t1e-52\t133\t87.2\n" )
|
|
90 alignFileHandler.write( "chr7\t1\t200\tchr2\t11\t210\t1e-78\t235\t98.9\n" )
|
|
91 alignFileHandler.close()
|
|
92
|
|
93 lExp = [ 133, 235 ]
|
|
94 lObs = AlignUtils.getScoreListFromFile( alignFile )
|
|
95 self.assertEqual( lExp, lObs )
|
|
96
|
|
97 os.remove( alignFile )
|
|
98
|
|
99
|
|
100 def test_getScoreListFromFile_empty_file( self ):
|
|
101 alignFile = "dummyAlignFile"
|
|
102 alignFileHandler = open( alignFile, "w" )
|
|
103 alignFileHandler.close()
|
|
104
|
|
105 lExp = []
|
|
106 lObs = AlignUtils.getScoreListFromFile( alignFile )
|
|
107
|
|
108 self.assertEqual( lExp, lObs )
|
|
109
|
|
110 os.remove( alignFile )
|
|
111
|
|
112
|
|
113 def test_getScoreListFromFile_with_endline_char( self ):
|
|
114 alignFile = "dummyAlignFile"
|
|
115 alignFileHandler = open( alignFile, "w" )
|
|
116 alignFileHandler.write( "chr3\t1\t100\tchr5\t11\t110\t1e-52\t133\t87.2\n" )
|
|
117 alignFileHandler.write( "\n" )
|
|
118 alignFileHandler.write( "chr7\t1\t200\tchr2\t11\t210\t1e-78\t235\t98.9\n" )
|
|
119 alignFileHandler.write( "\n" )
|
|
120 alignFileHandler.close()
|
|
121
|
|
122 lExp = [133, 235]
|
|
123 lObs = AlignUtils.getScoreListFromFile( alignFile )
|
|
124
|
|
125 self.assertEqual( lExp, lObs )
|
|
126
|
|
127 os.remove( alignFile )
|
|
128
|
|
129
|
|
130 def test_convertAlignFileIntoMapFileWithQueriesAndSubjects( self ):
|
|
131 alignFile = "dummyAlignFile_%s" % ( self._uniqId )
|
|
132 alignFileHandler = open( alignFile, "w" )
|
|
133 alignFileHandler.write( "chr3\t1\t100\tchr5\t11\t110\t1e-52\t133\t87.2\n" )
|
|
134 alignFileHandler.write( "chr7\t1\t200\tchr2\t11\t210\t1e-78\t235\t98.9\n" )
|
|
135 alignFileHandler.close()
|
|
136
|
|
137 expFile = "dummyExpFile_%s" % ( self._uniqId )
|
|
138 expFileHandler = open( expFile, "w" )
|
|
139 expFileHandler.write( "repet\tchr3\t1\t100\n" )
|
|
140 expFileHandler.write( "repet\tchr5\t11\t110\n" )
|
|
141 expFileHandler.write( "repet\tchr7\t1\t200\n" )
|
|
142 expFileHandler.write( "repet\tchr2\t11\t210\n" )
|
|
143 expFileHandler.close()
|
|
144
|
|
145 obsFile = "dummyObsFile_%s" % ( self._uniqId )
|
|
146
|
|
147 AlignUtils.convertAlignFileIntoMapFileWithQueriesAndSubjects( alignFile, obsFile )
|
|
148
|
|
149 self.assertTrue( FileUtils.are2FilesIdentical( expFile, obsFile ) )
|
|
150
|
|
151 for f in [ alignFile, expFile, obsFile ]:
|
|
152 if os.path.exists( f ):
|
|
153 os.remove( f )
|
|
154
|
|
155
|
|
156 def test_convertAlignFileIntoMapFileWithSubjectsOnQueries( self ):
|
|
157 alignFile = "dummyAlignFile_%s" % ( self._uniqId )
|
|
158 alignFileHandler = open( alignFile, "w" )
|
|
159 alignFileHandler.write( "chr3\t1\t100\tTE1\t11\t110\t1e-52\t133\t87.2\n" )
|
|
160 alignFileHandler.write( "chr7\t1\t200\tTE1\t11\t210\t1e-78\t235\t98.9\n" )
|
|
161 alignFileHandler.close()
|
|
162
|
|
163 expFile = "dummyExpFile_%s" % ( self._uniqId )
|
|
164 expFileHandler = open( expFile, "w" )
|
|
165 expFileHandler.write( "TE1\tchr3\t1\t100\n" )
|
|
166 expFileHandler.write( "TE1\tchr7\t1\t200\n" )
|
|
167 expFileHandler.close()
|
|
168
|
|
169 obsFile = "dummyObsFile_%s" % ( self._uniqId )
|
|
170
|
|
171 AlignUtils.convertAlignFileIntoMapFileWithSubjectsOnQueries( alignFile, obsFile )
|
|
172
|
|
173 self.assertTrue( FileUtils.are2FilesIdentical( expFile, obsFile ) )
|
|
174
|
|
175 for f in [ alignFile, expFile, obsFile ]:
|
|
176 if os.path.exists( f ):
|
|
177 os.remove( f )
|
|
178
|
|
179
|
|
180 def test_getAlignListSortedByDecreasingScoreThenLength( self ):
|
|
181 a1 = Align()
|
|
182 a1.setFromTuple( ( "chr1", "1", "100", "seq3", "1", "100", "1e-23", "89", "97.26" ) )
|
|
183 a2 = Align()
|
|
184 a2.setFromTuple( ( "chr7", "121", "200", "seq9", "21", "110", "1e-32", "95", "98.13" ) )
|
|
185 a3 = Align()
|
|
186 a3.setFromTuple( ( "chr2", "121", "210", "seq5", "21", "110", "1e-32", "95", "98.13" ) )
|
|
187 lAligns = [ a1, a2, a3 ]
|
|
188
|
|
189 lExp = [ a3, a2, a1 ]
|
|
190
|
|
191 lObs = AlignUtils.getAlignListSortedByDecreasingScoreThenLength( lAligns )
|
|
192
|
|
193 self.assertEqual( lExp, lObs )
|
|
194
|
|
195
|
|
196 def test_convertAlignFileIntoPathFile( self ):
|
|
197 alignFile = "dummyAlignFile_%s" % ( self._uniqId )
|
|
198 alignFileHandler = open( alignFile, "w" )
|
|
199 alignFileHandler.write( "chr3\t1\t100\tchr5\t11\t110\t1e-52\t133\t87.200000\n" )
|
|
200 alignFileHandler.write( "chr7\t1\t200\tchr2\t11\t210\t1e-78\t235\t98.900000\n" )
|
|
201 alignFileHandler.close()
|
|
202
|
|
203 expFile = "dummyExpFile_%s" % ( self._uniqId )
|
|
204 expFileHandler = open( expFile, "w" )
|
|
205 expFileHandler.write( "1\tchr3\t1\t100\tchr5\t11\t110\t1e-52\t133\t87.200000\n" )
|
|
206 expFileHandler.write( "2\tchr7\t1\t200\tchr2\t11\t210\t1e-78\t235\t98.900000\n" )
|
|
207 expFileHandler.close()
|
|
208
|
|
209 obsFile = "dummyObsFile_%s" % ( self._uniqId )
|
|
210
|
|
211 AlignUtils.convertAlignFileIntoPathFile( alignFile, obsFile )
|
|
212
|
|
213 self.assertTrue( FileUtils.are2FilesIdentical( expFile, obsFile ) )
|
|
214
|
|
215 for f in [ alignFile, expFile, obsFile ]:
|
|
216 if os.path.exists( f ):
|
|
217 os.remove( f )
|
|
218
|
|
219
|
|
220 def test_sortAlignFile( self ):
|
|
221 alignFile = "dummyAlignFile_%s" % ( self._uniqId )
|
|
222 alignFileHandler = open( alignFile, "w" )
|
|
223 alignFileHandler.write( "chr7\t1\t200\tchr2\t11\t210\t1e-78\t235\t98.900000\n" )
|
|
224 alignFileHandler.write( "chr3\t1\t100\tchr5\t11\t110\t1e-52\t133\t87.200000\n" )
|
|
225 alignFileHandler.write( "chr8\t1\t100\tchr5\t11\t110\t1e-52\t133\t87.200000\n" )
|
|
226 alignFileHandler.write( "chr8\t1\t100\tchr5\t15\t90\t1e-52\t133\t87.200000\n" )
|
|
227 alignFileHandler.write( "chr8\t1\t100\tchr5\t11\t100\t1e-52\t133\t87.200000\n" )
|
|
228 alignFileHandler.close()
|
|
229
|
|
230 expFile = "dummyExpFile_%s" % ( self._uniqId )
|
|
231 expFileHandler = open( expFile, "w" )
|
|
232 expFileHandler.write( "chr3\t1\t100\tchr5\t11\t110\t1e-52\t133\t87.200000\n" )
|
|
233 expFileHandler.write( "chr7\t1\t200\tchr2\t11\t210\t1e-78\t235\t98.900000\n" )
|
|
234 expFileHandler.write( "chr8\t1\t100\tchr5\t11\t100\t1e-52\t133\t87.200000\n" )
|
|
235 expFileHandler.write( "chr8\t1\t100\tchr5\t11\t110\t1e-52\t133\t87.200000\n" )
|
|
236 expFileHandler.write( "chr8\t1\t100\tchr5\t15\t90\t1e-52\t133\t87.200000\n" )
|
|
237 expFileHandler.close()
|
|
238
|
|
239 obsFile = "dummyObsFile_%s" % ( self._uniqId )
|
|
240
|
|
241 AlignUtils.sortAlignFile( alignFile, obsFile )
|
|
242
|
|
243 self.assertTrue( FileUtils.are2FilesIdentical( expFile, obsFile ) )
|
|
244
|
|
245 for f in [ alignFile, expFile, obsFile ]:
|
|
246 if os.path.exists( f ):
|
|
247 os.remove( f )
|
|
248
|
|
249 def test_writeListInFile( self ):
|
|
250 line1 = ("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.200000\n")
|
|
251 line2 = ("chr1\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.200000\n")
|
|
252 line3 = ("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.200000\n")
|
|
253
|
|
254 expFileName = "expFileName.align"
|
|
255 expFileHandle = open ( expFileName, 'w' )
|
|
256 expFileHandle.write(line1)
|
|
257 expFileHandle.write(line2)
|
|
258 expFileHandle.write(line3)
|
|
259 expFileHandle.close()
|
|
260
|
|
261 iAlign1 = Align()
|
|
262 iAlign1.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
263 iAlign2 = Align()
|
|
264 iAlign2.setFromString("chr1\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
265 iAlign3 = Align()
|
|
266 iAlign3.setFromString("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
267
|
|
268 obsFileName = "obsFileName.align"
|
|
269 obsPathList =[iAlign1, iAlign2, iAlign3]
|
|
270
|
|
271 AlignUtils.writeListInFile( obsPathList, obsFileName )
|
|
272
|
|
273 self.assertTrue( FileUtils.are2FilesIdentical( expFileName, obsFileName ) )
|
|
274
|
|
275 os.remove( obsFileName )
|
|
276 os.remove( expFileName )
|
|
277
|
|
278
|
|
279 def test_splitAlignListByQueryName_empty_list( self ):
|
|
280 lAlign = []
|
|
281
|
|
282 obsLAlign = AlignUtils.splitAlignListByQueryName( lAlign )
|
|
283
|
|
284 expLAlign = []
|
|
285
|
|
286 self.assertEquals( expLAlign, obsLAlign )
|
|
287
|
|
288
|
|
289 def test_splitAlignListByQueryName( self ):
|
|
290 iAlign1 = Align()
|
|
291 iAlign1.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
292 iAlign2 = Align()
|
|
293 iAlign2.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
294 iAlign3 = Align()
|
|
295 iAlign3.setFromString("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
296 lAlign = [ iAlign1, iAlign2, iAlign3 ]
|
|
297
|
|
298 obsLAlign = AlignUtils.splitAlignListByQueryName( lAlign )
|
|
299
|
|
300 expLAlign = [ [ iAlign1, iAlign3 ],
|
|
301 [ iAlign2 ] ]
|
|
302
|
|
303 self.assertEquals( expLAlign, obsLAlign )
|
|
304
|
|
305
|
|
306 def test_splitAlignListByQueryName_last_align_alone( self ):
|
|
307 iAlign1 = Align()
|
|
308 iAlign1.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
309 iAlign2 = Align()
|
|
310 iAlign2.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
311 iAlign3 = Align()
|
|
312 iAlign3.setFromString("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
313 iAlign4 = Align()
|
|
314 iAlign4.setFromString("chr3\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
315 iAlign5 = Align()
|
|
316 iAlign5.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
317 iAlign6 = Align()
|
|
318 iAlign6.setFromString("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
319 iAlign7 = Align()
|
|
320 iAlign7.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
321 iAlign8 = Align()
|
|
322 iAlign8.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
323 iAlign9 = Align()
|
|
324 iAlign9.setFromString("chr4\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
325 lAlign = [ iAlign1, iAlign2, iAlign3, iAlign4, iAlign5, iAlign6, iAlign7, iAlign8, iAlign9 ]
|
|
326
|
|
327 obsLAlign = AlignUtils.splitAlignListByQueryName( lAlign )
|
|
328
|
|
329 expLAlign = [ [ iAlign1, iAlign3, iAlign6, iAlign7 ],
|
|
330 [ iAlign2, iAlign5, iAlign8 ],
|
|
331 [ iAlign4 ],
|
|
332 [ iAlign9 ] ]
|
|
333
|
|
334 self.assertEquals( expLAlign, obsLAlign )
|
|
335
|
|
336
|
|
337 def test_createAlignFiles( self ):
|
|
338 expFile1 = "dummyExpAlignFile.align_1"
|
|
339 expFile2 = "dummyExpAlignFile.align_2"
|
|
340 expFile3 = "dummyExpAlignFile.align_3"
|
|
341 expFile4 = "dummyExpAlignFile.align_4"
|
|
342
|
|
343 f1 = open(expFile1, "w")
|
|
344 iAlign1 = Align()
|
|
345 iAlign1.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
346 iAlign1.write(f1)
|
|
347 iAlign3 = Align()
|
|
348 iAlign3.setFromString("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
349 iAlign3.write(f1)
|
|
350 iAlign6 = Align()
|
|
351 iAlign6.setFromString("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
352 iAlign6.write(f1)
|
|
353 iAlign7 = Align()
|
|
354 iAlign7.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
355 iAlign7.write(f1)
|
|
356 f1.close()
|
|
357
|
|
358 f2 = open(expFile2, "w")
|
|
359 iAlign2 = Align()
|
|
360 iAlign2.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
361 iAlign2.write(f2)
|
|
362 iAlign5 = Align()
|
|
363 iAlign5.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
364 iAlign5.write(f2)
|
|
365 iAlign8 = Align()
|
|
366 iAlign8.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
367 iAlign8.write(f2)
|
|
368 f2.close()
|
|
369
|
|
370 f3 = open(expFile3, "w")
|
|
371 iAlign4 = Align()
|
|
372 iAlign4.setFromString("chr3\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
373 iAlign4.write(f3)
|
|
374 f3.close()
|
|
375
|
|
376 f4 = open(expFile4, "w")
|
|
377 iAlign9 = Align()
|
|
378 iAlign9.setFromString("chr4\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
379 iAlign9.write(f4)
|
|
380 f4.close()
|
|
381
|
|
382 lAlignList = [ [ iAlign1, iAlign3, iAlign6, iAlign7 ],
|
|
383 [ iAlign2, iAlign5, iAlign8 ],
|
|
384 [ iAlign4 ],
|
|
385 [ iAlign9 ] ]
|
|
386
|
|
387 AlignUtils.createAlignFiles( lAlignList, "dummyAlignFile" )
|
|
388
|
|
389 obsFile1 = "dummyAlignFile_1.align"
|
|
390 obsFile2 = "dummyAlignFile_2.align"
|
|
391 obsFile3 = "dummyAlignFile_3.align"
|
|
392 obsFile4 = "dummyAlignFile_4.align"
|
|
393
|
|
394 self.assertTrue( FileUtils.are2FilesIdentical( expFile1, obsFile1 ) )
|
|
395 self.assertTrue( FileUtils.are2FilesIdentical( expFile2, obsFile2 ) )
|
|
396 self.assertTrue( FileUtils.are2FilesIdentical( expFile3, obsFile3 ) )
|
|
397 self.assertTrue( FileUtils.are2FilesIdentical( expFile4, obsFile4 ) )
|
|
398
|
|
399 os.remove(expFile1)
|
|
400 os.remove(expFile2)
|
|
401 os.remove(expFile3)
|
|
402 os.remove(expFile4)
|
|
403 os.remove(obsFile1)
|
|
404 os.remove(obsFile2)
|
|
405 os.remove(obsFile3)
|
|
406 os.remove(obsFile4)
|
|
407
|
|
408
|
|
409 def test_createAlignFiles_eleven_output_files( self ):
|
|
410 expFile1 = "dummyExpAlignFile.align_01"
|
|
411 expFile2 = "dummyExpAlignFile.align_02"
|
|
412 expFile3 = "dummyExpAlignFile.align_03"
|
|
413 expFile4 = "dummyExpAlignFile.align_04"
|
|
414 expFile5 = "dummyExpAlignFile.align_05"
|
|
415 expFile6 = "dummyExpAlignFile.align_06"
|
|
416 expFile7 = "dummyExpAlignFile.align_07"
|
|
417 expFile8 = "dummyExpAlignFile.align_08"
|
|
418 expFile9 = "dummyExpAlignFile.align_09"
|
|
419 expFile10 = "dummyExpAlignFile.align_10"
|
|
420 expFile11 = "dummyExpAlignFile.align_11"
|
|
421 lExpFiles = [expFile1, expFile2, expFile3, expFile4, expFile5, expFile6, expFile7, expFile8, expFile9, expFile10, expFile11]
|
|
422
|
|
423 f1 = open(expFile1, "w")
|
|
424 iAlign1 = Align()
|
|
425 iAlign1.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
426 iAlign1.write(f1)
|
|
427 f1.close()
|
|
428
|
|
429 f2 = open(expFile2, "w")
|
|
430 iAlign2 = Align()
|
|
431 iAlign2.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
432 iAlign2.write(f2)
|
|
433 f2.close()
|
|
434
|
|
435 f3 = open(expFile3, "w")
|
|
436 iAlign3 = Align()
|
|
437 iAlign3.setFromString("chr3\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
438 iAlign3.write(f3)
|
|
439 f3.close()
|
|
440
|
|
441 f4 = open(expFile4, "w")
|
|
442 iAlign4 = Align()
|
|
443 iAlign4.setFromString("chr4\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
444 iAlign4.write(f4)
|
|
445 f4.close()
|
|
446
|
|
447 f = open(expFile5, "w")
|
|
448 iAlign5 = Align()
|
|
449 iAlign5.setFromString("chr5\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
450 iAlign5.write(f)
|
|
451 f.close()
|
|
452
|
|
453 f = open(expFile6, "w")
|
|
454 iAlign6 = Align()
|
|
455 iAlign6.setFromString("chr6\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
456 iAlign6.write(f)
|
|
457 f.close()
|
|
458
|
|
459 f = open(expFile7, "w")
|
|
460 iAlign7 = Align()
|
|
461 iAlign7.setFromString("chr7\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
462 iAlign7.write(f)
|
|
463 f.close()
|
|
464
|
|
465 f = open(expFile8, "w")
|
|
466 iAlign8 = Align()
|
|
467 iAlign8.setFromString("chr8\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
468 iAlign8.write(f)
|
|
469 f.close()
|
|
470
|
|
471 f = open(expFile9, "w")
|
|
472 iAlign9 = Align()
|
|
473 iAlign9.setFromString("chr9\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
474 iAlign9.write(f)
|
|
475 f.close()
|
|
476
|
|
477 f = open(expFile10, "w")
|
|
478 iAlign10 = Align()
|
|
479 iAlign10.setFromString("chr10\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
480 iAlign10.write(f)
|
|
481 f.close()
|
|
482
|
|
483 f = open(expFile11, "w")
|
|
484 iAlign11 = Align()
|
|
485 iAlign11.setFromString("chr11\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
486 iAlign11.write(f)
|
|
487 f.close()
|
|
488
|
|
489 lAlignList = [[iAlign1], [iAlign2], [iAlign3], [iAlign4], [iAlign5], [iAlign6], [iAlign7], [iAlign8], [iAlign9], [iAlign10], [iAlign11]]
|
|
490
|
|
491 AlignUtils.createAlignFiles(lAlignList, "dummyAlignFile")
|
|
492
|
|
493 obsFile1 = "dummyAlignFile_01.align"
|
|
494 obsFile2 = "dummyAlignFile_02.align"
|
|
495 obsFile3 = "dummyAlignFile_03.align"
|
|
496 obsFile4 = "dummyAlignFile_04.align"
|
|
497 obsFile5 = "dummyAlignFile_05.align"
|
|
498 obsFile6 = "dummyAlignFile_06.align"
|
|
499 obsFile7 = "dummyAlignFile_07.align"
|
|
500 obsFile8 = "dummyAlignFile_08.align"
|
|
501 obsFile9 = "dummyAlignFile_09.align"
|
|
502 obsFile10 = "dummyAlignFile_10.align"
|
|
503 obsFile11 = "dummyAlignFile_11.align"
|
|
504 lObsFiles = [obsFile1, obsFile2, obsFile3, obsFile4, obsFile5, obsFile6, obsFile7, obsFile8, obsFile9, obsFile10, obsFile11]
|
|
505
|
|
506 self.assertTrue( FileUtils.are2FilesIdentical( expFile1, obsFile1 ) )
|
|
507 self.assertTrue( FileUtils.are2FilesIdentical( expFile2, obsFile2 ) )
|
|
508 self.assertTrue( FileUtils.are2FilesIdentical( expFile3, obsFile3 ) )
|
|
509 self.assertTrue( FileUtils.are2FilesIdentical( expFile4, obsFile4 ) )
|
|
510 self.assertTrue( FileUtils.are2FilesIdentical( expFile5, obsFile5 ) )
|
|
511 self.assertTrue( FileUtils.are2FilesIdentical( expFile6, obsFile6 ) )
|
|
512 self.assertTrue( FileUtils.are2FilesIdentical( expFile7, obsFile7 ) )
|
|
513 self.assertTrue( FileUtils.are2FilesIdentical( expFile8, obsFile8 ) )
|
|
514 self.assertTrue( FileUtils.are2FilesIdentical( expFile9, obsFile9 ) )
|
|
515 self.assertTrue( FileUtils.are2FilesIdentical( expFile10, obsFile10 ) )
|
|
516 self.assertTrue( FileUtils.are2FilesIdentical( expFile11, obsFile11 ) )
|
|
517
|
|
518 for file in lExpFiles:
|
|
519 os.remove(file)
|
|
520 for file in lObsFiles:
|
|
521 os.remove(file)
|
|
522
|
|
523
|
|
524 def test_createAlignFiles_dirName_specified( self ):
|
|
525 expFile1 = "dummyExpAlignFile.align_1"
|
|
526 expFile2 = "dummyExpAlignFile.align_2"
|
|
527 expFile3 = "dummyExpAlignFile.align_3"
|
|
528 expFile4 = "dummyExpAlignFile.align_4"
|
|
529
|
|
530 f1 = open(expFile1, "w")
|
|
531 iAlign1 = Align()
|
|
532 iAlign1.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
533 iAlign1.write(f1)
|
|
534 iAlign3 = Align()
|
|
535 iAlign3.setFromString("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
536 iAlign3.write(f1)
|
|
537 iAlign6 = Align()
|
|
538 iAlign6.setFromString("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
539 iAlign6.write(f1)
|
|
540 iAlign7 = Align()
|
|
541 iAlign7.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
542 iAlign7.write(f1)
|
|
543 f1.close()
|
|
544
|
|
545 f2 = open(expFile2, "w")
|
|
546 iAlign2 = Align()
|
|
547 iAlign2.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
548 iAlign2.write(f2)
|
|
549 iAlign5 = Align()
|
|
550 iAlign5.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
551 iAlign5.write(f2)
|
|
552 iAlign8 = Align()
|
|
553 iAlign8.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
554 iAlign8.write(f2)
|
|
555 f2.close()
|
|
556
|
|
557 f3 = open(expFile3, "w")
|
|
558 iAlign4 = Align()
|
|
559 iAlign4.setFromString("chr3\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
560 iAlign4.write(f3)
|
|
561 f3.close()
|
|
562
|
|
563 f4 = open(expFile4, "w")
|
|
564 iAlign9 = Align()
|
|
565 iAlign9.setFromString("chr4\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
566 iAlign9.write(f4)
|
|
567 f4.close()
|
|
568
|
|
569 lAlignList = [[iAlign1, iAlign3, iAlign6, iAlign7], [iAlign2, iAlign5, iAlign8], [iAlign4], [iAlign9]]
|
|
570
|
|
571 dirName = "dummyAlignDir"
|
|
572
|
|
573 AlignUtils.createAlignFiles(lAlignList, "dummyAlignFile", dirName)
|
|
574
|
|
575 obsFile1 = dirName + "/dummyAlignFile_1.align"
|
|
576 obsFile2 = dirName + "/dummyAlignFile_2.align"
|
|
577 obsFile3 = dirName + "/dummyAlignFile_3.align"
|
|
578 obsFile4 = dirName + "/dummyAlignFile_4.align"
|
|
579
|
|
580 self.assertTrue( FileUtils.are2FilesIdentical( expFile1, obsFile1 ) )
|
|
581 self.assertTrue( FileUtils.are2FilesIdentical( expFile2, obsFile2 ) )
|
|
582 self.assertTrue( FileUtils.are2FilesIdentical( expFile3, obsFile3 ) )
|
|
583 self.assertTrue( FileUtils.are2FilesIdentical( expFile4, obsFile4 ) )
|
|
584
|
|
585 os.remove(expFile1)
|
|
586 os.remove(expFile2)
|
|
587 os.remove(expFile3)
|
|
588 os.remove(expFile4)
|
|
589 shutil.rmtree (dirName)
|
|
590
|
|
591
|
|
592 def test_createAlignFiles_dirName_specified_with_ended_slash( self ):
|
|
593 expFile1 = "dummyExpAlignFile.align_1"
|
|
594 expFile2 = "dummyExpAlignFile.align_2"
|
|
595 expFile3 = "dummyExpAlignFile.align_3"
|
|
596 expFile4 = "dummyExpAlignFile.align_4"
|
|
597
|
|
598 f1 = open(expFile1, "w")
|
|
599 iAlign1 = Align()
|
|
600 iAlign1.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
601 iAlign1.write(f1)
|
|
602 iAlign3 = Align()
|
|
603 iAlign3.setFromString("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
604 iAlign3.write(f1)
|
|
605 iAlign6 = Align()
|
|
606 iAlign6.setFromString("chr1\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
607 iAlign6.write(f1)
|
|
608 iAlign7 = Align()
|
|
609 iAlign7.setFromString("chr1\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
610 iAlign7.write(f1)
|
|
611 f1.close()
|
|
612
|
|
613 f2 = open(expFile2, "w")
|
|
614 iAlign2 = Align()
|
|
615 iAlign2.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
616 iAlign2.write(f2)
|
|
617 iAlign5 = Align()
|
|
618 iAlign5.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
619 iAlign5.write(f2)
|
|
620 iAlign8 = Align()
|
|
621 iAlign8.setFromString("chr2\t200\t220\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
622 iAlign8.write(f2)
|
|
623 f2.close()
|
|
624
|
|
625 f3 = open(expFile3, "w")
|
|
626 iAlign4 = Align()
|
|
627 iAlign4.setFromString("chr3\t100\t110\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
628 iAlign4.write(f3)
|
|
629 f3.close()
|
|
630
|
|
631 f4 = open(expFile4, "w")
|
|
632 iAlign9 = Align()
|
|
633 iAlign9.setFromString("chr4\t300\t330\tTE2\t150\t200\t1e-20\t30\t90.2\n")
|
|
634 iAlign9.write(f4)
|
|
635 f4.close()
|
|
636
|
|
637 lAlignList = [[iAlign1, iAlign3, iAlign6, iAlign7], [iAlign2, iAlign5, iAlign8], [iAlign4], [iAlign9]]
|
|
638
|
|
639 dirName = "dummyAlignDir/"
|
|
640
|
|
641 AlignUtils.createAlignFiles(lAlignList, "dummyAlignFile", dirName)
|
|
642
|
|
643 obsFile1 = dirName + "dummyAlignFile_1.align"
|
|
644 obsFile2 = dirName + "dummyAlignFile_2.align"
|
|
645 obsFile3 = dirName + "dummyAlignFile_3.align"
|
|
646 obsFile4 = dirName + "dummyAlignFile_4.align"
|
|
647
|
|
648 self.assertTrue( FileUtils.are2FilesIdentical( expFile1, obsFile1 ) )
|
|
649 self.assertTrue( FileUtils.are2FilesIdentical( expFile2, obsFile2 ) )
|
|
650 self.assertTrue( FileUtils.are2FilesIdentical( expFile3, obsFile3 ) )
|
|
651 self.assertTrue( FileUtils.are2FilesIdentical( expFile4, obsFile4 ) )
|
|
652
|
|
653 os.remove(expFile1)
|
|
654 os.remove(expFile2)
|
|
655 os.remove(expFile3)
|
|
656 os.remove(expFile4)
|
|
657 shutil.rmtree (dirName)
|
|
658
|
|
659
|
|
660 def test_sortList( self ):
|
|
661 iAlign1 = Align( Range("qry1",3,80), Range("sbj1",3,80), 1e-20, 103, 97.3 ) # higher query start
|
|
662 iAlign2 = Align( Range("qry1",1,100), Range("sbj1",1,100), 1e-20, 113, 97.3 ) # higher score
|
|
663 iAlign3 = Align( Range("qry2",1,100), Range("sbj1",1,100), 1e-20, 103, 97.3 ) # different query
|
|
664 iAlign4 = Align( Range("qry1",1,100), Range("sbj1",1,100), 1e-20, 103, 97.3 ) # canonical
|
|
665 iAlign5 = Align( Range("qry1",1,100), Range("sbj2",1,100), 1e-20, 103, 97.3 ) # different subject
|
|
666 iAlign6 = Align( Range("qry1",201,300), Range("sbj1",100,1), 1e-20, 103, 97.3 ) # subject on reverse strand
|
|
667 iAlign7 = Align( Range("qry1",401,500), Range("sbj1",1,100), 1e-20, 103, 97.3 ) # higher query start
|
|
668 lAligns = [ iAlign1, iAlign2, iAlign3, iAlign4, iAlign5, iAlign6, iAlign7 ]
|
|
669 lExp = [iAlign4, iAlign2, iAlign1, iAlign6, iAlign7, iAlign5, iAlign3]
|
|
670 lObs = AlignUtils.sortList( lAligns )
|
|
671 self.assertEquals( lExp, lObs )
|
|
672
|
|
673
|
|
674 def test_isOverlapping( self ):
|
|
675 iAlign1 = Align( Range("chr1",1,100), Range("TE1",11,110), 1e-20, 90.2, 30 )
|
|
676 iAlign2 = Align( Range("chr1",51,80), Range("TE1",61,90), 1e-20, 90.2, 30 )
|
|
677 self.assertTrue( iAlign1.isOverlapping( iAlign2 ) )
|
|
678
|
|
679 iAlign1 = Align( Range("chr1",1,100), Range("TE1",11,110), 1e-20, 90.2, 30 )
|
|
680 iAlign2 = Align( Range("chr1",51,80), Range("TE1",161,190), 1e-20, 90.2, 30 )
|
|
681 self.assertFalse( iAlign1.isOverlapping( iAlign2 ) )
|
|
682
|
|
683
|
|
684 def test_mergeList( self ):
|
|
685 iAlign1 = Align( Range("chr1",81,120), Range("TE1",91,130), 1e-20, 90.2, 30 )
|
|
686 iAlign2 = Align( Range("chr2",51,80), Range("TE1",61,90), 1e-20, 90.2, 30 ) # different query
|
|
687 iAlign3 = Align( Range("chr1",1,100), Range("TE1",11,110), 1e-20, 90.2, 30 ) # to be merged with 1st line
|
|
688 iAlign4 = Align( Range("chr1",1,200), Range("TE2",11,210), 1e-20, 90.2, 30 ) # different subject
|
|
689 iAlign5 = Align( Range("chr1",1,100), Range("TE1",501,600), 1e-20, 90.2, 30 ) # non-overlapping subject
|
|
690 lAligns = [ iAlign1, iAlign2, iAlign3, iAlign4, iAlign5 ]
|
|
691
|
|
692 iAlign6 = Align( Range("chr1",1,120), Range("TE1",11,130), 1e-20, 90.2, 30 )
|
|
693 lExp = [ iAlign6, iAlign5, iAlign4, iAlign2 ]
|
|
694
|
|
695 lObs = AlignUtils.mergeList( lAligns )
|
|
696
|
|
697 self.assertEquals( lExp, lObs )
|
|
698
|
|
699
|
|
700 def test_mergeFile_empty( self ):
|
|
701 inFile = "dummyInFile.align"
|
|
702 inF = open( inFile, "w" )
|
|
703 inF.close()
|
|
704
|
|
705 expFile = "dummyExpFile.align"
|
|
706 expF = open( expFile, "w" )
|
|
707 expF.close()
|
|
708
|
|
709 obsFile = "dummyObsFile.align"
|
|
710 AlignUtils.mergeFile( inFile, obsFile )
|
|
711
|
|
712 self.assertTrue( FileUtils.are2FilesIdentical( expFile, obsFile ) )
|
|
713
|
|
714 for f in [ inFile, expFile, obsFile ]:
|
|
715 os.remove( f )
|
|
716
|
|
717
|
|
718 def test_mergeFile( self ):
|
|
719 iAlign = Align()
|
|
720
|
|
721 inFile = "dummyInFile.align"
|
|
722 inF = open( inFile, "w" )
|
|
723 iAlign.setFromString( "chr1\t81\t120\tTE1\t91\t130\t1e-20\t30\t90.2\n" )
|
|
724 iAlign.write( inF )
|
|
725 iAlign.setFromString( "chr2\t51\t80\tTE1\t61\t90\t1e-20\t30\t90.2\n" ) # different query
|
|
726 iAlign.write( inF )
|
|
727 iAlign.setFromString( "chr1\t1\t100\tTE1\t11\t110\t1e-20\t30\t90.2\n" ) # to be merged with 1st line
|
|
728 iAlign.write( inF )
|
|
729 iAlign.setFromString( "chr1\t1\t200\tTE2\t11\t210\t1e-20\t30\t90.2\n" ) # different subject
|
|
730 iAlign.write( inF )
|
|
731 inF.close()
|
|
732
|
|
733 expFile = "dummyExpFile.align"
|
|
734 expF = open( expFile, "w" )
|
|
735 iAlign.setFromString( "chr1\t1\t120\tTE1\t11\t130\t1e-20\t30\t90.2\n" )
|
|
736 iAlign.write( expF )
|
|
737 iAlign.setFromString( "chr1\t1\t200\tTE2\t11\t210\t1e-20\t30\t90.2\n" )
|
|
738 iAlign.write( expF )
|
|
739 iAlign.setFromString( "chr2\t51\t80\tTE1\t61\t90\t1e-20\t30\t90.2\n" )
|
|
740 iAlign.write( expF )
|
|
741 expF.close()
|
|
742
|
|
743 obsFile = "dummyObsFile.align"
|
|
744 AlignUtils.mergeFile( inFile, obsFile )
|
|
745
|
|
746 self.assertTrue( FileUtils.are2FilesIdentical( expFile, obsFile ) )
|
|
747
|
|
748 for f in [ inFile, expFile, obsFile ]:
|
|
749 os.remove( f )
|
|
750
|
|
751
|
|
752 def test_updateScoresInFile( self ):
|
|
753 iAlign = Align()
|
|
754
|
|
755 inFile = "dummyInFile.align"
|
|
756 inHandler = open( inFile, "w" )
|
|
757 iAlign.setFromString( "query1\t1\t100\tsubject1\t1\t95\t1e-180\t230\t90.2\n" )
|
|
758 iAlign.write( inHandler )
|
|
759 inHandler.close()
|
|
760
|
|
761 expFile = "dummyExpFile.align"
|
|
762 expHandler = open( expFile, "w" )
|
|
763 iAlign.setFromString( "query1\t1\t100\tsubject1\t1\t95\t1e-180\t%i\t90.2\n" % ( ( 100 - 1 + 1 ) * 90.2 / 100.0 ) )
|
|
764 iAlign.write( expHandler )
|
|
765 expHandler.close()
|
|
766
|
|
767 obsFile = "dummyObsFile.align"
|
|
768 AlignUtils.updateScoresInFile( inFile, obsFile )
|
|
769
|
|
770 self.assertTrue( FileUtils.are2FilesIdentical( expFile, obsFile ) )
|
|
771
|
|
772 for f in [ inFile, expFile, obsFile ]:
|
|
773 os.remove( f )
|
|
774
|
|
775
|
|
776 if __name__ == "__main__":
|
|
777 unittest.main() |