1 |
|
package jalview.datamodel.features; |
2 |
|
|
3 |
|
import static org.testng.Assert.assertEquals; |
4 |
|
import static org.testng.Assert.assertFalse; |
5 |
|
import static org.testng.Assert.assertSame; |
6 |
|
import static org.testng.Assert.assertTrue; |
7 |
|
|
8 |
|
import jalview.datamodel.SequenceFeature; |
9 |
|
|
10 |
|
import java.util.ArrayList; |
11 |
|
import java.util.Iterator; |
12 |
|
import java.util.List; |
13 |
|
import java.util.Map; |
14 |
|
import java.util.Set; |
15 |
|
|
16 |
|
import junit.extensions.PA; |
17 |
|
|
18 |
|
import org.testng.annotations.Test; |
19 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (704) |
Complexity: 22 |
Complexity Density: 0.03 |
|
20 |
|
public class SequenceFeaturesTest |
21 |
|
{ |
|
|
| 100% |
Uncovered Elements: 0 (20) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
22 |
1 |
@Test(groups = "Functional")... |
23 |
|
public void testConstructor() |
24 |
|
{ |
25 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
26 |
1 |
assertFalse(store.hasFeatures()); |
27 |
|
|
28 |
1 |
store = new SequenceFeatures((List<SequenceFeature>) null); |
29 |
1 |
assertFalse(store.hasFeatures()); |
30 |
|
|
31 |
1 |
List<SequenceFeature> features = new ArrayList<>(); |
32 |
1 |
store = new SequenceFeatures(features); |
33 |
1 |
assertFalse(store.hasFeatures()); |
34 |
|
|
35 |
1 |
SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, |
36 |
|
Float.NaN, null); |
37 |
1 |
features.add(sf1); |
38 |
1 |
SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 15, 18, |
39 |
|
Float.NaN, null); |
40 |
1 |
features.add(sf2); |
41 |
1 |
SequenceFeature sf3 = new SequenceFeature("Pfam", "desc2", 0, 0, |
42 |
|
Float.NaN, null); |
43 |
1 |
features.add(sf3); |
44 |
1 |
store = new SequenceFeatures(features); |
45 |
1 |
assertTrue(store.hasFeatures()); |
46 |
1 |
assertEquals(2, store.getFeatureCount(true)); |
47 |
1 |
assertEquals(1, store.getFeatureCount(false)); |
48 |
1 |
assertFalse(store.add(sf1)); |
49 |
1 |
assertFalse(store.add(sf2)); |
50 |
1 |
assertFalse(store.add(sf3)); |
51 |
|
} |
52 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (48) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
53 |
1 |
@Test(groups = "Functional")... |
54 |
|
public void testGetPositionalFeatures() |
55 |
|
{ |
56 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
57 |
1 |
SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, |
58 |
|
Float.NaN, null); |
59 |
1 |
store.add(sf1); |
60 |
|
|
61 |
1 |
SequenceFeature sf2 = new SequenceFeature("Metal", "desc2", 10, 20, |
62 |
|
Float.NaN, null); |
63 |
1 |
store.add(sf2); |
64 |
|
|
65 |
1 |
SequenceFeature sf3 = new SequenceFeature("Metal", "desc", 30, 40, |
66 |
|
Float.NaN, null); |
67 |
1 |
store.add(sf3); |
68 |
|
|
69 |
1 |
SequenceFeature sf4 = new SequenceFeature("Metal", "desc", 15, 35, |
70 |
|
Float.NaN, null); |
71 |
1 |
store.add(sf4); |
72 |
|
|
73 |
1 |
SequenceFeature sf5 = new SequenceFeature("Metal", "desc", 5, 50, |
74 |
|
Float.NaN, null); |
75 |
1 |
store.add(sf5); |
76 |
|
|
77 |
1 |
SequenceFeature sf6 = new SequenceFeature("Metal", "desc", 0, 0, |
78 |
|
Float.NaN, null); |
79 |
1 |
store.add(sf6); |
80 |
|
|
81 |
1 |
SequenceFeature sf7 = new SequenceFeature("Disulphide bond", "desc", |
82 |
|
18, 45, Float.NaN, null); |
83 |
1 |
store.add(sf7); |
84 |
|
|
85 |
1 |
SequenceFeature sf8 = new SequenceFeature("Pfam", "desc", 30, 40, |
86 |
|
Float.NaN, null); |
87 |
1 |
store.add(sf8); |
88 |
1 |
SequenceFeature sf9 = new SequenceFeature("Pfam", "desc", 15, 35, |
89 |
|
Float.NaN, null); |
90 |
1 |
store.add(sf9); |
91 |
|
|
92 |
|
|
93 |
|
|
94 |
|
|
95 |
1 |
List<SequenceFeature> features = store.getPositionalFeatures(); |
96 |
1 |
assertEquals(features.size(), 8); |
97 |
1 |
assertTrue(features.contains(sf1)); |
98 |
1 |
assertTrue(features.contains(sf2)); |
99 |
1 |
assertTrue(features.contains(sf3)); |
100 |
1 |
assertTrue(features.contains(sf4)); |
101 |
1 |
assertTrue(features.contains(sf5)); |
102 |
1 |
assertFalse(features.contains(sf6)); |
103 |
1 |
assertTrue(features.contains(sf7)); |
104 |
1 |
assertTrue(features.contains(sf8)); |
105 |
1 |
assertTrue(features.contains(sf9)); |
106 |
|
|
107 |
|
|
108 |
|
|
109 |
|
|
110 |
1 |
assertTrue(store.getPositionalFeatures((String) null).isEmpty()); |
111 |
1 |
assertTrue(store.getPositionalFeatures("Cath").isEmpty()); |
112 |
1 |
assertTrue(store.getPositionalFeatures("METAL").isEmpty()); |
113 |
|
|
114 |
1 |
features = store.getPositionalFeatures("Metal"); |
115 |
1 |
assertEquals(features.size(), 5); |
116 |
1 |
assertTrue(features.contains(sf1)); |
117 |
1 |
assertTrue(features.contains(sf2)); |
118 |
1 |
assertTrue(features.contains(sf3)); |
119 |
1 |
assertTrue(features.contains(sf4)); |
120 |
1 |
assertTrue(features.contains(sf5)); |
121 |
1 |
assertFalse(features.contains(sf6)); |
122 |
|
|
123 |
1 |
features = store.getPositionalFeatures("Disulphide bond"); |
124 |
1 |
assertEquals(features.size(), 1); |
125 |
1 |
assertTrue(features.contains(sf7)); |
126 |
|
|
127 |
1 |
features = store.getPositionalFeatures("Pfam"); |
128 |
1 |
assertEquals(features.size(), 2); |
129 |
1 |
assertTrue(features.contains(sf8)); |
130 |
1 |
assertTrue(features.contains(sf9)); |
131 |
|
} |
132 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (27) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
133 |
1 |
@Test(groups = "Functional")... |
134 |
|
public void testGetContactFeatures() |
135 |
|
{ |
136 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
137 |
|
|
138 |
1 |
SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, |
139 |
|
Float.NaN, null); |
140 |
1 |
store.add(sf1); |
141 |
|
|
142 |
1 |
SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 0, 0, |
143 |
|
Float.NaN, null); |
144 |
1 |
store.add(sf2); |
145 |
|
|
146 |
1 |
SequenceFeature sf3 = new SequenceFeature("Disulphide bond", "desc", |
147 |
|
18, 45, Float.NaN, null); |
148 |
1 |
store.add(sf3); |
149 |
|
|
150 |
1 |
SequenceFeature sf4 = new SequenceFeature("Pfam", "desc", 10, 20, |
151 |
|
Float.NaN, null); |
152 |
1 |
store.add(sf4); |
153 |
1 |
SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 0, 0, |
154 |
|
Float.NaN, null); |
155 |
1 |
store.add(sf5); |
156 |
1 |
SequenceFeature sf6 = new SequenceFeature("Disulfide bond", "desc", 18, |
157 |
|
45, Float.NaN, null); |
158 |
1 |
store.add(sf6); |
159 |
|
|
160 |
|
|
161 |
|
|
162 |
|
|
163 |
1 |
List<SequenceFeature> features = store.getContactFeatures(); |
164 |
1 |
assertEquals(features.size(), 2); |
165 |
1 |
assertTrue(features.contains(sf3)); |
166 |
1 |
assertTrue(features.contains(sf6)); |
167 |
|
|
168 |
|
|
169 |
|
|
170 |
|
|
171 |
1 |
assertTrue(store.getContactFeatures((String) null).isEmpty()); |
172 |
1 |
assertTrue(store.getContactFeatures("Cath").isEmpty()); |
173 |
1 |
assertTrue(store.getContactFeatures("Pfam").isEmpty()); |
174 |
1 |
assertTrue(store.getContactFeatures("DISULPHIDE BOND").isEmpty()); |
175 |
|
|
176 |
1 |
features = store.getContactFeatures("Disulphide bond"); |
177 |
1 |
assertEquals(features.size(), 1); |
178 |
1 |
assertTrue(features.contains(sf3)); |
179 |
|
|
180 |
1 |
features = store.getContactFeatures("Disulfide bond"); |
181 |
1 |
assertEquals(features.size(), 1); |
182 |
1 |
assertTrue(features.contains(sf6)); |
183 |
|
} |
184 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (30) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
185 |
1 |
@Test(groups = "Functional")... |
186 |
|
public void testGetNonPositionalFeatures() |
187 |
|
{ |
188 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
189 |
|
|
190 |
1 |
SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, |
191 |
|
Float.NaN, null); |
192 |
1 |
store.add(sf1); |
193 |
|
|
194 |
1 |
SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 0, 0, |
195 |
|
Float.NaN, null); |
196 |
1 |
store.add(sf2); |
197 |
|
|
198 |
1 |
SequenceFeature sf3 = new SequenceFeature("Disulphide bond", "desc", |
199 |
|
18, 45, Float.NaN, null); |
200 |
1 |
store.add(sf3); |
201 |
|
|
202 |
1 |
SequenceFeature sf4 = new SequenceFeature("Pfam", "desc", 10, 20, |
203 |
|
Float.NaN, null); |
204 |
1 |
store.add(sf4); |
205 |
1 |
SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 0, 0, |
206 |
|
Float.NaN, null); |
207 |
1 |
store.add(sf5); |
208 |
1 |
SequenceFeature sf6 = new SequenceFeature("Disulfide bond", "desc", 18, |
209 |
|
45, Float.NaN, null); |
210 |
1 |
store.add(sf6); |
211 |
|
|
212 |
1 |
SequenceFeature sf7 = new SequenceFeature("Pfam", "desc2", 0, 0, |
213 |
|
Float.NaN, null); |
214 |
1 |
store.add(sf7); |
215 |
|
|
216 |
|
|
217 |
|
|
218 |
|
|
219 |
1 |
List<SequenceFeature> features = store.getNonPositionalFeatures(); |
220 |
1 |
assertEquals(features.size(), 3); |
221 |
1 |
assertTrue(features.contains(sf2)); |
222 |
1 |
assertTrue(features.contains(sf5)); |
223 |
1 |
assertTrue(features.contains(sf7)); |
224 |
|
|
225 |
|
|
226 |
|
|
227 |
|
|
228 |
1 |
assertTrue(store.getNonPositionalFeatures((String) null).isEmpty()); |
229 |
1 |
assertTrue(store.getNonPositionalFeatures("Cath").isEmpty()); |
230 |
1 |
assertTrue(store.getNonPositionalFeatures("PFAM").isEmpty()); |
231 |
|
|
232 |
1 |
features = store.getNonPositionalFeatures("Metal"); |
233 |
1 |
assertEquals(features.size(), 1); |
234 |
1 |
assertTrue(features.contains(sf2)); |
235 |
|
|
236 |
1 |
features = store.getNonPositionalFeatures("Pfam"); |
237 |
1 |
assertEquals(features.size(), 2); |
238 |
1 |
assertTrue(features.contains(sf5)); |
239 |
1 |
assertTrue(features.contains(sf7)); |
240 |
|
} |
241 |
|
|
242 |
|
|
243 |
|
|
244 |
|
|
245 |
|
@param |
246 |
|
@param |
247 |
|
@param |
248 |
|
@param |
249 |
|
@return |
250 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0.33 |
|
251 |
14 |
SequenceFeature addFeature(SequenceFeaturesI sf, String type, int from,... |
252 |
|
int to) |
253 |
|
{ |
254 |
14 |
SequenceFeature sf1 = new SequenceFeature(type, "", from, to, |
255 |
|
Float.NaN, |
256 |
|
null); |
257 |
14 |
sf.add(sf1); |
258 |
14 |
return sf1; |
259 |
|
} |
260 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (47) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
261 |
1 |
@Test(groups = "Functional")... |
262 |
|
public void testFindFeatures() |
263 |
|
{ |
264 |
1 |
SequenceFeaturesI sf = new SequenceFeatures(); |
265 |
1 |
SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50); |
266 |
1 |
SequenceFeature sf2 = addFeature(sf, "Pfam", 1, 15); |
267 |
1 |
SequenceFeature sf3 = addFeature(sf, "Pfam", 20, 30); |
268 |
1 |
SequenceFeature sf4 = addFeature(sf, "Pfam", 40, 100); |
269 |
1 |
SequenceFeature sf5 = addFeature(sf, "Pfam", 60, 100); |
270 |
1 |
SequenceFeature sf6 = addFeature(sf, "Pfam", 70, 70); |
271 |
1 |
SequenceFeature sf7 = addFeature(sf, "Cath", 10, 50); |
272 |
1 |
SequenceFeature sf8 = addFeature(sf, "Cath", 1, 15); |
273 |
1 |
SequenceFeature sf9 = addFeature(sf, "Cath", 20, 30); |
274 |
1 |
SequenceFeature sf10 = addFeature(sf, "Cath", 40, 100); |
275 |
1 |
SequenceFeature sf11 = addFeature(sf, "Cath", 60, 100); |
276 |
1 |
SequenceFeature sf12 = addFeature(sf, "Cath", 70, 70); |
277 |
|
|
278 |
1 |
List<SequenceFeature> overlaps = sf.findFeatures(200, 200, "Pfam"); |
279 |
1 |
assertTrue(overlaps.isEmpty()); |
280 |
|
|
281 |
1 |
overlaps = sf.findFeatures( 1, 9, "Pfam"); |
282 |
1 |
assertEquals(overlaps.size(), 1); |
283 |
1 |
assertTrue(overlaps.contains(sf2)); |
284 |
|
|
285 |
1 |
overlaps = sf.findFeatures( 5, 18, "Pfam"); |
286 |
1 |
assertEquals(overlaps.size(), 2); |
287 |
1 |
assertTrue(overlaps.contains(sf1)); |
288 |
1 |
assertTrue(overlaps.contains(sf2)); |
289 |
|
|
290 |
1 |
overlaps = sf.findFeatures(30, 40, "Pfam"); |
291 |
1 |
assertEquals(overlaps.size(), 3); |
292 |
1 |
assertTrue(overlaps.contains(sf1)); |
293 |
1 |
assertTrue(overlaps.contains(sf3)); |
294 |
1 |
assertTrue(overlaps.contains(sf4)); |
295 |
|
|
296 |
1 |
overlaps = sf.findFeatures( 80, 90, "Pfam"); |
297 |
1 |
assertEquals(overlaps.size(), 2); |
298 |
1 |
assertTrue(overlaps.contains(sf4)); |
299 |
1 |
assertTrue(overlaps.contains(sf5)); |
300 |
|
|
301 |
1 |
overlaps = sf.findFeatures( 68, 70, "Pfam"); |
302 |
1 |
assertEquals(overlaps.size(), 3); |
303 |
1 |
assertTrue(overlaps.contains(sf4)); |
304 |
1 |
assertTrue(overlaps.contains(sf5)); |
305 |
1 |
assertTrue(overlaps.contains(sf6)); |
306 |
|
|
307 |
1 |
overlaps = sf.findFeatures(16, 69, "Cath"); |
308 |
1 |
assertEquals(overlaps.size(), 4); |
309 |
1 |
assertTrue(overlaps.contains(sf7)); |
310 |
1 |
assertFalse(overlaps.contains(sf8)); |
311 |
1 |
assertTrue(overlaps.contains(sf9)); |
312 |
1 |
assertTrue(overlaps.contains(sf10)); |
313 |
1 |
assertTrue(overlaps.contains(sf11)); |
314 |
1 |
assertFalse(overlaps.contains(sf12)); |
315 |
|
|
316 |
1 |
assertTrue(sf.findFeatures(0, 1000, "Metal").isEmpty()); |
317 |
|
|
318 |
1 |
overlaps = sf.findFeatures(7, 7, (String) null); |
319 |
1 |
assertTrue(overlaps.isEmpty()); |
320 |
|
} |
321 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 1 |
Complexity Density: 0.12 |
1PASS
|
|
322 |
1 |
@Test(groups = "Functional")... |
323 |
|
public void testDelete() |
324 |
|
{ |
325 |
1 |
SequenceFeaturesI sf = new SequenceFeatures(); |
326 |
1 |
SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50); |
327 |
1 |
assertTrue(sf.getPositionalFeatures().contains(sf1)); |
328 |
|
|
329 |
1 |
assertFalse(sf.delete(null)); |
330 |
1 |
SequenceFeature sf2 = new SequenceFeature("Cath", "", 10, 15, 0f, null); |
331 |
1 |
assertFalse(sf.delete(sf2)); |
332 |
1 |
assertTrue(sf.delete(sf1)); |
333 |
1 |
assertTrue(sf.getPositionalFeatures().isEmpty()); |
334 |
|
} |
335 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0.17 |
1PASS
|
|
336 |
1 |
@Test(groups = "Functional")... |
337 |
|
public void testHasFeatures() |
338 |
|
{ |
339 |
1 |
SequenceFeaturesI sf = new SequenceFeatures(); |
340 |
1 |
assertFalse(sf.hasFeatures()); |
341 |
|
|
342 |
1 |
SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50); |
343 |
1 |
assertTrue(sf.hasFeatures()); |
344 |
|
|
345 |
1 |
sf.delete(sf1); |
346 |
1 |
assertFalse(sf.hasFeatures()); |
347 |
|
} |
348 |
|
|
349 |
|
|
350 |
|
|
351 |
|
|
352 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (60) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
353 |
1 |
@Test(groups = "Functional")... |
354 |
|
public void testGetFeatureGroups() |
355 |
|
{ |
356 |
1 |
SequenceFeaturesI sf = new SequenceFeatures(); |
357 |
1 |
assertTrue(sf.getFeatureGroups(true).isEmpty()); |
358 |
1 |
assertTrue(sf.getFeatureGroups(false).isEmpty()); |
359 |
|
|
360 |
|
|
361 |
|
|
362 |
|
|
363 |
1 |
SequenceFeature sfx = new SequenceFeature("AType", "Desc", 0, 0, 0f, |
364 |
|
"AGroup"); |
365 |
1 |
sf.add(sfx); |
366 |
1 |
Set<String> groups = sf.getFeatureGroups(true); |
367 |
1 |
assertTrue(groups.isEmpty()); |
368 |
1 |
groups = sf.getFeatureGroups(false); |
369 |
1 |
assertEquals(groups.size(), 1); |
370 |
1 |
assertTrue(groups.contains("AGroup")); |
371 |
1 |
groups = sf.getFeatureGroups(false, "AType"); |
372 |
1 |
assertEquals(groups.size(), 1); |
373 |
1 |
assertTrue(groups.contains("AGroup")); |
374 |
1 |
groups = sf.getFeatureGroups(true, "AnotherType"); |
375 |
1 |
assertTrue(groups.isEmpty()); |
376 |
|
|
377 |
|
|
378 |
|
|
379 |
|
|
380 |
1 |
SequenceFeature sfy = new SequenceFeature("AnotherType", "Desc", 0, 0, |
381 |
|
0f, |
382 |
|
"AnotherGroup"); |
383 |
1 |
sf.add(sfy); |
384 |
1 |
SequenceFeature sfz = new SequenceFeature("AThirdType", "Desc", 0, 0, |
385 |
|
0f, |
386 |
|
null); |
387 |
1 |
sf.add(sfz); |
388 |
1 |
groups = sf.getFeatureGroups(false); |
389 |
1 |
assertEquals(groups.size(), 3); |
390 |
1 |
assertTrue(groups.contains("AGroup")); |
391 |
1 |
assertTrue(groups.contains("AnotherGroup")); |
392 |
1 |
assertTrue(groups.contains(null)); |
393 |
1 |
sf.delete(sfz); |
394 |
1 |
sf.delete(sfy); |
395 |
1 |
groups = sf.getFeatureGroups(false); |
396 |
1 |
assertEquals(groups.size(), 1); |
397 |
1 |
assertTrue(groups.contains("AGroup")); |
398 |
|
|
399 |
|
|
400 |
|
|
401 |
|
|
402 |
1 |
SequenceFeature sf1 = new SequenceFeature("Pfam", "Desc", 10, 50, 0f, |
403 |
|
"PfamGroup"); |
404 |
1 |
sf.add(sf1); |
405 |
1 |
groups = sf.getFeatureGroups(true); |
406 |
1 |
assertEquals(groups.size(), 1); |
407 |
1 |
assertTrue(groups.contains("PfamGroup")); |
408 |
1 |
groups = sf.getFeatureGroups(false); |
409 |
1 |
assertEquals(groups.size(), 1); |
410 |
1 |
assertTrue(groups.contains("AGroup")); |
411 |
|
|
412 |
1 |
SequenceFeature sf2 = new SequenceFeature("Cath", "Desc", 10, 50, 0f, |
413 |
|
null); |
414 |
1 |
sf.add(sf2); |
415 |
1 |
groups = sf.getFeatureGroups(true); |
416 |
1 |
assertEquals(groups.size(), 2); |
417 |
1 |
assertTrue(groups.contains("PfamGroup")); |
418 |
1 |
assertTrue(groups.contains(null)); |
419 |
|
|
420 |
1 |
sf.delete(sf1); |
421 |
1 |
sf.delete(sf2); |
422 |
1 |
assertTrue(sf.getFeatureGroups(true).isEmpty()); |
423 |
|
|
424 |
1 |
SequenceFeature sf3 = new SequenceFeature("CDS", "", 10, 50, 0f, |
425 |
|
"Ensembl"); |
426 |
1 |
sf.add(sf3); |
427 |
1 |
SequenceFeature sf4 = new SequenceFeature("exon", "", 10, 50, 0f, |
428 |
|
"Ensembl"); |
429 |
1 |
sf.add(sf4); |
430 |
1 |
groups = sf.getFeatureGroups(true); |
431 |
1 |
assertEquals(groups.size(), 1); |
432 |
1 |
assertTrue(groups.contains("Ensembl")); |
433 |
|
|
434 |
|
|
435 |
|
|
436 |
|
|
437 |
|
|
438 |
1 |
sf.delete(sf3); |
439 |
1 |
groups = sf.getFeatureGroups(true); |
440 |
1 |
assertEquals(groups.size(), 1); |
441 |
1 |
assertTrue(groups.contains("Ensembl")); |
442 |
|
|
443 |
|
|
444 |
|
|
445 |
|
|
446 |
1 |
sf.delete(sfx); |
447 |
1 |
groups = sf.getFeatureGroups(false); |
448 |
1 |
assertTrue(groups.isEmpty()); |
449 |
|
} |
450 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (47) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
451 |
1 |
@Test(groups = "Functional")... |
452 |
|
public void testGetFeatureTypesForGroups() |
453 |
|
{ |
454 |
1 |
SequenceFeaturesI sf = new SequenceFeatures(); |
455 |
1 |
assertTrue(sf.getFeatureTypesForGroups(true, (String) null).isEmpty()); |
456 |
|
|
457 |
|
|
458 |
|
|
459 |
|
|
460 |
1 |
String groupUniprot = "Uniprot"; |
461 |
1 |
SequenceFeature sf1 = new SequenceFeature("helix", "Desc", 10, 50, 0f, |
462 |
|
groupUniprot); |
463 |
1 |
sf.add(sf1); |
464 |
1 |
Set<String> groups = sf.getFeatureTypesForGroups(true, groupUniprot); |
465 |
1 |
assertEquals(groups.size(), 1); |
466 |
1 |
assertTrue(groups.contains("helix")); |
467 |
1 |
assertTrue(sf.getFeatureTypesForGroups(true, (String) null).isEmpty()); |
468 |
|
|
469 |
|
|
470 |
|
|
471 |
|
|
472 |
1 |
SequenceFeature sf2 = new SequenceFeature("strand", "Desc", 10, 50, 0f, |
473 |
|
groupUniprot); |
474 |
1 |
sf.add(sf2); |
475 |
1 |
groups = sf.getFeatureTypesForGroups(true, groupUniprot); |
476 |
1 |
assertEquals(groups.size(), 2); |
477 |
1 |
assertTrue(groups.contains("helix")); |
478 |
1 |
assertTrue(groups.contains("strand")); |
479 |
|
|
480 |
|
|
481 |
|
|
482 |
|
|
483 |
1 |
sf.delete(sf2); |
484 |
1 |
groups = sf.getFeatureTypesForGroups(true, groupUniprot); |
485 |
1 |
assertEquals(groups.size(), 1); |
486 |
1 |
assertTrue(groups.contains("helix")); |
487 |
|
|
488 |
|
|
489 |
|
|
490 |
|
|
491 |
1 |
sf.delete(sf1); |
492 |
1 |
assertTrue(sf.getFeatureTypesForGroups(true, groupUniprot).isEmpty()); |
493 |
|
|
494 |
|
|
495 |
|
|
496 |
|
|
497 |
1 |
SequenceFeature sf3 = new SequenceFeature("strand", "Desc", 10, 50, 0f, |
498 |
|
null); |
499 |
1 |
sf.add(sf3); |
500 |
1 |
SequenceFeature sf4 = new SequenceFeature("turn", "Desc", 10, 50, 0f, |
501 |
|
null); |
502 |
1 |
sf.add(sf4); |
503 |
1 |
groups = sf.getFeatureTypesForGroups(true, (String) null); |
504 |
1 |
assertEquals(groups.size(), 2); |
505 |
1 |
assertTrue(groups.contains("strand")); |
506 |
1 |
assertTrue(groups.contains("turn")); |
507 |
|
|
508 |
|
|
509 |
|
|
510 |
|
|
511 |
|
|
512 |
1 |
SequenceFeature sf5 = new SequenceFeature("strand", "Desc", 10, 50, 0f, |
513 |
|
"Cath"); |
514 |
1 |
sf.add(sf5); |
515 |
1 |
SequenceFeature sf6 = new SequenceFeature("turn", "Desc", 10, 50, 0f, |
516 |
|
"Scop"); |
517 |
1 |
sf.add(sf6); |
518 |
1 |
groups = sf.getFeatureTypesForGroups(true, "Cath"); |
519 |
1 |
assertEquals(groups.size(), 1); |
520 |
1 |
assertTrue(groups.contains("strand")); |
521 |
1 |
groups = sf.getFeatureTypesForGroups(true, "Scop"); |
522 |
1 |
assertEquals(groups.size(), 1); |
523 |
1 |
assertTrue(groups.contains("turn")); |
524 |
1 |
groups = sf.getFeatureTypesForGroups(true, "Cath", "Scop"); |
525 |
1 |
assertEquals(groups.size(), 2); |
526 |
1 |
assertTrue(groups.contains("turn")); |
527 |
1 |
assertTrue(groups.contains("strand")); |
528 |
|
|
529 |
1 |
groups = sf.getFeatureTypesForGroups(true, new String[] { "Cath", |
530 |
|
"Scop" }); |
531 |
1 |
assertEquals(groups.size(), 2); |
532 |
1 |
assertTrue(groups.contains("turn")); |
533 |
1 |
assertTrue(groups.contains("strand")); |
534 |
|
} |
535 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (36) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
536 |
1 |
@Test(groups = "Functional")... |
537 |
|
public void testGetFeatureTypes() |
538 |
|
{ |
539 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
540 |
1 |
Set<String> types = store.getFeatureTypes(); |
541 |
1 |
assertTrue(types.isEmpty()); |
542 |
|
|
543 |
1 |
SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, |
544 |
|
Float.NaN, null); |
545 |
1 |
store.add(sf1); |
546 |
1 |
types = store.getFeatureTypes(); |
547 |
1 |
assertEquals(types.size(), 1); |
548 |
1 |
assertTrue(types.contains("Metal")); |
549 |
|
|
550 |
|
|
551 |
1 |
SequenceFeature sf2 = new SequenceFeature(null, "desc", 10, 20, |
552 |
|
Float.NaN, null); |
553 |
1 |
assertFalse(store.add(sf2)); |
554 |
1 |
types = store.getFeatureTypes(); |
555 |
1 |
assertEquals(types.size(), 1); |
556 |
1 |
assertFalse(types.contains(null)); |
557 |
1 |
assertTrue(types.contains("Metal")); |
558 |
|
|
559 |
|
|
560 |
|
|
561 |
|
|
562 |
1 |
SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0, |
563 |
|
Float.NaN, null); |
564 |
1 |
store.add(sf3); |
565 |
1 |
types = store.getFeatureTypes(); |
566 |
1 |
assertEquals(types.size(), 2); |
567 |
1 |
assertTrue(types.contains("Pfam")); |
568 |
|
|
569 |
|
|
570 |
|
|
571 |
|
|
572 |
1 |
SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc", |
573 |
|
10, 20, Float.NaN, null); |
574 |
1 |
store.add(sf4); |
575 |
1 |
types = store.getFeatureTypes(); |
576 |
1 |
assertEquals(types.size(), 3); |
577 |
1 |
assertTrue(types.contains("Disulphide Bond")); |
578 |
|
|
579 |
|
|
580 |
|
|
581 |
|
|
582 |
1 |
SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20, |
583 |
|
Float.NaN, null); |
584 |
1 |
store.add(sf5); |
585 |
1 |
types = store.getFeatureTypes(); |
586 |
1 |
assertEquals(types.size(), 3); |
587 |
|
|
588 |
|
|
589 |
|
|
590 |
|
|
591 |
1 |
assertTrue(store.delete(sf3)); |
592 |
1 |
types = store.getFeatureTypes(); |
593 |
1 |
assertEquals(types.size(), 3); |
594 |
1 |
assertTrue(types.contains("Pfam")); |
595 |
|
|
596 |
|
|
597 |
|
|
598 |
|
|
599 |
1 |
assertTrue(store.delete(sf5)); |
600 |
1 |
types = store.getFeatureTypes(); |
601 |
1 |
assertEquals(types.size(), 2); |
602 |
1 |
assertFalse(types.contains("Pfam")); |
603 |
|
} |
604 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (36) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
605 |
1 |
@Test(groups = "Functional")... |
606 |
|
public void testGetFeatureCount() |
607 |
|
{ |
608 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
609 |
1 |
assertEquals(store.getFeatureCount(true), 0); |
610 |
1 |
assertEquals(store.getFeatureCount(false), 0); |
611 |
|
|
612 |
|
|
613 |
|
|
614 |
|
|
615 |
1 |
SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, |
616 |
|
Float.NaN, null); |
617 |
1 |
store.add(sf1); |
618 |
1 |
assertEquals(store.getFeatureCount(true), 1); |
619 |
1 |
assertEquals(store.getFeatureCount(false), 0); |
620 |
|
|
621 |
|
|
622 |
|
|
623 |
|
|
624 |
1 |
SequenceFeature sf2 = new SequenceFeature(null, "desc", 10, 20, |
625 |
|
Float.NaN, null); |
626 |
1 |
assertFalse(store.add(sf2)); |
627 |
1 |
assertEquals(store.getFeatureCount(true), 1); |
628 |
1 |
assertEquals(store.getFeatureCount(false), 0); |
629 |
|
|
630 |
|
|
631 |
|
|
632 |
|
|
633 |
1 |
SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0, |
634 |
|
Float.NaN, null); |
635 |
1 |
store.add(sf3); |
636 |
1 |
assertEquals(store.getFeatureCount(true), 1); |
637 |
1 |
assertEquals(store.getFeatureCount(false), 1); |
638 |
|
|
639 |
|
|
640 |
|
|
641 |
|
|
642 |
1 |
SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc", |
643 |
|
10, 20, Float.NaN, null); |
644 |
1 |
store.add(sf4); |
645 |
1 |
assertEquals(store.getFeatureCount(true), 2); |
646 |
1 |
assertEquals(store.getFeatureCount(false), 1); |
647 |
|
|
648 |
|
|
649 |
|
|
650 |
|
|
651 |
1 |
SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20, |
652 |
|
Float.NaN, null); |
653 |
1 |
store.add(sf5); |
654 |
1 |
assertEquals(store.getFeatureCount(true), 3); |
655 |
1 |
assertEquals(store.getFeatureCount(false), 1); |
656 |
1 |
assertEquals(store.getFeatureCount(true, "Pfam"), 1); |
657 |
1 |
assertEquals(store.getFeatureCount(false, "Pfam"), 1); |
658 |
|
|
659 |
1 |
assertEquals(store.getFeatureCount(true, (String) null), 0); |
660 |
|
|
661 |
1 |
assertEquals(store.getFeatureCount(true, (String[]) null), 3); |
662 |
1 |
assertEquals(store.getFeatureCount(true, "Metal", "Cath"), 1); |
663 |
1 |
assertEquals(store.getFeatureCount(true, "Disulphide Bond"), 1); |
664 |
1 |
assertEquals(store.getFeatureCount(true, "Metal", "Pfam", null), 2); |
665 |
|
|
666 |
|
|
667 |
|
|
668 |
|
|
669 |
1 |
assertTrue(store.delete(sf3)); |
670 |
1 |
assertEquals(store.getFeatureCount(true), 3); |
671 |
1 |
assertEquals(store.getFeatureCount(false), 0); |
672 |
|
|
673 |
|
|
674 |
|
|
675 |
|
|
676 |
1 |
assertTrue(store.delete(sf5)); |
677 |
1 |
assertEquals(store.getFeatureCount(true), 2); |
678 |
1 |
assertEquals(store.getFeatureCount(false), 0); |
679 |
|
} |
680 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (44) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
681 |
1 |
@Test(groups = "Functional")... |
682 |
|
public void testGetAllFeatures() |
683 |
|
{ |
684 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
685 |
1 |
List<SequenceFeature> features = store.getAllFeatures(); |
686 |
1 |
assertTrue(features.isEmpty()); |
687 |
|
|
688 |
1 |
SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, |
689 |
|
Float.NaN, null); |
690 |
1 |
store.add(sf1); |
691 |
1 |
features = store.getAllFeatures(); |
692 |
1 |
assertEquals(features.size(), 1); |
693 |
1 |
assertTrue(features.contains(sf1)); |
694 |
|
|
695 |
1 |
SequenceFeature sf2 = new SequenceFeature("Metallic", "desc", 10, 20, |
696 |
|
Float.NaN, null); |
697 |
1 |
store.add(sf2); |
698 |
1 |
features = store.getAllFeatures(); |
699 |
1 |
assertEquals(features.size(), 2); |
700 |
1 |
assertTrue(features.contains(sf2)); |
701 |
|
|
702 |
|
|
703 |
|
|
704 |
|
|
705 |
1 |
SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0, |
706 |
|
Float.NaN, null); |
707 |
1 |
store.add(sf3); |
708 |
1 |
features = store.getAllFeatures(); |
709 |
1 |
assertEquals(features.size(), 3); |
710 |
1 |
assertTrue(features.contains(sf3)); |
711 |
|
|
712 |
|
|
713 |
|
|
714 |
|
|
715 |
1 |
SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc", |
716 |
|
10, 20, Float.NaN, null); |
717 |
1 |
store.add(sf4); |
718 |
1 |
features = store.getAllFeatures(); |
719 |
1 |
assertEquals(features.size(), 4); |
720 |
1 |
assertTrue(features.contains(sf4)); |
721 |
|
|
722 |
|
|
723 |
|
|
724 |
|
|
725 |
1 |
SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20, |
726 |
|
Float.NaN, null); |
727 |
1 |
store.add(sf5); |
728 |
1 |
features = store.getAllFeatures(); |
729 |
1 |
assertEquals(features.size(), 5); |
730 |
1 |
assertTrue(features.contains(sf5)); |
731 |
|
|
732 |
|
|
733 |
|
|
734 |
|
|
735 |
1 |
features = store.getAllFeatures("Cath"); |
736 |
1 |
assertEquals(features.size(), 1); |
737 |
1 |
assertTrue(features.contains(sf3)); |
738 |
|
|
739 |
1 |
features = store.getAllFeatures("Pfam", "Cath", "Metal"); |
740 |
1 |
assertEquals(features.size(), 3); |
741 |
1 |
assertTrue(features.contains(sf1)); |
742 |
1 |
assertTrue(features.contains(sf3)); |
743 |
1 |
assertTrue(features.contains(sf5)); |
744 |
|
|
745 |
|
|
746 |
|
|
747 |
|
|
748 |
1 |
assertTrue(store.delete(sf3)); |
749 |
1 |
features = store.getAllFeatures(); |
750 |
1 |
assertEquals(features.size(), 4); |
751 |
1 |
assertFalse(features.contains(sf3)); |
752 |
|
|
753 |
|
|
754 |
|
|
755 |
|
|
756 |
1 |
assertTrue(store.delete(sf5)); |
757 |
1 |
features = store.getAllFeatures(); |
758 |
1 |
assertEquals(features.size(), 3); |
759 |
1 |
assertFalse(features.contains(sf3)); |
760 |
|
} |
761 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (26) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
762 |
1 |
@Test(groups = "Functional")... |
763 |
|
public void testGetTotalFeatureLength() |
764 |
|
{ |
765 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
766 |
1 |
assertEquals(store.getTotalFeatureLength(), 0); |
767 |
|
|
768 |
1 |
SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, |
769 |
|
Float.NaN, null); |
770 |
1 |
assertTrue(store.add(sf1)); |
771 |
1 |
assertEquals(store.getTotalFeatureLength(), 11); |
772 |
1 |
assertEquals(store.getTotalFeatureLength("Metal"), 11); |
773 |
1 |
assertEquals(store.getTotalFeatureLength("Plastic"), 0); |
774 |
|
|
775 |
|
|
776 |
1 |
assertFalse(store.add(sf1)); |
777 |
1 |
assertEquals(store.getTotalFeatureLength(), 11); |
778 |
|
|
779 |
|
|
780 |
|
|
781 |
|
|
782 |
1 |
SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0, |
783 |
|
Float.NaN, null); |
784 |
1 |
store.add(sf3); |
785 |
1 |
assertEquals(store.getTotalFeatureLength(), 11); |
786 |
|
|
787 |
|
|
788 |
|
|
789 |
|
|
790 |
1 |
SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc", |
791 |
|
10, 20, Float.NaN, null); |
792 |
1 |
store.add(sf4); |
793 |
1 |
assertEquals(store.getTotalFeatureLength(), 12); |
794 |
|
|
795 |
|
|
796 |
|
|
797 |
|
|
798 |
1 |
SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20, |
799 |
|
Float.NaN, null); |
800 |
1 |
store.add(sf5); |
801 |
1 |
assertEquals(store.getTotalFeatureLength(), 23); |
802 |
|
|
803 |
|
|
804 |
|
|
805 |
|
|
806 |
1 |
assertTrue(store.delete(sf3)); |
807 |
1 |
assertEquals(store.getTotalFeatureLength(), 23); |
808 |
|
|
809 |
1 |
assertTrue(store.delete(sf5)); |
810 |
1 |
assertEquals(store.getTotalFeatureLength(), 12); |
811 |
|
|
812 |
1 |
assertTrue(store.delete(sf4)); |
813 |
1 |
assertEquals(store.getTotalFeatureLength(), 11); |
814 |
|
|
815 |
1 |
assertTrue(store.delete(sf1)); |
816 |
1 |
assertEquals(store.getTotalFeatureLength(), 0); |
817 |
|
} |
818 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (44) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
819 |
1 |
@Test(groups = "Functional")... |
820 |
|
public void testGetMinimumScore_getMaximumScore() |
821 |
|
{ |
822 |
1 |
SequenceFeatures sf = new SequenceFeatures(); |
823 |
1 |
SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 0, 0, |
824 |
|
Float.NaN, "group"); |
825 |
1 |
sf.add(sf1); |
826 |
1 |
SequenceFeature sf2 = new SequenceFeature("Cath", "desc", 10, 20, |
827 |
|
Float.NaN, "group"); |
828 |
1 |
sf.add(sf2); |
829 |
1 |
SequenceFeature sf3 = new SequenceFeature("Metal", "desc", 10, 20, 1f, |
830 |
|
"group"); |
831 |
1 |
sf.add(sf3); |
832 |
1 |
SequenceFeature sf4 = new SequenceFeature("Metal", "desc", 12, 16, 4f, |
833 |
|
"group"); |
834 |
1 |
sf.add(sf4); |
835 |
1 |
SequenceFeature sf5 = new SequenceFeature("Cath", "desc", 0, 0, 11f, |
836 |
|
"group"); |
837 |
1 |
sf.add(sf5); |
838 |
1 |
SequenceFeature sf6 = new SequenceFeature("Cath", "desc", 0, 0, -7f, |
839 |
|
"group"); |
840 |
1 |
sf.add(sf6); |
841 |
|
|
842 |
1 |
assertEquals(sf.getMinimumScore("nosuchtype", true), Float.NaN); |
843 |
1 |
assertEquals(sf.getMinimumScore("nosuchtype", false), Float.NaN); |
844 |
1 |
assertEquals(sf.getMaximumScore("nosuchtype", true), Float.NaN); |
845 |
1 |
assertEquals(sf.getMaximumScore("nosuchtype", false), Float.NaN); |
846 |
|
|
847 |
|
|
848 |
1 |
assertEquals(sf.getMinimumScore("Metal", true), 1f); |
849 |
1 |
assertEquals(sf.getMaximumScore("Metal", true), 4f); |
850 |
1 |
assertEquals(sf.getMinimumScore("Cath", true), Float.NaN); |
851 |
1 |
assertEquals(sf.getMaximumScore("Cath", true), Float.NaN); |
852 |
|
|
853 |
|
|
854 |
1 |
assertEquals(sf.getMinimumScore("Cath", false), -7f); |
855 |
1 |
assertEquals(sf.getMaximumScore("Cath", false), 11f); |
856 |
1 |
assertEquals(sf.getMinimumScore("Metal", false), Float.NaN); |
857 |
1 |
assertEquals(sf.getMaximumScore("Metal", false), Float.NaN); |
858 |
|
|
859 |
|
|
860 |
1 |
sf.delete(sf6); |
861 |
1 |
assertEquals(sf.getMinimumScore("Cath", false), 11f); |
862 |
1 |
assertEquals(sf.getMaximumScore("Cath", false), 11f); |
863 |
1 |
sf.delete(sf4); |
864 |
1 |
assertEquals(sf.getMinimumScore("Metal", true), 1f); |
865 |
1 |
assertEquals(sf.getMaximumScore("Metal", true), 1f); |
866 |
1 |
sf.delete(sf5); |
867 |
1 |
assertEquals(sf.getMinimumScore("Cath", false), Float.NaN); |
868 |
1 |
assertEquals(sf.getMaximumScore("Cath", false), Float.NaN); |
869 |
1 |
sf.delete(sf3); |
870 |
1 |
assertEquals(sf.getMinimumScore("Metal", true), Float.NaN); |
871 |
1 |
assertEquals(sf.getMaximumScore("Metal", true), Float.NaN); |
872 |
1 |
sf.delete(sf1); |
873 |
1 |
sf.delete(sf2); |
874 |
1 |
assertFalse(sf.hasFeatures()); |
875 |
1 |
assertEquals(sf.getMinimumScore("Cath", false), Float.NaN); |
876 |
1 |
assertEquals(sf.getMaximumScore("Cath", false), Float.NaN); |
877 |
1 |
assertEquals(sf.getMinimumScore("Metal", true), Float.NaN); |
878 |
1 |
assertEquals(sf.getMaximumScore("Metal", true), Float.NaN); |
879 |
|
} |
880 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (44) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
881 |
1 |
@Test(groups = "Functional")... |
882 |
|
public void testVarargsToTypes() |
883 |
|
{ |
884 |
1 |
SequenceFeatures sf = new SequenceFeatures(); |
885 |
1 |
sf.add(new SequenceFeature("Metal", "desc", 0, 0, Float.NaN, "group")); |
886 |
1 |
sf.add(new SequenceFeature("Cath", "desc", 10, 20, Float.NaN, "group")); |
887 |
|
|
888 |
|
|
889 |
|
|
890 |
|
|
891 |
|
|
892 |
1 |
Map<String, FeatureStore> featureStores = (Map<String, FeatureStore>) PA |
893 |
|
.getValue(sf, "featureStore"); |
894 |
|
|
895 |
1 |
Iterable<FeatureStore> types = sf.varargToTypes(); |
896 |
1 |
Iterator<FeatureStore> iterator = types.iterator(); |
897 |
1 |
assertTrue(iterator.hasNext()); |
898 |
1 |
assertSame(iterator.next(), featureStores.get("Cath")); |
899 |
1 |
assertTrue(iterator.hasNext()); |
900 |
1 |
assertSame(iterator.next(), featureStores.get("Metal")); |
901 |
1 |
assertFalse(iterator.hasNext()); |
902 |
|
|
903 |
|
|
904 |
|
|
905 |
|
|
906 |
|
|
907 |
1 |
types = sf.varargToTypes(new String[] {}); |
908 |
1 |
iterator = types.iterator(); |
909 |
1 |
assertTrue(iterator.hasNext()); |
910 |
1 |
assertSame(iterator.next(), featureStores.get("Cath")); |
911 |
1 |
assertTrue(iterator.hasNext()); |
912 |
1 |
assertSame(iterator.next(), featureStores.get("Metal")); |
913 |
1 |
assertFalse(iterator.hasNext()); |
914 |
|
|
915 |
|
|
916 |
|
|
917 |
|
|
918 |
|
|
919 |
1 |
types = sf.varargToTypes((String) null); |
920 |
1 |
assertFalse(types.iterator().hasNext()); |
921 |
|
|
922 |
|
|
923 |
|
|
924 |
|
|
925 |
1 |
types = sf.varargToTypes((String[]) null); |
926 |
1 |
iterator = types.iterator(); |
927 |
1 |
assertTrue(iterator.hasNext()); |
928 |
1 |
assertSame(iterator.next(), featureStores.get("Cath")); |
929 |
1 |
assertTrue(iterator.hasNext()); |
930 |
1 |
assertSame(iterator.next(), featureStores.get("Metal")); |
931 |
1 |
assertFalse(iterator.hasNext()); |
932 |
|
|
933 |
|
|
934 |
|
|
935 |
|
|
936 |
1 |
types = sf.varargToTypes("Metal"); |
937 |
1 |
iterator = types.iterator(); |
938 |
1 |
assertTrue(iterator.hasNext()); |
939 |
1 |
assertSame(iterator.next(), featureStores.get("Metal")); |
940 |
1 |
assertFalse(iterator.hasNext()); |
941 |
|
|
942 |
|
|
943 |
|
|
944 |
|
|
945 |
1 |
types = sf.varargToTypes("Metal", "Cath"); |
946 |
1 |
iterator = types.iterator(); |
947 |
1 |
assertTrue(iterator.hasNext()); |
948 |
1 |
assertSame(iterator.next(), featureStores.get("Cath")); |
949 |
1 |
assertTrue(iterator.hasNext()); |
950 |
1 |
assertSame(iterator.next(), featureStores.get("Metal")); |
951 |
1 |
assertFalse(iterator.hasNext()); |
952 |
|
|
953 |
|
|
954 |
|
|
955 |
|
|
956 |
1 |
types = sf.varargToTypes("Metal", null, "Helix"); |
957 |
1 |
iterator = types.iterator(); |
958 |
1 |
assertTrue(iterator.hasNext()); |
959 |
1 |
assertSame(iterator.next(), featureStores.get("Metal")); |
960 |
1 |
assertFalse(iterator.hasNext()); |
961 |
|
} |
962 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (20) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
963 |
1 |
@Test(groups = "Functional")... |
964 |
|
public void testGetFeatureTypes_byOntology() |
965 |
|
{ |
966 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
967 |
|
|
968 |
1 |
SequenceFeature sf1 = new SequenceFeature("transcript", "desc", 10, 20, |
969 |
|
Float.NaN, null); |
970 |
1 |
store.add(sf1); |
971 |
|
|
972 |
1 |
SequenceFeature sf2 = new SequenceFeature("mRNA", "desc", 10, 20, |
973 |
|
Float.NaN, null); |
974 |
1 |
store.add(sf2); |
975 |
|
|
976 |
1 |
SequenceFeature sf3 = new SequenceFeature("mRNA", "desc", 0, 0, |
977 |
|
Float.NaN, null); |
978 |
1 |
store.add(sf3); |
979 |
1 |
SequenceFeature sf4 = new SequenceFeature("CDS", "desc", 0, 0, |
980 |
|
Float.NaN, null); |
981 |
1 |
store.add(sf4); |
982 |
|
|
983 |
1 |
Set<String> types = store.getFeatureTypes("transcript"); |
984 |
1 |
assertEquals(types.size(), 2); |
985 |
1 |
assertTrue(types.contains("transcript")); |
986 |
1 |
assertTrue(types.contains("mRNA")); |
987 |
|
|
988 |
|
|
989 |
1 |
types = store.getFeatureTypes("transcript", "CDS"); |
990 |
1 |
assertEquals(types.size(), 3); |
991 |
1 |
assertTrue(types.contains("transcript")); |
992 |
1 |
assertTrue(types.contains("mRNA")); |
993 |
1 |
assertTrue(types.contains("CDS")); |
994 |
|
|
995 |
1 |
types = store.getFeatureTypes("exon"); |
996 |
1 |
assertTrue(types.isEmpty()); |
997 |
|
} |
998 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (24) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
999 |
1 |
@Test(groups = "Functional")... |
1000 |
|
public void testGetFeaturesByOntology() |
1001 |
|
{ |
1002 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
1003 |
1 |
List<SequenceFeature> features = store.getFeaturesByOntology(); |
1004 |
1 |
assertTrue(features.isEmpty()); |
1005 |
1 |
assertTrue(store.getFeaturesByOntology(new String[] {}).isEmpty()); |
1006 |
1 |
assertTrue(store.getFeaturesByOntology((String[]) null).isEmpty()); |
1007 |
|
|
1008 |
1 |
SequenceFeature sf1 = new SequenceFeature("transcript", "desc", 10, 20, |
1009 |
|
Float.NaN, null); |
1010 |
1 |
store.add(sf1); |
1011 |
|
|
1012 |
|
|
1013 |
|
|
1014 |
1 |
SequenceFeature sf2 = new SequenceFeature("mRNA", "desc", 0, 0, |
1015 |
|
Float.NaN, null); |
1016 |
1 |
store.add(sf2); |
1017 |
|
|
1018 |
1 |
SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 30, 40, |
1019 |
|
Float.NaN, null); |
1020 |
1 |
store.add(sf3); |
1021 |
|
|
1022 |
1 |
features = store.getFeaturesByOntology("transcript"); |
1023 |
1 |
assertEquals(features.size(), 2); |
1024 |
1 |
assertTrue(features.contains(sf1)); |
1025 |
1 |
assertTrue(features.contains(sf2)); |
1026 |
|
|
1027 |
1 |
features = store.getFeaturesByOntology("mRNA"); |
1028 |
1 |
assertEquals(features.size(), 1); |
1029 |
1 |
assertTrue(features.contains(sf2)); |
1030 |
|
|
1031 |
1 |
features = store.getFeaturesByOntology("mRNA", "Pfam"); |
1032 |
1 |
assertEquals(features.size(), 2); |
1033 |
1 |
assertTrue(features.contains(sf2)); |
1034 |
1 |
assertTrue(features.contains(sf3)); |
1035 |
|
|
1036 |
1 |
features = store.getFeaturesByOntology("sequence_variant"); |
1037 |
1 |
assertTrue(features.isEmpty()); |
1038 |
|
} |
1039 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (15) |
Complexity: 1 |
Complexity Density: 0.07 |
1PASS
|
|
1040 |
1 |
@Test(groups = "Functional")... |
1041 |
|
public void testSortFeatures() |
1042 |
|
{ |
1043 |
1 |
List<SequenceFeature> sfs = new ArrayList<SequenceFeature>(); |
1044 |
1 |
SequenceFeature sf1 = new SequenceFeature("Pfam", "desc", 30, 80, |
1045 |
|
Float.NaN, null); |
1046 |
1 |
sfs.add(sf1); |
1047 |
1 |
SequenceFeature sf2 = new SequenceFeature("Rfam", "desc", 40, 50, |
1048 |
|
Float.NaN, null); |
1049 |
1 |
sfs.add(sf2); |
1050 |
1 |
SequenceFeature sf3 = new SequenceFeature("Rfam", "desc", 50, 60, |
1051 |
|
Float.NaN, null); |
1052 |
1 |
sfs.add(sf3); |
1053 |
|
|
1054 |
|
|
1055 |
1 |
SequenceFeatures.sortFeatures(sfs, false); |
1056 |
1 |
assertSame(sfs.get(0), sf1); |
1057 |
1 |
assertSame(sfs.get(1), sf3); |
1058 |
1 |
assertSame(sfs.get(2), sf2); |
1059 |
|
|
1060 |
|
|
1061 |
1 |
SequenceFeatures.sortFeatures(sfs, true); |
1062 |
1 |
assertSame(sfs.get(0), sf1); |
1063 |
1 |
assertSame(sfs.get(1), sf2); |
1064 |
1 |
assertSame(sfs.get(2), sf3); |
1065 |
|
} |
1066 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (50) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
1067 |
1 |
@Test(groups = "Functional")... |
1068 |
|
public void testGetFeaturesForGroup() |
1069 |
|
{ |
1070 |
1 |
SequenceFeaturesI store = new SequenceFeatures(); |
1071 |
|
|
1072 |
1 |
List<SequenceFeature> features = store.getFeaturesForGroup(true, null); |
1073 |
1 |
assertTrue(features.isEmpty()); |
1074 |
1 |
assertTrue(store.getFeaturesForGroup(false, null).isEmpty()); |
1075 |
1 |
assertTrue(store.getFeaturesForGroup(true, "Uniprot").isEmpty()); |
1076 |
1 |
assertTrue(store.getFeaturesForGroup(false, "Uniprot").isEmpty()); |
1077 |
|
|
1078 |
1 |
SequenceFeature sf1 = new SequenceFeature("Pfam", "desc", 4, 10, 0f, |
1079 |
|
null); |
1080 |
1 |
SequenceFeature sf2 = new SequenceFeature("Pfam", "desc", 0, 0, 0f, |
1081 |
|
null); |
1082 |
1 |
SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 4, 10, 0f, |
1083 |
|
"Uniprot"); |
1084 |
1 |
SequenceFeature sf4 = new SequenceFeature("Metal", "desc", 0, 0, 0f, |
1085 |
|
"Rfam"); |
1086 |
1 |
SequenceFeature sf5 = new SequenceFeature("Cath", "desc", 5, 15, 0f, |
1087 |
|
null); |
1088 |
1 |
store.add(sf1); |
1089 |
1 |
store.add(sf2); |
1090 |
1 |
store.add(sf3); |
1091 |
1 |
store.add(sf4); |
1092 |
1 |
store.add(sf5); |
1093 |
|
|
1094 |
|
|
1095 |
1 |
features = store.getFeaturesForGroup(true, null); |
1096 |
1 |
assertEquals(features.size(), 2); |
1097 |
1 |
assertTrue(features.contains(sf1)); |
1098 |
1 |
assertTrue(features.contains(sf5)); |
1099 |
|
|
1100 |
|
|
1101 |
1 |
features = store.getFeaturesForGroup(true, null, new String[] { "Pfam", |
1102 |
|
"Xfam" }); |
1103 |
1 |
assertEquals(features.size(), 1); |
1104 |
1 |
assertTrue(features.contains(sf1)); |
1105 |
1 |
features = store.getFeaturesForGroup(true, null, new String[] { "Pfam", |
1106 |
|
"Xfam", "Cath" }); |
1107 |
1 |
assertEquals(features.size(), 2); |
1108 |
1 |
assertTrue(features.contains(sf1)); |
1109 |
1 |
assertTrue(features.contains(sf5)); |
1110 |
|
|
1111 |
|
|
1112 |
1 |
features = store.getFeaturesForGroup(true, "Uniprot"); |
1113 |
1 |
assertEquals(features.size(), 1); |
1114 |
1 |
assertTrue(features.contains(sf3)); |
1115 |
1 |
assertTrue(store.getFeaturesForGroup(true, "Rfam").isEmpty()); |
1116 |
|
|
1117 |
|
|
1118 |
1 |
features = store.getFeaturesForGroup(true, "Uniprot", "Pfam", "Xfam", |
1119 |
|
"Rfam"); |
1120 |
1 |
assertEquals(features.size(), 1); |
1121 |
1 |
assertTrue(features.contains(sf3)); |
1122 |
1 |
assertTrue(store.getFeaturesForGroup(true, "Uniprot", "Cath").isEmpty()); |
1123 |
|
|
1124 |
|
|
1125 |
1 |
features = store.getFeaturesForGroup(false, null); |
1126 |
1 |
assertEquals(features.size(), 1); |
1127 |
1 |
assertTrue(features.contains(sf2)); |
1128 |
|
|
1129 |
|
|
1130 |
1 |
features = store.getFeaturesForGroup(false, null, "Pfam", "Xfam"); |
1131 |
1 |
assertEquals(features.size(), 1); |
1132 |
1 |
assertTrue(features.contains(sf2)); |
1133 |
1 |
assertTrue(store.getFeaturesForGroup(false, null, "Cath").isEmpty()); |
1134 |
|
|
1135 |
|
|
1136 |
1 |
features = store.getFeaturesForGroup(false, "Rfam"); |
1137 |
1 |
assertEquals(features.size(), 1); |
1138 |
1 |
assertTrue(features.contains(sf4)); |
1139 |
1 |
assertTrue(store.getFeaturesForGroup(false, "Uniprot").isEmpty()); |
1140 |
|
|
1141 |
|
|
1142 |
1 |
features = store.getFeaturesForGroup(false, "Rfam", "Pfam", "Metal"); |
1143 |
1 |
assertEquals(features.size(), 1); |
1144 |
1 |
assertTrue(features.contains(sf4)); |
1145 |
1 |
assertTrue(store.getFeaturesForGroup(false, "Rfam", "Cath", "Pfam") |
1146 |
|
.isEmpty()); |
1147 |
|
} |
1148 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (39) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
1149 |
1 |
@Test(groups = "Functional")... |
1150 |
|
public void testShiftFeatures() |
1151 |
|
{ |
1152 |
1 |
SequenceFeatures store = new SequenceFeatures(); |
1153 |
1 |
assertFalse(store.shiftFeatures(1)); |
1154 |
|
|
1155 |
1 |
SequenceFeature sf1 = new SequenceFeature("Cath", "", 2, 5, 0f, null); |
1156 |
1 |
store.add(sf1); |
1157 |
|
|
1158 |
1 |
SequenceFeature sf2 = new SequenceFeature("Metal", "", 8, 14, 0f, null); |
1159 |
1 |
store.add(sf2); |
1160 |
|
|
1161 |
1 |
SequenceFeature sf3 = new SequenceFeature("Disulfide bond", "", 23, 32, |
1162 |
|
0f, null); |
1163 |
1 |
store.add(sf3); |
1164 |
|
|
1165 |
1 |
SequenceFeature sf4 = new SequenceFeature("Pfam", "", 0, 0, 0f, null); |
1166 |
1 |
store.add(sf4); |
1167 |
|
|
1168 |
|
|
1169 |
|
|
1170 |
|
|
1171 |
1 |
assertTrue(store.shiftFeatures(5)); |
1172 |
|
|
1173 |
|
|
1174 |
1 |
List<SequenceFeature> nonPos = store.getNonPositionalFeatures(); |
1175 |
1 |
assertEquals(nonPos.size(), 1); |
1176 |
1 |
assertTrue(nonPos.contains(sf4)); |
1177 |
|
|
1178 |
|
|
1179 |
1 |
List<SequenceFeature> pos = store.getPositionalFeatures(); |
1180 |
1 |
assertEquals(pos.size(), 3); |
1181 |
1 |
assertFalse(pos.contains(sf1)); |
1182 |
1 |
assertFalse(pos.contains(sf2)); |
1183 |
1 |
assertFalse(pos.contains(sf3)); |
1184 |
1 |
SequenceFeatures.sortFeatures(pos, true); |
1185 |
1 |
assertEquals(pos.get(0).getBegin(), 7); |
1186 |
1 |
assertEquals(pos.get(0).getEnd(), 10); |
1187 |
1 |
assertEquals(pos.get(0).getType(), "Cath"); |
1188 |
1 |
assertEquals(pos.get(1).getBegin(), 13); |
1189 |
1 |
assertEquals(pos.get(1).getEnd(), 19); |
1190 |
1 |
assertEquals(pos.get(1).getType(), "Metal"); |
1191 |
1 |
assertEquals(pos.get(2).getBegin(), 28); |
1192 |
1 |
assertEquals(pos.get(2).getEnd(), 37); |
1193 |
1 |
assertEquals(pos.get(2).getType(), "Disulfide bond"); |
1194 |
|
|
1195 |
|
|
1196 |
|
|
1197 |
|
|
1198 |
|
|
1199 |
|
|
1200 |
1 |
assertTrue(store.shiftFeatures(-15)); |
1201 |
1 |
pos = store.getPositionalFeatures(); |
1202 |
1 |
assertEquals(pos.size(), 2); |
1203 |
1 |
SequenceFeatures.sortFeatures(pos, true); |
1204 |
1 |
assertEquals(pos.get(0).getBegin(), 1); |
1205 |
1 |
assertEquals(pos.get(0).getEnd(), 4); |
1206 |
1 |
assertEquals(pos.get(0).getType(), "Metal"); |
1207 |
1 |
assertEquals(pos.get(1).getBegin(), 13); |
1208 |
1 |
assertEquals(pos.get(1).getEnd(), 22); |
1209 |
1 |
assertEquals(pos.get(1).getType(), "Disulfide bond"); |
1210 |
|
} |
1211 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 1 |
Complexity Density: 0.12 |
1PASS
|
|
1212 |
1 |
@Test(groups = "Functional")... |
1213 |
|
public void testIsOntologyTerm() |
1214 |
|
{ |
1215 |
1 |
SequenceFeatures store = new SequenceFeatures(); |
1216 |
1 |
assertTrue(store.isOntologyTerm("gobbledygook")); |
1217 |
1 |
assertTrue(store.isOntologyTerm("transcript", "transcript")); |
1218 |
1 |
assertTrue(store.isOntologyTerm("mRNA", "transcript")); |
1219 |
1 |
assertFalse(store.isOntologyTerm("transcript", "mRNA")); |
1220 |
1 |
assertTrue(store.isOntologyTerm("junk", "transcript", "junk")); |
1221 |
1 |
assertTrue(store.isOntologyTerm("junk", new String[] {})); |
1222 |
1 |
assertTrue(store.isOntologyTerm("junk", (String[]) null)); |
1223 |
|
} |
1224 |
|
} |