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 from commons.core.coord.Set import Set
|
|
35 from commons.core.coord.Map import Map
|
|
36
|
|
37
|
|
38 class Test_Set( unittest.TestCase ):
|
|
39
|
|
40 def test__eq__sets_equals(self):
|
|
41 set1 = Set( 1, "set1", "seq1", 1, 2 )
|
|
42 set2 = Set( 1, "set1", "seq1", 1 ,2 )
|
|
43 self.assertEquals( set1, set2 )
|
|
44
|
|
45 def test__eq__sets_not_equals_ids(self):
|
|
46 set1 = Set( 1, "set1", "seq1", 1, 2 )
|
|
47 set2 = Set( 2, "set1", "seq1", 1 ,2 )
|
|
48 self.assertNotEquals( set1, set2 )
|
|
49
|
|
50 def test__eq__sets_not_equals_name(self):
|
|
51 set1 = Set( 1, "set1", "seq1", 1, 2 )
|
|
52 set2 = Set( 1, "set2", "seq1", 1 ,2 )
|
|
53 self.assertNotEquals( set1, set2 )
|
|
54
|
|
55 def test__eq__on_empty_set(self):
|
|
56 set1 = Set()
|
|
57 set2 = Set()
|
|
58 self.assertEquals( set1, set2 )
|
|
59
|
|
60 def test_setFromTuple_equals_instances(self):
|
|
61 tuple = ( 1, "set1", "seq1", 1, 2 )
|
|
62 obsSet = Set()
|
|
63 obsSet.setFromTuple(tuple)
|
|
64 expSet = Set( 1, "set1", "seq1", 1, 2 )
|
|
65 self.assertEquals( expSet, obsSet )
|
|
66
|
|
67 def test_setFromTuple_not_equals_instances(self):
|
|
68 tuple = ( 1, "set1", "seq1", 1, 2 )
|
|
69 obsSet = Set()
|
|
70 obsSet.setFromTuple(tuple)
|
|
71 expSet = Set( 2, "set1", "seq1", 1, 2 )
|
|
72 self.assertNotEquals( expSet, obsSet )
|
|
73
|
|
74 def test_read_empty_line_file(self):
|
|
75 fileName = "dummyFile"
|
|
76
|
|
77 os.system(" touch " + fileName)
|
|
78
|
|
79 fileHandler = open(fileName, "r")
|
|
80
|
|
81 obsSet = Set()
|
|
82
|
|
83 obsRes = obsSet.read( fileHandler )
|
|
84 expRes = 0
|
|
85
|
|
86 fileHandler.close()
|
|
87 os.remove(fileName)
|
|
88
|
|
89 self.assertEquals( expRes, obsRes )
|
|
90
|
|
91 def test_read_one_line_file(self):
|
|
92 line = ( "1\tset1\tseq1\t1\t2" )
|
|
93 fileName = "dummyFile"
|
|
94
|
|
95 fileHandler = open( fileName, "w" )
|
|
96 fileHandler.write( line )
|
|
97 fileHandler.close()
|
|
98
|
|
99 fileHandler = open( fileName, "r" )
|
|
100
|
|
101 tuple = line.split("\t")
|
|
102 expSet = Set()
|
|
103 expSet.setFromTuple(tuple)
|
|
104
|
|
105 obsSet = Set()
|
|
106
|
|
107 expRes = 1
|
|
108 obsRes = obsSet.read(fileHandler)
|
|
109
|
|
110 fileHandler.close()
|
|
111 os.remove(fileName)
|
|
112 self.assertEquals( expRes, obsRes )
|
|
113 self.assertEquals( expSet, obsSet )
|
|
114
|
|
115 def test_read_two_line_file(self):
|
|
116 line1 = ( "1\tset1\tseq1\t1\t2\n" )
|
|
117 line2 = ( "2\tset2\tseq2\t3\t4" )
|
|
118 fileName = "dummyFile"
|
|
119
|
|
120 fileHandler = open( fileName, "w" )
|
|
121 fileHandler.write( line1 )
|
|
122 fileHandler.write( line2 )
|
|
123 fileHandler.close()
|
|
124
|
|
125 tuple1 = line1.split("\t")
|
|
126 tuple2 = line2.split("\t")
|
|
127
|
|
128 expSet1 = Set()
|
|
129 expSet2 = Set()
|
|
130
|
|
131 expSet1.setFromTuple(tuple1)
|
|
132 expSet2.setFromTuple(tuple2)
|
|
133
|
|
134 expSetList = [ expSet1, expSet2 ]
|
|
135 expResList = [ 1, 1 ]
|
|
136
|
|
137 fileHandler = open( fileName, "r" )
|
|
138
|
|
139 obsSet1 = Set()
|
|
140 obsSet2 = Set()
|
|
141
|
|
142 obsRes1 = obsSet1.read(fileHandler)
|
|
143 obsRes2 = obsSet2.read(fileHandler)
|
|
144
|
|
145 obsSetList= [ obsSet1, obsSet2 ]
|
|
146 obsResList = [ obsRes1, obsRes2 ]
|
|
147
|
|
148 fileHandler.close()
|
|
149 os.remove(fileName)
|
|
150
|
|
151 self.assertEquals( expSetList, obsSetList )
|
|
152 self.assertEquals( expResList, obsResList )
|
|
153
|
|
154 def test_merge_first_id_greater_than_second_id(self):
|
|
155 firstSet = Set( 2, "set1", "seq1", 10, 40 )
|
|
156 secondSet = Set( 1, "set2", "seq1", 20, 60 )
|
|
157
|
|
158 firstSet.merge( secondSet )
|
|
159
|
|
160 expSet = Set( 1, "set1", "seq1", 10, 60)
|
|
161 obsSet = firstSet
|
|
162
|
|
163 self.assertEquals( expSet, obsSet)
|
|
164
|
|
165 def test_merge_first_id_smaller_than_second_id(self):
|
|
166 firstSet = Set( 1, "set1", "seq1", 10, 40 )
|
|
167 secondSet = Set( 2, "set2", "seq1", 20, 60 )
|
|
168
|
|
169 firstSet.merge( secondSet )
|
|
170
|
|
171 expSet = Set( 1, "set1", "seq1", 10, 60)
|
|
172 obsSet = firstSet
|
|
173
|
|
174 self.assertEquals( expSet, obsSet)
|
|
175
|
|
176 def test_merge_first_id_equals_second_id(self):
|
|
177 firstSet = Set( 1, "set1", "seq1", 10, 40 )
|
|
178 secondSet = Set( 1, "set2", "seq1", 20, 60 )
|
|
179
|
|
180 firstSet.merge( secondSet )
|
|
181
|
|
182 expSet = Set( 1, "set1", "seq1", 10, 60)
|
|
183 obsSet = firstSet
|
|
184
|
|
185 self.assertEquals( expSet, obsSet)
|
|
186
|
|
187 def test_merge_different_seqnames(self):
|
|
188 firstSet = Set( 2, "set1", "seq1", 10, 40 )
|
|
189 secondSet = Set( 1, "set1", "seq2", 20, 60 )
|
|
190 expSet = Set( 2, "set1", "seq1", 10, 40 )
|
|
191 firstSet.merge( secondSet )
|
|
192 obsSet = firstSet
|
|
193 self.assertEquals( expSet, obsSet )
|
|
194
|
|
195 def test_diff_on_empty_sets(self):
|
|
196 firstSet = Set()
|
|
197 firstSet.seqname = "seq1"
|
|
198 secondSet = Set()
|
|
199 secondSet.seqname = "seq2"
|
|
200
|
|
201 obsSet = firstSet.diff( secondSet )
|
|
202 expSet = Set()
|
|
203
|
|
204 self.assertEquals( expSet, obsSet )
|
|
205
|
|
206 def test_diff(self):
|
|
207 firstSet = Set( 2, "set1", "seq1", 10, 80 )
|
|
208 secondSet = Set( 1, "set2", "seq1", 20, 60 )
|
|
209
|
|
210 expSet1 = Set( 2, "set1", "seq1", 10, 19 )
|
|
211 expSet2 = Set( 2, "set1", "seq1", 61, 80 )
|
|
212
|
|
213 obsSet2 = firstSet.diff( secondSet )
|
|
214 obsSet1 = firstSet
|
|
215
|
|
216 self.assertEquals( expSet1, obsSet1 )
|
|
217 self.assertEquals( expSet2, obsSet2 )
|
|
218
|
|
219 def test_diff_reverse(self):
|
|
220 firstSet = Set( 2, "set1", "seq1", 20, 60 )
|
|
221 secondSet = Set( 1, "set2", "seq1", 10, 80 )
|
|
222
|
|
223 expSet1 = Set( 2, "set1", "seq1", 0, 0 )
|
|
224 expSet2 = Set( )
|
|
225
|
|
226 obsSet2 = firstSet.diff( secondSet )
|
|
227 obsSet1 = firstSet
|
|
228
|
|
229 self.assertEquals( expSet1, obsSet1 )
|
|
230 self.assertEquals( expSet2, obsSet2 )
|
|
231
|
|
232 def test_diff_list1_overlap_end_list2(self):
|
|
233 firstSet = Set( 2, "set1", "seq1", 20, 100 )
|
|
234 secondSet = Set( 1, "set2", "seq1", 10, 80 )
|
|
235
|
|
236 expSet1 = Set( 2, "set1", "seq1", 81, 100 )
|
|
237 expSet2 = Set( )
|
|
238
|
|
239 obsSet2 = firstSet.diff( secondSet )
|
|
240 obsSet1 = firstSet
|
|
241
|
|
242 self.assertEquals( expSet1, obsSet1 )
|
|
243 self.assertEquals( expSet2, obsSet2 )
|
|
244
|
|
245 def test_diff_with_empty_set1(self):
|
|
246 set2 = Set( 1, "set1", "seq1", 2, 45 )
|
|
247 set1 = Set( )
|
|
248
|
|
249 expSet1 = Set( )
|
|
250 expSet2 = Set( )
|
|
251
|
|
252 obsSet2 = set1.diff( set2 )
|
|
253 obsSet1 = set1
|
|
254
|
|
255 self.assertEquals( expSet1, obsSet1 )
|
|
256 self.assertEquals( expSet2, obsSet2 )
|
|
257
|
|
258 def test_diff_list2_overlap_end_list1(self):
|
|
259 firstSet = Set( 2, "set1", "seq1", 10, 70 )
|
|
260 secondSet = Set( 1, "set2", "seq1", 40, 100 )
|
|
261
|
|
262 expSet1 = Set( 2, "set1", "seq1", 10, 39 )
|
|
263 expSet2 = Set( )
|
|
264
|
|
265 obsSet2 = firstSet.diff( secondSet )
|
|
266 obsSet1 = firstSet
|
|
267
|
|
268 self.assertEquals( expSet1, obsSet1 )
|
|
269 self.assertEquals( expSet2, obsSet2 )
|
|
270
|
|
271 def test_set2map(self):
|
|
272 set = Set( 1, "set", "seq", 1, 2 )
|
|
273
|
|
274 expMap = Map( "set::1", "seq", 1, 2 )
|
|
275 obsMap = set.set2map()
|
|
276
|
|
277 self.assertEquals( expMap, obsMap )
|
|
278
|
|
279 test_suite = unittest.TestSuite()
|
|
280 test_suite.addTest( unittest.makeSuite( Test_Set ) )
|
|
281 if __name__ == "__main__":
|
|
282 unittest.TextTestRunner(verbosity=2).run( test_suite )
|