1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
|
|
19 |
|
|
20 |
|
|
21 |
|
package jalview.datamodel; |
22 |
|
|
23 |
|
import static org.testng.AssertJUnit.assertEquals; |
24 |
|
import static org.testng.AssertJUnit.assertFalse; |
25 |
|
import static org.testng.AssertJUnit.assertNotNull; |
26 |
|
import static org.testng.AssertJUnit.assertNull; |
27 |
|
import static org.testng.AssertJUnit.assertSame; |
28 |
|
import static org.testng.AssertJUnit.assertTrue; |
29 |
|
|
30 |
|
import java.io.IOException; |
31 |
|
import java.util.Arrays; |
32 |
|
import java.util.Iterator; |
33 |
|
import java.util.List; |
34 |
|
|
35 |
|
import org.testng.Assert; |
36 |
|
import org.testng.annotations.BeforeClass; |
37 |
|
import org.testng.annotations.BeforeMethod; |
38 |
|
import org.testng.annotations.Test; |
39 |
|
|
40 |
|
import jalview.analysis.AlignmentGenerator; |
41 |
|
import jalview.analysis.AlignmentUtils; |
42 |
|
import jalview.analysis.CrossRef; |
43 |
|
import jalview.datamodel.AlignedCodonFrame.SequenceToSequenceMapping; |
44 |
|
import jalview.gui.JvOptionPane; |
45 |
|
import jalview.io.DataSourceType; |
46 |
|
import jalview.io.FastaFile; |
47 |
|
import jalview.io.FileFormat; |
48 |
|
import jalview.io.FileFormatI; |
49 |
|
import jalview.io.FormatAdapter; |
50 |
|
import jalview.util.Comparison; |
51 |
|
import jalview.util.MapList; |
52 |
|
|
53 |
|
|
54 |
|
|
55 |
|
|
56 |
|
@author |
57 |
|
|
58 |
|
|
|
|
| 89% |
Uncovered Elements: 84 (766) |
Complexity: 98 |
Complexity Density: 0.16 |
|
59 |
|
public class AlignmentTest |
60 |
|
{ |
61 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
62 |
1 |
@BeforeClass(alwaysRun = true)... |
63 |
|
public void setUpJvOptionPane() |
64 |
|
{ |
65 |
1 |
JvOptionPane.setInteractiveMode(false); |
66 |
1 |
JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); |
67 |
|
} |
68 |
|
|
69 |
|
|
70 |
|
private static final String TEST_DATA = |
71 |
|
"# STOCKHOLM 1.0\n" + |
72 |
|
"#=GS D.melanogaster.1 AC AY119185.1/838-902\n" + |
73 |
|
"#=GS D.melanogaster.2 AC AC092237.1/57223-57161\n" + |
74 |
|
"#=GS D.melanogaster.3 AC AY060611.1/560-627\n" + |
75 |
|
"D.melanogaster.1 G.AGCC.CU...AUGAUCGA\n" + |
76 |
|
"#=GR D.melanogaster.1 SS ................((((\n" + |
77 |
|
"D.melanogaster.2 C.AUUCAACU.UAUGAGGAU\n" + |
78 |
|
"#=GR D.melanogaster.2 SS ................((((\n" + |
79 |
|
"D.melanogaster.3 G.UGGCGCU..UAUGACGCA\n" + |
80 |
|
"#=GR D.melanogaster.3 SS (.(((...(....(((((((\n" + |
81 |
|
"//"; |
82 |
|
|
83 |
|
private static final String AA_SEQS_1 = |
84 |
|
">Seq1Name/5-8\n" + |
85 |
|
"K-QY--L\n" + |
86 |
|
">Seq2Name/12-15\n" + |
87 |
|
"-R-FP-W-\n"; |
88 |
|
|
89 |
|
private static final String CDNA_SEQS_1 = |
90 |
|
">Seq1Name/100-111\n" + |
91 |
|
"AC-GG--CUC-CAA-CT\n" + |
92 |
|
">Seq2Name/200-211\n" + |
93 |
|
"-CG-TTA--ACG---AAGT\n"; |
94 |
|
|
95 |
|
private static final String CDNA_SEQS_2 = |
96 |
|
">Seq1Name/50-61\n" + |
97 |
|
"GCTCGUCGTACT\n" + |
98 |
|
">Seq2Name/60-71\n" + |
99 |
|
"GGGTCAGGCAGT\n"; |
100 |
|
|
101 |
|
private static final String AA_SEQS_2 = |
102 |
|
">Seq1Name/5-8\n" + |
103 |
|
"K-QY-L\n" + |
104 |
|
">Seq2Name/12-15\n" + |
105 |
|
"-R-FPW\n"; |
106 |
|
private static final String AA_SEQS_2_DS = |
107 |
|
">Seq1Name/5-8\n" + |
108 |
|
"KQYL\n" + |
109 |
|
">Seq2Name/12-15\n" + |
110 |
|
"RFPW\n"; |
111 |
|
private static final String TD_SEQS_2_DS = |
112 |
|
">Seq1Name/5-8\n" + |
113 |
|
"NMPR\n" + |
114 |
|
">Seq2Name/12-15\n" + |
115 |
|
"VXYA\n"; |
116 |
|
private static final String TD_SEQS_2 = |
117 |
|
">Seq1Name/5-8\n" + |
118 |
|
"-NMP-R\n" + |
119 |
|
">Seq2Name/12-15\n" + |
120 |
|
"VX--YA\n"; |
121 |
|
|
122 |
|
|
123 |
|
|
124 |
|
private AlignmentI al; |
125 |
|
|
126 |
|
|
127 |
|
|
128 |
|
|
129 |
|
@param |
130 |
|
@param |
131 |
|
|
132 |
|
@return |
133 |
|
@throws |
134 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0.33 |
|
135 |
53 |
protected AlignmentI loadAlignment(final String data, FileFormatI format)... |
136 |
|
throws IOException |
137 |
|
{ |
138 |
53 |
AlignmentI a = new FormatAdapter().readFile(data, DataSourceType.PASTE, |
139 |
|
format); |
140 |
53 |
a.setDataset(null); |
141 |
53 |
return a; |
142 |
|
} |
143 |
|
|
144 |
|
|
145 |
|
|
146 |
|
|
147 |
|
@param |
148 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
149 |
0 |
public static void assertAlignmentDatasetRefs(AlignmentI alignment)... |
150 |
|
{ |
151 |
0 |
verifyAlignmentDatasetRefs(alignment, true, null); |
152 |
|
} |
153 |
|
|
154 |
|
|
155 |
|
|
156 |
|
|
157 |
|
@param |
158 |
|
@param |
159 |
|
|
160 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
161 |
1 |
public static void assertAlignmentDatasetRefs(AlignmentI alignment,... |
162 |
|
String message) |
163 |
|
{ |
164 |
1 |
verifyAlignmentDatasetRefs(alignment, true, message); |
165 |
|
} |
166 |
|
|
167 |
|
|
168 |
|
|
169 |
|
|
170 |
|
|
171 |
|
@param |
172 |
|
|
173 |
|
@param |
174 |
|
|
175 |
|
@param |
176 |
|
|
177 |
|
|
178 |
|
@return |
179 |
|
|
|
|
| 62.5% |
Uncovered Elements: 45 (120) |
Complexity: 29 |
Complexity Density: 0.45 |
|
180 |
44 |
public static boolean verifyAlignmentDatasetRefs(AlignmentI alignment,... |
181 |
|
boolean raiseAssert, String message) |
182 |
|
{ |
183 |
44 |
if (message == null) |
184 |
|
{ |
185 |
24 |
message = ""; |
186 |
|
} |
187 |
44 |
if (alignment == null) |
188 |
|
{ |
189 |
0 |
if (raiseAssert) |
190 |
|
{ |
191 |
0 |
Assert.fail(message + "Alignment for verification was null."); |
192 |
|
} |
193 |
0 |
return false; |
194 |
|
} |
195 |
44 |
if (alignment.getDataset() != null) |
196 |
|
{ |
197 |
19 |
AlignmentI dataset = alignment.getDataset(); |
198 |
|
|
199 |
19 |
for (SequenceI seq : alignment.getSequences()) |
200 |
|
{ |
201 |
39 |
SequenceI seqds = seq.getDatasetSequence(); |
202 |
39 |
if (seqds.getDatasetSequence() != null) |
203 |
|
{ |
204 |
0 |
if (raiseAssert) |
205 |
|
{ |
206 |
0 |
Assert.fail(message |
207 |
|
+ " Alignment contained a sequence who's dataset sequence has a second dataset reference."); |
208 |
|
} |
209 |
0 |
return false; |
210 |
|
} |
211 |
39 |
if (dataset.findIndex(seqds) == -1) |
212 |
|
{ |
213 |
0 |
if (raiseAssert) |
214 |
|
{ |
215 |
0 |
Assert.fail(message |
216 |
|
+ " Alignment contained a sequence who's dataset sequence was not in the dataset."); |
217 |
|
} |
218 |
0 |
return false; |
219 |
|
} |
220 |
|
} |
221 |
19 |
return verifyAlignmentDatasetRefs(alignment.getDataset(), raiseAssert, |
222 |
|
message); |
223 |
|
} |
224 |
|
else |
225 |
|
{ |
226 |
25 |
int dsp = -1; |
227 |
|
|
228 |
25 |
for (SequenceI seqds : alignment.getSequences()) |
229 |
|
{ |
230 |
80 |
dsp++; |
231 |
80 |
if (seqds.getDatasetSequence() != null) |
232 |
|
{ |
233 |
2 |
if (raiseAssert) |
234 |
|
{ |
235 |
1 |
Assert.fail(message |
236 |
|
+ " Dataset contained a sequence with non-null dataset reference (ie not a dataset sequence!)"); |
237 |
|
} |
238 |
1 |
return false; |
239 |
|
} |
240 |
78 |
int foundp = alignment.findIndex(seqds); |
241 |
78 |
if (foundp != dsp) |
242 |
|
{ |
243 |
2 |
if (raiseAssert) |
244 |
|
{ |
245 |
1 |
Assert.fail(message |
246 |
|
+ " Dataset sequence array contains a reference at " |
247 |
|
+ dsp + " to a sequence first seen at " + foundp + " (" |
248 |
|
+ seqds.toString() + ")"); |
249 |
|
} |
250 |
1 |
return false; |
251 |
|
} |
252 |
76 |
if (seqds.getDBRefs() != null) |
253 |
|
{ |
254 |
28 |
for (DBRefEntry dbr : seqds.getDBRefs()) |
255 |
|
{ |
256 |
28 |
if (dbr.getMap() != null) |
257 |
|
{ |
258 |
28 |
SequenceI seqdbrmapto = dbr.getMap().getTo(); |
259 |
28 |
if (seqdbrmapto != null) |
260 |
|
{ |
261 |
28 |
if (seqdbrmapto.getDatasetSequence() != null) |
262 |
|
{ |
263 |
0 |
if (raiseAssert) |
264 |
|
{ |
265 |
0 |
Assert.fail(message |
266 |
|
+ " DBRefEntry for sequence in alignment had map to sequence which was not a dataset sequence"); |
267 |
|
} |
268 |
0 |
return false; |
269 |
|
|
270 |
|
} |
271 |
28 |
if (alignment.findIndex(dbr.getMap().getTo()) == -1) |
272 |
|
{ |
273 |
2 |
if (raiseAssert) |
274 |
|
{ |
275 |
1 |
Assert.fail(message + " DBRefEntry " + dbr |
276 |
|
+ " for sequence " + seqds |
277 |
|
+ " in alignment has map to sequence not in dataset"); |
278 |
|
} |
279 |
1 |
return false; |
280 |
|
} |
281 |
|
} |
282 |
|
} |
283 |
|
} |
284 |
|
} |
285 |
|
} |
286 |
|
|
287 |
19 |
if (alignment.getCodonFrames() != null) |
288 |
|
{ |
289 |
19 |
for (AlignedCodonFrame alc : alignment.getCodonFrames()) |
290 |
|
{ |
291 |
6 |
for (SequenceToSequenceMapping ssm : alc.getMappings()) |
292 |
|
{ |
293 |
6 |
if (ssm.getFromSeq().getDatasetSequence() != null) |
294 |
|
{ |
295 |
0 |
if (raiseAssert) |
296 |
|
{ |
297 |
0 |
Assert.fail(message |
298 |
|
+ " CodonFrame-SSM-FromSeq is not a dataset sequence"); |
299 |
|
} |
300 |
0 |
return false; |
301 |
|
} |
302 |
6 |
if (alignment.findIndex(ssm.getFromSeq()) == -1) |
303 |
|
{ |
304 |
|
|
305 |
2 |
if (raiseAssert) |
306 |
|
{ |
307 |
1 |
Assert.fail(message |
308 |
|
+ " CodonFrame-SSM-FromSeq is not contained in dataset"); |
309 |
|
} |
310 |
1 |
return false; |
311 |
|
} |
312 |
4 |
if (ssm.getMapping().getTo().getDatasetSequence() != null) |
313 |
|
{ |
314 |
0 |
if (raiseAssert) |
315 |
|
{ |
316 |
0 |
Assert.fail(message |
317 |
|
+ " CodonFrame-SSM-Mapping-ToSeq is not a dataset sequence"); |
318 |
|
} |
319 |
0 |
return false; |
320 |
|
} |
321 |
4 |
if (alignment.findIndex(ssm.getMapping().getTo()) == -1) |
322 |
|
{ |
323 |
|
|
324 |
0 |
if (raiseAssert) |
325 |
|
{ |
326 |
0 |
Assert.fail(message |
327 |
|
+ " CodonFrame-SSM-Mapping-ToSeq is not contained in dataset"); |
328 |
|
} |
329 |
0 |
return false; |
330 |
|
} |
331 |
|
} |
332 |
|
} |
333 |
|
} |
334 |
|
} |
335 |
17 |
return true; |
336 |
|
} |
337 |
|
|
338 |
|
|
339 |
|
|
340 |
|
|
341 |
|
|
342 |
|
@param |
343 |
|
@param |
344 |
|
@param |
345 |
|
|
|
|
| 76.5% |
Uncovered Elements: 4 (17) |
Complexity: 5 |
Complexity Density: 0.38 |
|
346 |
12 |
private void assertVerifyAlignment(AlignmentI al, boolean expected,... |
347 |
|
String msg) |
348 |
|
{ |
349 |
12 |
if (expected) |
350 |
|
{ |
351 |
8 |
try |
352 |
|
{ |
353 |
|
|
354 |
8 |
Assert.assertTrue(verifyAlignmentDatasetRefs(al, true, null), |
355 |
|
"Valid test alignment failed when raiseAsserts enabled:" |
356 |
|
+ msg); |
357 |
|
} catch (AssertionError ae) |
358 |
|
{ |
359 |
0 |
ae.printStackTrace(); |
360 |
0 |
Assert.fail( |
361 |
|
"Valid test alignment raised assertion errors when raiseAsserts enabled: " |
362 |
|
+ msg, |
363 |
|
ae); |
364 |
|
} |
365 |
|
|
366 |
8 |
Assert.assertTrue(verifyAlignmentDatasetRefs(al, false, null), |
367 |
|
"Valid test alignment tested false when raiseAsserts disabled:" |
368 |
|
+ msg); |
369 |
|
} |
370 |
|
else |
371 |
|
{ |
372 |
4 |
boolean assertRaised = false; |
373 |
4 |
try |
374 |
|
{ |
375 |
4 |
verifyAlignmentDatasetRefs(al, true, null); |
376 |
|
} catch (AssertionError ae) |
377 |
|
{ |
378 |
|
|
379 |
4 |
assertRaised = true; |
380 |
|
} |
381 |
4 |
if (!assertRaised) |
382 |
|
{ |
383 |
0 |
Assert.fail( |
384 |
|
"Invalid test alignment passed when raiseAsserts enabled:" |
385 |
|
+ msg); |
386 |
|
} |
387 |
|
|
388 |
4 |
Assert.assertFalse(verifyAlignmentDatasetRefs(al, false, null), |
389 |
|
"Invalid test alignment tested true when raiseAsserts disabled:" |
390 |
|
+ msg); |
391 |
|
} |
392 |
|
} |
393 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (35) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
394 |
1 |
@Test(groups = { "Functional" })... |
395 |
|
public void testVerifyAlignmentDatasetRefs() |
396 |
|
{ |
397 |
1 |
SequenceI sq1 = new Sequence("sq1", "ASFDD"), |
398 |
|
sq2 = new Sequence("sq2", "TTTTTT"); |
399 |
|
|
400 |
|
|
401 |
1 |
Alignment al = new Alignment(new SequenceI[] { sq1, sq2 }); |
402 |
|
|
403 |
1 |
assertVerifyAlignment(al, true, "Simple valid alignment didn't verify"); |
404 |
|
|
405 |
|
|
406 |
1 |
sq1.setDatasetSequence(sq2); |
407 |
1 |
assertVerifyAlignment(al, false, |
408 |
|
"didn't detect dataset sequence with a dataset sequence reference."); |
409 |
|
|
410 |
1 |
sq1.setDatasetSequence(null); |
411 |
1 |
assertVerifyAlignment(al, true, |
412 |
|
"didn't reinstate validity after nulling dataset sequence dataset reference"); |
413 |
|
|
414 |
|
|
415 |
1 |
al.createDatasetAlignment(); |
416 |
1 |
assertNotNull(al.getDataset()); |
417 |
|
|
418 |
1 |
assertVerifyAlignment(al, true, |
419 |
|
"verify failed after createDatasetAlignment"); |
420 |
|
|
421 |
|
|
422 |
1 |
DBRefEntry dbrs1tos2 = new DBRefEntry("UNIPROT", "1", "Q111111"); |
423 |
1 |
dbrs1tos2 |
424 |
|
.setMap(new Mapping(sq2.getDatasetSequence(), new int[] |
425 |
|
{ 1, 5 }, new int[] { 2, 6 }, 1, 1)); |
426 |
1 |
sq1.getDatasetSequence().addDBRef(dbrs1tos2); |
427 |
1 |
assertVerifyAlignment(al, true, |
428 |
|
"verify failed after addition of valid DBRefEntry/map"); |
429 |
|
|
430 |
|
|
431 |
1 |
SequenceI sqout = new Sequence("sqout", "ututututucagcagcag"), |
432 |
|
sqnew = new Sequence("sqnew", "EEERRR"); |
433 |
1 |
DBRefEntry sqnewsqout = new DBRefEntry("ENAFOO", "1", "R000001"); |
434 |
1 |
sqnewsqout |
435 |
|
.setMap(new Mapping(sqout, new int[] |
436 |
|
{ 1, 6 }, new int[] { 1, 18 }, 1, 3)); |
437 |
1 |
al.getDataset().addSequence(sqnew); |
438 |
|
|
439 |
1 |
assertVerifyAlignment(al, true, |
440 |
|
"verify failed after addition of new sequence to dataset"); |
441 |
|
|
442 |
1 |
sqnew.addDBRef(sqnewsqout); |
443 |
1 |
assertVerifyAlignment(al, false, |
444 |
|
"verify passed when a dbref with map to sequence outside of dataset was added"); |
445 |
|
|
446 |
1 |
al.getDataset().addSequence(sqout); |
447 |
1 |
assertVerifyAlignment(al, true, |
448 |
|
"verify should have passed after adding dbref->to sequence in to dataset"); |
449 |
|
|
450 |
1 |
SequenceI sqanotherout = new Sequence("sqanotherout", |
451 |
|
"aggtutaggcagcagcag"); |
452 |
|
|
453 |
1 |
AlignedCodonFrame alc = new AlignedCodonFrame(); |
454 |
1 |
alc.addMap(sqanotherout, sqnew, |
455 |
|
new MapList(new int[] |
456 |
|
{ 1, 6 }, new int[] { 1, 18 }, 3, 1)); |
457 |
|
|
458 |
1 |
al.addCodonFrame(alc); |
459 |
1 |
Assert.assertEquals(al.getDataset().getCodonFrames().size(), 1); |
460 |
|
|
461 |
1 |
assertVerifyAlignment(al, false, |
462 |
|
"verify passed when alCodonFrame mapping to sequence outside of dataset was added"); |
463 |
|
|
464 |
1 |
al.getDataset().addSequence(sqanotherout); |
465 |
1 |
assertVerifyAlignment(al, true, |
466 |
|
"verify should have passed once all sequences involved in alCodonFrame were added to dataset"); |
467 |
1 |
al.getDataset().addSequence(sqanotherout); |
468 |
1 |
assertVerifyAlignment(al, false, |
469 |
|
"verify should have failed when a sequence was added twice to the dataset"); |
470 |
1 |
al.getDataset().deleteSequence(sqanotherout); |
471 |
1 |
assertVerifyAlignment(al, true, |
472 |
|
"verify should have passed after duplicate entry for sequence was removed"); |
473 |
|
} |
474 |
|
|
475 |
|
|
476 |
|
|
477 |
|
|
478 |
|
|
479 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
480 |
6 |
public static void assertDatasetIsNormalised(AlignmentI al)... |
481 |
|
{ |
482 |
6 |
assertDatasetIsNormalised(al, null); |
483 |
|
} |
484 |
|
|
485 |
|
|
486 |
|
|
487 |
|
|
488 |
|
|
489 |
|
@param |
490 |
|
|
491 |
|
@param |
492 |
|
|
493 |
|
|
|
|
| 90.9% |
Uncovered Elements: 3 (33) |
Complexity: 9 |
Complexity Density: 0.53 |
|
494 |
12 |
public static void assertDatasetIsNormalised(AlignmentI al,... |
495 |
|
String message) |
496 |
|
{ |
497 |
12 |
if (al.getDataset() != null) |
498 |
|
{ |
499 |
6 |
assertDatasetIsNormalised(al.getDataset(), message); |
500 |
5 |
return; |
501 |
|
} |
502 |
|
|
503 |
|
|
504 |
|
|
505 |
6 |
List<SequenceI> seqSet = al.getSequences(); |
506 |
18 |
for (int p = 0; p < seqSet.size(); p++) |
507 |
|
{ |
508 |
13 |
SequenceI pSeq = seqSet.get(p); |
509 |
27 |
for (int q = p + 1; q < seqSet.size(); q++) |
510 |
|
{ |
511 |
15 |
SequenceI qSeq = seqSet.get(q); |
512 |
15 |
if (pSeq.getStart() != qSeq.getStart()) |
513 |
|
{ |
514 |
4 |
continue; |
515 |
|
} |
516 |
11 |
if (pSeq.getEnd() != qSeq.getEnd()) |
517 |
|
{ |
518 |
0 |
continue; |
519 |
|
} |
520 |
11 |
if (!pSeq.getName().equals(qSeq.getName())) |
521 |
|
{ |
522 |
7 |
continue; |
523 |
|
} |
524 |
4 |
if (!Arrays.equals(pSeq.getSequence(), qSeq.getSequence())) |
525 |
|
{ |
526 |
3 |
continue; |
527 |
|
} |
528 |
1 |
Assert.fail((message == null ? "" : message + " :") |
529 |
|
+ "Found similar sequences at position " + p + " and " + q |
530 |
|
+ "\n" + pSeq.toString()); |
531 |
|
} |
532 |
|
} |
533 |
|
} |
534 |
|
|
|
|
| 80% |
Uncovered Elements: 7 (35) |
Complexity: 8 |
Complexity Density: 0.24 |
1PASS
|
|
535 |
1 |
@Test(groups = { "Functional", "Asserts" })... |
536 |
|
public void testAssertDatasetIsNormalised() |
537 |
|
{ |
538 |
1 |
Sequence sq1 = new Sequence("s1/1-4", "asdf"); |
539 |
1 |
Sequence sq1shift = new Sequence("s1/2-5", "asdf"); |
540 |
1 |
Sequence sq1seqd = new Sequence("s1/1-4", "asdt"); |
541 |
1 |
Sequence sq2 = new Sequence("s2/1-4", "asdf"); |
542 |
1 |
Sequence sq1dup = new Sequence("s1/1-4", "asdf"); |
543 |
|
|
544 |
1 |
Alignment al = new Alignment(new SequenceI[] { sq1 }); |
545 |
1 |
al.setDataset(null); |
546 |
|
|
547 |
1 |
try |
548 |
|
{ |
549 |
1 |
assertDatasetIsNormalised(al); |
550 |
|
} catch (AssertionError ae) |
551 |
|
{ |
552 |
0 |
Assert.fail("Single sequence should be valid normalised dataset."); |
553 |
|
} |
554 |
1 |
al.addSequence(sq2); |
555 |
1 |
try |
556 |
|
{ |
557 |
1 |
assertDatasetIsNormalised(al); |
558 |
|
} catch (AssertionError ae) |
559 |
|
{ |
560 |
0 |
Assert.fail( |
561 |
|
"Two different sequences should be valid normalised dataset."); |
562 |
|
} |
563 |
|
|
564 |
|
|
565 |
|
|
566 |
1 |
al.findName(sq2.getName()).setName("sq1"); |
567 |
1 |
try |
568 |
|
{ |
569 |
1 |
assertDatasetIsNormalised(al); |
570 |
|
} catch (AssertionError ae) |
571 |
|
{ |
572 |
0 |
Assert.fail( |
573 |
|
"Two different sequences in dataset, but same name in alignment, should be valid normalised dataset."); |
574 |
|
} |
575 |
|
|
576 |
1 |
al.addSequence(sq1seqd); |
577 |
1 |
try |
578 |
|
{ |
579 |
1 |
assertDatasetIsNormalised(al); |
580 |
|
} catch (AssertionError ae) |
581 |
|
{ |
582 |
0 |
Assert.fail( |
583 |
|
"sq1 and sq1 with different sequence should be distinct."); |
584 |
|
} |
585 |
|
|
586 |
1 |
al.addSequence(sq1shift); |
587 |
1 |
try |
588 |
|
{ |
589 |
1 |
assertDatasetIsNormalised(al); |
590 |
|
} catch (AssertionError ae) |
591 |
|
{ |
592 |
0 |
Assert.fail( |
593 |
|
"sq1 and sq1 with different start/end should be distinct."); |
594 |
|
} |
595 |
|
|
596 |
|
|
597 |
|
|
598 |
1 |
al.addSequence(sq1dup); |
599 |
1 |
boolean ssertRaised = false; |
600 |
1 |
try |
601 |
|
{ |
602 |
1 |
assertDatasetIsNormalised(al); |
603 |
|
|
604 |
|
} catch (AssertionError ae) |
605 |
|
{ |
606 |
1 |
ssertRaised = true; |
607 |
|
} |
608 |
1 |
if (!ssertRaised) |
609 |
|
{ |
610 |
0 |
Assert.fail("Expected identical sequence to raise exception."); |
611 |
|
} |
612 |
|
} |
613 |
|
|
614 |
|
|
615 |
|
|
616 |
|
|
617 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (5) |
Complexity: 1 |
Complexity Density: 0.2 |
|
618 |
34 |
@BeforeMethod(alwaysRun = true)... |
619 |
|
public void setUp() throws IOException |
620 |
|
{ |
621 |
34 |
al = loadAlignment(TEST_DATA, FileFormat.Stockholm); |
622 |
34 |
int i = 0; |
623 |
34 |
for (AlignmentAnnotation ann : al.getAlignmentAnnotation()) |
624 |
|
{ |
625 |
102 |
ann.setCalcId("CalcIdFor" + al.getSequenceAt(i).getName()); |
626 |
102 |
i++; |
627 |
|
} |
628 |
|
} |
629 |
|
|
630 |
|
|
631 |
|
|
632 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (10) |
Complexity: 1 |
Complexity Density: 0.1 |
1PASS
|
|
633 |
1 |
@Test(groups = { "Functional" })... |
634 |
|
public void testFindAnnotation_byCalcId() |
635 |
|
{ |
636 |
1 |
Iterable<AlignmentAnnotation> anns = al |
637 |
|
.findAnnotation("CalcIdForD.melanogaster.2"); |
638 |
1 |
Iterator<AlignmentAnnotation> iter = anns.iterator(); |
639 |
1 |
assertTrue(iter.hasNext()); |
640 |
1 |
AlignmentAnnotation ann = iter.next(); |
641 |
1 |
assertEquals("D.melanogaster.2", ann.sequenceRef.getName()); |
642 |
1 |
assertFalse(iter.hasNext()); |
643 |
|
|
644 |
|
|
645 |
1 |
anns = al.findAnnotation("CalcIdForD.melanogaster.?"); |
646 |
1 |
assertFalse(iter.hasNext()); |
647 |
1 |
anns = al.findAnnotation(null); |
648 |
1 |
assertFalse(iter.hasNext()); |
649 |
|
} |
650 |
|
|
651 |
|
|
652 |
|
|
653 |
|
|
654 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (40) |
Complexity: 2 |
Complexity Density: 0.05 |
1PASS
|
|
655 |
1 |
@Test(groups = { "Functional" })... |
656 |
|
public void testFindAnnotations_bySeqLabelandorCalcId() |
657 |
|
{ |
658 |
|
|
659 |
|
|
660 |
|
|
661 |
|
|
662 |
|
|
663 |
|
|
664 |
1 |
Iterable<AlignmentAnnotation> anns = al.findAnnotations(null, |
665 |
|
"CalcIdForD.melanogaster.2", null); |
666 |
1 |
Iterator<AlignmentAnnotation> iter = anns.iterator(); |
667 |
1 |
assertTrue(iter.hasNext()); |
668 |
1 |
AlignmentAnnotation ann = iter.next(); |
669 |
1 |
assertEquals("D.melanogaster.2", ann.sequenceRef.getName()); |
670 |
1 |
assertFalse(iter.hasNext()); |
671 |
|
|
672 |
|
|
673 |
1 |
SequenceI rseq = ann.sequenceRef; |
674 |
|
|
675 |
|
|
676 |
1 |
anns = al.findAnnotations(rseq, null, null); |
677 |
1 |
iter = anns.iterator(); |
678 |
1 |
assertTrue(iter.hasNext()); |
679 |
1 |
ann = iter.next(); |
680 |
1 |
assertEquals("D.melanogaster.2", ann.sequenceRef.getName()); |
681 |
1 |
assertFalse(iter.hasNext()); |
682 |
|
|
683 |
|
|
684 |
1 |
anns = al.findAnnotations(null, "CalcIdForD.melanogaster.?", null); |
685 |
1 |
iter = anns.iterator(); |
686 |
1 |
assertFalse(iter.hasNext()); |
687 |
|
|
688 |
|
|
689 |
1 |
anns = al.findAnnotations(null, null, "Secondary Structure"); |
690 |
1 |
iter = anns.iterator(); |
691 |
1 |
assertTrue(iter.hasNext()); |
692 |
1 |
iter.next(); |
693 |
1 |
assertTrue(iter.hasNext()); |
694 |
1 |
iter.next(); |
695 |
1 |
assertTrue(iter.hasNext()); |
696 |
1 |
iter.next(); |
697 |
|
|
698 |
1 |
assertFalse(iter.hasNext()); |
699 |
|
|
700 |
|
|
701 |
|
|
702 |
1 |
SequenceI sqfound; |
703 |
1 |
anns = al.findAnnotations(sqfound = al.getSequenceAt(1), null, |
704 |
|
"Secondary Structure"); |
705 |
1 |
iter = anns.iterator(); |
706 |
1 |
assertTrue(iter.hasNext()); |
707 |
|
|
708 |
1 |
assertTrue(sqfound == iter.next().sequenceRef); |
709 |
1 |
assertFalse(iter.hasNext()); |
710 |
|
|
711 |
|
|
712 |
1 |
anns = al.findAnnotations(null, null, null); |
713 |
1 |
iter = anns.iterator(); |
714 |
1 |
int n = al.getAlignmentAnnotation().length; |
715 |
4 |
while (iter.hasNext()) |
716 |
|
{ |
717 |
3 |
n--; |
718 |
3 |
iter.next(); |
719 |
|
} |
720 |
1 |
assertTrue("Found " + n + " fewer annotations from search.", n == 0); |
721 |
|
} |
722 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0.14 |
1PASS
|
|
723 |
1 |
@Test(groups = { "Functional" })... |
724 |
|
public void testDeleteAllAnnotations_includingAutocalculated() |
725 |
|
{ |
726 |
1 |
AlignmentAnnotation aa = new AlignmentAnnotation("Consensus", |
727 |
|
"Consensus", 0.5); |
728 |
1 |
aa.autoCalculated = true; |
729 |
1 |
al.addAnnotation(aa); |
730 |
1 |
AlignmentAnnotation[] anns = al.getAlignmentAnnotation(); |
731 |
1 |
assertEquals("Wrong number of annotations before deleting", 4, |
732 |
|
anns.length); |
733 |
1 |
al.deleteAllAnnotations(true); |
734 |
1 |
assertEquals("Not all deleted", 0, al.getAlignmentAnnotation().length); |
735 |
|
} |
736 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0.14 |
1PASS
|
|
737 |
1 |
@Test(groups = { "Functional" })... |
738 |
|
public void testDeleteAllAnnotations_excludingAutocalculated() |
739 |
|
{ |
740 |
1 |
AlignmentAnnotation aa = new AlignmentAnnotation("Consensus", |
741 |
|
"Consensus", 0.5); |
742 |
1 |
aa.autoCalculated = true; |
743 |
1 |
al.addAnnotation(aa); |
744 |
1 |
AlignmentAnnotation[] anns = al.getAlignmentAnnotation(); |
745 |
1 |
assertEquals("Wrong number of annotations before deleting", 4, |
746 |
|
anns.length); |
747 |
1 |
al.deleteAllAnnotations(false); |
748 |
1 |
assertEquals("Not just one annotation left", 1, |
749 |
|
al.getAlignmentAnnotation().length); |
750 |
|
} |
751 |
|
|
752 |
|
|
753 |
|
|
754 |
|
|
755 |
|
|
756 |
|
|
757 |
|
|
758 |
|
|
759 |
|
@throws |
760 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0.17 |
1PASS
|
|
761 |
1 |
@Test(groups = { "Functional" })... |
762 |
|
public void testAlignAs_dnaAsDna() throws IOException |
763 |
|
{ |
764 |
|
|
765 |
1 |
AlignmentI al1 = loadAlignment(CDNA_SEQS_1, FileFormat.Fasta); |
766 |
|
|
767 |
1 |
AlignmentI al2 = loadAlignment(CDNA_SEQS_2, FileFormat.Fasta); |
768 |
|
|
769 |
|
|
770 |
|
|
771 |
|
|
772 |
|
|
773 |
1 |
makeMappings(al1, al2); |
774 |
|
|
775 |
1 |
((Alignment) al2).alignAs(al1, false, true); |
776 |
1 |
assertEquals("GC-TC--GUC-GTACT", |
777 |
|
al2.getSequenceAt(0).getSequenceAsString()); |
778 |
1 |
assertEquals("-GG-GTC--AGG--CAGT", |
779 |
|
al2.getSequenceAt(1).getSequenceAsString()); |
780 |
|
} |
781 |
|
|
782 |
|
|
783 |
|
|
784 |
|
|
785 |
|
@throws |
786 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0.14 |
1PASS
|
|
787 |
1 |
@Test(groups = { "Functional" })... |
788 |
|
public void testAlignAs_proteinAsCdna() throws IOException |
789 |
|
{ |
790 |
|
|
791 |
1 |
AlignmentI al1 = loadAlignment(CDNA_SEQS_1, FileFormat.Fasta); |
792 |
1 |
AlignmentI al2 = loadAlignment(AA_SEQS_1, FileFormat.Fasta); |
793 |
1 |
makeMappings(al1, al2); |
794 |
|
|
795 |
|
|
796 |
1 |
al2.getCodonFrames().addAll(al1.getCodonFrames()); |
797 |
|
|
798 |
1 |
((Alignment) al2).alignAs(al1, false, true); |
799 |
1 |
assertEquals("K-Q-Y-L-", al2.getSequenceAt(0).getSequenceAsString()); |
800 |
1 |
assertEquals("-R-F-P-W", al2.getSequenceAt(1).getSequenceAsString()); |
801 |
|
} |
802 |
|
|
803 |
|
|
804 |
|
|
805 |
|
|
806 |
|
|
807 |
|
@throws |
808 |
|
|
|
|
| 88.9% |
Uncovered Elements: 2 (18) |
Complexity: 2 |
Complexity Density: 0.12 |
1PASS
|
|
809 |
1 |
@Test(groups = { "Functional" })... |
810 |
|
public void testAlignAs_prot_tdi() throws Exception |
811 |
|
{ |
812 |
|
|
813 |
1 |
AlignmentI al1 = loadAlignment(TD_SEQS_2, FileFormat.Fasta); |
814 |
1 |
AlignmentI al2 = loadAlignment(AA_SEQS_2_DS, FileFormat.Fasta); |
815 |
1 |
al1.setDataset(null); |
816 |
1 |
al2.setDataset(al1.getDataset()); |
817 |
1 |
AlignmentI al1copy = new Alignment(al1); |
818 |
1 |
AlignmentI al2copy = new Alignment(al2); |
819 |
1 |
AlignmentUtils.map3diPeptideToProteinAligment(al2, al1); |
820 |
1 |
if (al2.getCodonFrames().isEmpty()) {al2.getCodonFrames().addAll(al1.getCodonFrames()); } |
821 |
1 |
else {al1.getCodonFrames().addAll(al2.getCodonFrames()); }; |
822 |
|
|
823 |
1 |
((Alignment) al2).alignAs(al1); |
824 |
1 |
assertEquals("-NMP-R", al1.getSequenceAt(0).getSequenceAsString()); |
825 |
1 |
assertEquals("VX--YA", al1.getSequenceAt(1).getSequenceAsString()); |
826 |
1 |
assertEquals("-KQY-L", al2.getSequenceAt(0).getSequenceAsString()); |
827 |
1 |
assertEquals("RF--PW", al2.getSequenceAt(1).getSequenceAsString()); |
828 |
|
|
829 |
|
} |
830 |
|
|
831 |
|
|
832 |
|
|
833 |
|
@throws |
834 |
|
|
|
|
| 88.9% |
Uncovered Elements: 2 (18) |
Complexity: 2 |
Complexity Density: 0.12 |
1PASS
|
|
835 |
1 |
@Test(groups = { "Functional" })... |
836 |
|
public void testAlignAs_tdi_prot() throws Exception |
837 |
|
{ |
838 |
|
|
839 |
1 |
AlignmentI al1 = loadAlignment(AA_SEQS_2, FileFormat.Fasta); |
840 |
1 |
AlignmentI al2 = loadAlignment(TD_SEQS_2_DS, FileFormat.Fasta); |
841 |
1 |
al1.setDataset(null); |
842 |
1 |
al2.setDataset(al1.getDataset()); |
843 |
1 |
AlignmentI al1copy = new Alignment(al1); |
844 |
1 |
AlignmentI al2copy = new Alignment(al2); |
845 |
1 |
AlignmentUtils.map3diPeptideToProteinAligment(al1, al2); |
846 |
1 |
if (al2.getCodonFrames().isEmpty()) {al2.getCodonFrames().addAll(al1.getCodonFrames()); } |
847 |
0 |
else {al1.getCodonFrames().addAll(al2.getCodonFrames()); }; |
848 |
|
|
849 |
1 |
((Alignment) al2).alignAs(al1); |
850 |
1 |
assertEquals("K-QY-L", al1.getSequenceAt(0).getSequenceAsString()); |
851 |
1 |
assertEquals("-R-FPW", al1.getSequenceAt(1).getSequenceAsString()); |
852 |
1 |
assertEquals("N-MP-R", al2.getSequenceAt(0).getSequenceAsString()); |
853 |
1 |
assertEquals("-V-XYA", al2.getSequenceAt(1).getSequenceAsString()); |
854 |
|
|
855 |
|
} |
856 |
|
|
857 |
|
|
858 |
|
|
859 |
|
@throws |
860 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0.17 |
1PASS
|
|
861 |
1 |
@Test(groups = { "Functional" }, enabled = true)... |
862 |
|
|
863 |
|
public void testAlignAs_cdnaAsProtein() throws IOException |
864 |
|
{ |
865 |
|
|
866 |
|
|
867 |
|
|
868 |
1 |
AlignmentI al1 = loadAlignment(CDNA_SEQS_1, FileFormat.Fasta); |
869 |
1 |
AlignmentI al2 = loadAlignment(AA_SEQS_1, FileFormat.Fasta); |
870 |
1 |
makeMappings(al1, al2); |
871 |
|
|
872 |
|
|
873 |
|
|
874 |
|
|
875 |
1 |
((Alignment) al1).alignAs(al2, false, true); |
876 |
1 |
assertEquals("ACG---GCUCCA------ACT---", |
877 |
|
al1.getSequenceAt(0).getSequenceAsString()); |
878 |
1 |
assertEquals("---CGT---TAACGA---AGT---", |
879 |
|
al1.getSequenceAt(1).getSequenceAsString()); |
880 |
|
} |
881 |
|
|
882 |
|
|
883 |
|
|
884 |
|
|
885 |
|
@throws |
886 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0.33 |
1PASS
|
|
887 |
1 |
@Test(groups = { "Functional" }, enabled = true)... |
888 |
|
|
889 |
|
public void testAlignAs_cdnaAsProtein_singleSequence() throws IOException |
890 |
|
{ |
891 |
|
|
892 |
|
|
893 |
|
|
894 |
1 |
verifyAlignAs(">dna\nCAAaaa\n", ">protein\nQ-K\n", "CAA---aaa"); |
895 |
|
|
896 |
|
|
897 |
|
|
898 |
|
|
899 |
1 |
verifyAlignAs(">dna/5-10\nCAAaaa\n", ">protein/20-21\nQ-K\n", |
900 |
|
"CAA---aaa"); |
901 |
|
|
902 |
|
|
903 |
|
|
904 |
|
|
905 |
1 |
verifyAlignAs(">dna/10-18\nCA-Aa-aa--AGA\n", ">aa/6-8\n-Q-K--R\n", |
906 |
|
"---CAA---aaa------AGA"); |
907 |
|
} |
908 |
|
|
909 |
|
|
910 |
|
|
911 |
|
@throws |
912 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 1 |
Complexity Density: 0.12 |
1PASS
|
|
913 |
1 |
@Test(groups={"Functional"},enabled=true)... |
914 |
|
public void testAlignAs_3di() throws IOException |
915 |
|
{ |
916 |
1 |
String protAl = ">1ji5_A\n" |
917 |
|
+ "-----------------------------DQPVLLLLLLQLLLLLVLLLQQLVVCLVQAD\n" |
918 |
|
+ "DPCNVVSNVVSVVSSVVSVVSNVVSQVVCVVVVHHHDDDVSSVVRYPQDHHDPP--DYPL\n" |
919 |
|
+ "RSLVSLLVSLVVVLVSLVVSLVSCVVVVNVVSNVSSVVVSVVSVVSNVVSCVVVVD----\n" |
920 |
|
+ "---------------------------------------------------\n" |
921 |
|
+ ">1jig_A\n" |
922 |
|
+ "---------------------------DALLVVLLLLLLQLLLALVLLLQQLVLCLVLAD\n" |
923 |
|
+ "DPCNVVSNVVSVVVSVVSVVSNVVSQVVCVVSVHHHDDDVSSVVRYPQDHDDSP--DYPL\n" |
924 |
|
+ "RSLVSLLVSLVVLLVSLVVSLVSCVVNVNPVSNVSSVVSSVVSVVSNVVSVVVND-----\n" |
925 |
|
+ "---------------------------------------------------\n" |
926 |
|
+ "\n"; |
927 |
1 |
String tdiAl = ">1ji5_A\n" |
928 |
|
+ "-----------------------------MNKQVIEVLNKQVADWSVLFTKLHNFHWYVK\n" |
929 |
|
+ "GPQFFTLHEKFEELYTESATHIDEIAERILAIGGKPVATKEYLEISSIQEAAYG--ETAE\n" |
930 |
|
+ "GMVEAIMKDYEMMLVELKKGMEIAQNSDDEMTSDLLLGIYTELEKHAWMLRAFLNQ----\n" |
931 |
|
+ "---------------------------------------------------\n" |
932 |
|
+ ">1jig_A\n" |
933 |
|
+ "---------------------------MSTKTNVVEVLNKQVANWNVLYVKLHNYHWYVT\n" |
934 |
|
+ "GPHFFTLHEKFEEFYNEAGTYIDELAERILALEGKPLATKEYLATSSVNEGTSK--ESAE\n" |
935 |
|
+ "EMVQTLVNDYSALIQELKEGMEVAGEAGDATSADMLLAIHTTLEQHVWMLSAFLK-----\n" |
936 |
|
+ "---------------------------------------------------\n" + ""; |
937 |
1 |
AlignmentI prot = loadAlignment(protAl, FileFormat.Fasta); |
938 |
1 |
((Alignment) prot).createDatasetAlignment(); |
939 |
|
|
940 |
1 |
AlignmentI tdi = loadAlignment(tdiAl, FileFormat.Fasta); |
941 |
1 |
assertTrue(AlignmentUtils.map3diPeptideToProteinAligment(prot, tdi)); |
942 |
|
|
943 |
1 |
AlignmentI newProt = new Alignment( |
944 |
|
new SequenceI[] |
945 |
|
{ prot.getSequenceAt(0).getSubSequence(25, 35), |
946 |
|
prot.getSequenceAt(1).getSubSequence(35, 45) }); |
947 |
1 |
newProt.setDataset(prot.getDataset()); |
948 |
|
|
949 |
|
|
950 |
|
|
951 |
|
|
952 |
|
|
953 |
|
|
954 |
|
|
955 |
|
|
956 |
|
|
957 |
|
|
958 |
|
|
959 |
|
|
960 |
|
|
961 |
|
} |
962 |
|
|
963 |
|
|
964 |
|
|
965 |
|
|
966 |
|
@param |
967 |
|
@param |
968 |
|
@param |
969 |
|
@throws |
970 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (5) |
Complexity: 1 |
Complexity Density: 0.2 |
|
971 |
3 |
public void verifyAlignAs(String fromSeqs, String toSeqs, String expected)... |
972 |
|
throws IOException |
973 |
|
{ |
974 |
|
|
975 |
|
|
976 |
|
|
977 |
|
|
978 |
3 |
AlignmentI al1 = loadAlignment(fromSeqs, FileFormat.Fasta); |
979 |
3 |
AlignmentI al2 = loadAlignment(toSeqs, FileFormat.Fasta); |
980 |
3 |
makeMappings(al1, al2); |
981 |
|
|
982 |
|
|
983 |
|
|
984 |
|
|
985 |
3 |
((Alignment) al1).alignAs(al2, false, true); |
986 |
3 |
assertEquals(expected, al1.getSequenceAt(0).getSequenceAsString()); |
987 |
|
} |
988 |
|
|
989 |
|
|
990 |
|
|
991 |
|
|
992 |
|
|
993 |
|
@param |
994 |
|
@param |
995 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (13) |
Complexity: 3 |
Complexity Density: 0.33 |
|
996 |
6 |
public void makeMappings(AlignmentI alFrom, AlignmentI alTo)... |
997 |
|
{ |
998 |
6 |
int ratio = (alFrom.isNucleotide() == alTo.isNucleotide() ? 1 : 3); |
999 |
|
|
1000 |
6 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
1001 |
|
|
1002 |
15 |
for (int i = 0; i < alFrom.getHeight(); i++) |
1003 |
|
{ |
1004 |
9 |
SequenceI seqFrom = alFrom.getSequenceAt(i); |
1005 |
9 |
SequenceI seqTo = alTo.getSequenceAt(i); |
1006 |
9 |
MapList ml = new MapList( |
1007 |
|
new int[] |
1008 |
|
{ seqFrom.getStart(), seqFrom.getEnd() }, |
1009 |
|
new int[] |
1010 |
|
{ seqTo.getStart(), seqTo.getEnd() }, ratio, 1); |
1011 |
9 |
acf.addMap(seqFrom, seqTo, ml); |
1012 |
|
} |
1013 |
|
|
1014 |
|
|
1015 |
|
|
1016 |
|
|
1017 |
|
|
1018 |
6 |
alFrom.addCodonFrame(acf); |
1019 |
6 |
alTo.addCodonFrame(acf); |
1020 |
|
} |
1021 |
|
|
1022 |
|
|
1023 |
|
|
1024 |
|
|
1025 |
|
|
1026 |
|
@throws |
1027 |
|
|
|
|
| 0% |
Uncovered Elements: 18 (18) |
Complexity: 1 |
Complexity Density: 0.06 |
1PASS
|
|
1028 |
0 |
@Test(groups = { "Functional" }, enabled = false)... |
1029 |
|
|
1030 |
|
public void testAlignAs_dnaAsProtein_withIntrons() throws IOException |
1031 |
|
{ |
1032 |
|
|
1033 |
|
|
1034 |
|
|
1035 |
0 |
String dna1 = "A-Aa-gG-GCC-cT-TT"; |
1036 |
0 |
String dna2 = "c--CCGgg-TT--T-AA-A"; |
1037 |
0 |
AlignmentI al1 = loadAlignment( |
1038 |
|
">Dna1/6-17\n" + dna1 + "\n>Dna2/20-31\n" + dna2 + "\n", |
1039 |
|
FileFormat.Fasta); |
1040 |
0 |
AlignmentI al2 = loadAlignment( |
1041 |
|
">Pep1/7-9\n-P--YK\n>Pep2/11-13\nG-T--F\n", FileFormat.Fasta); |
1042 |
0 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
1043 |
|
|
1044 |
|
|
1045 |
0 |
MapList ml1 = new MapList(new int[] { 6, 7, 10, 13, 15, 17 }, |
1046 |
|
new int[] |
1047 |
|
{ 7, 9 }, 3, 1); |
1048 |
0 |
acf.addMap(al1.getSequenceAt(0), al2.getSequenceAt(0), ml1); |
1049 |
0 |
MapList ml2 = new MapList(new int[] { 21, 23, 26, 31 }, |
1050 |
|
new int[] |
1051 |
|
{ 11, 13 }, 3, 1); |
1052 |
0 |
acf.addMap(al1.getSequenceAt(1), al2.getSequenceAt(1), ml2); |
1053 |
0 |
al2.addCodonFrame(acf); |
1054 |
|
|
1055 |
|
|
1056 |
|
|
1057 |
|
|
1058 |
0 |
((Alignment) al1).alignAs(al2, false, false); |
1059 |
0 |
assertEquals("---AAagG------GCCcTTT", |
1060 |
|
al1.getSequenceAt(0).getSequenceAsString()); |
1061 |
|
|
1062 |
0 |
assertEquals("cCCGgg-TTT------AAA", |
1063 |
|
al1.getSequenceAt(1).getSequenceAsString()); |
1064 |
|
|
1065 |
|
|
1066 |
|
|
1067 |
|
|
1068 |
0 |
al1.getSequenceAt(0).setSequence(dna1); |
1069 |
0 |
al1.getSequenceAt(1).setSequence(dna2); |
1070 |
0 |
((Alignment) al1).alignAs(al2, true, true); |
1071 |
|
|
1072 |
|
|
1073 |
|
|
1074 |
0 |
assertEquals("---A-Aa-gG------GCC-cT-TT", |
1075 |
|
al1.getSequenceAt(0).getSequenceAsString()); |
1076 |
0 |
assertEquals("c--CCGgg-TT--T------AA-A", |
1077 |
|
al1.getSequenceAt(1).getSequenceAsString()); |
1078 |
|
} |
1079 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 1 |
Complexity Density: 0.09 |
1PASS
|
|
1080 |
1 |
@Test(groups = "Functional")... |
1081 |
|
public void testCopyConstructor() throws IOException |
1082 |
|
{ |
1083 |
1 |
AlignmentI protein = loadAlignment(AA_SEQS_1, FileFormat.Fasta); |
1084 |
|
|
1085 |
1 |
protein.setDataset(null); |
1086 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
1087 |
1 |
List<AlignedCodonFrame> acfList = Arrays |
1088 |
|
.asList(new AlignedCodonFrame[] |
1089 |
|
{ acf }); |
1090 |
1 |
protein.getDataset().setCodonFrames(acfList); |
1091 |
1 |
AlignmentI copy = new Alignment(protein); |
1092 |
|
|
1093 |
|
|
1094 |
|
|
1095 |
|
|
1096 |
1 |
assertFalse(copy.getSequenceAt(0) == protein.getSequenceAt(0)); |
1097 |
1 |
assertFalse(copy.getSequenceAt(1) == protein.getSequenceAt(1)); |
1098 |
1 |
assertSame(copy.getSequenceAt(0).getDatasetSequence(), |
1099 |
|
protein.getSequenceAt(0).getDatasetSequence()); |
1100 |
1 |
assertSame(copy.getSequenceAt(1).getDatasetSequence(), |
1101 |
|
protein.getSequenceAt(1).getDatasetSequence()); |
1102 |
|
|
1103 |
|
|
1104 |
|
|
1105 |
1 |
assertNull(copy.getDataset()); |
1106 |
|
|
1107 |
|
|
1108 |
|
|
1109 |
|
|
1110 |
|
} |
1111 |
|
|
1112 |
|
|
1113 |
|
|
1114 |
|
|
1115 |
|
@throws |
1116 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (15) |
Complexity: 1 |
Complexity Density: 0.07 |
1PASS
|
|
1117 |
1 |
@Test(groups = "Functional")... |
1118 |
|
public void testCreateDatasetAlignment() throws IOException |
1119 |
|
{ |
1120 |
1 |
AlignmentI protein = new FormatAdapter().readFile(AA_SEQS_1, |
1121 |
|
DataSourceType.PASTE, FileFormat.Fasta); |
1122 |
|
|
1123 |
|
|
1124 |
|
|
1125 |
|
|
1126 |
1 |
protein.getSequenceAt(0).createDatasetSequence(); |
1127 |
1 |
assertNotNull(protein.getSequenceAt(0).getDatasetSequence()); |
1128 |
1 |
assertNull(protein.getSequenceAt(1).getDatasetSequence()); |
1129 |
|
|
1130 |
|
|
1131 |
|
|
1132 |
|
|
1133 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
1134 |
1 |
protein.addCodonFrame(acf); |
1135 |
1 |
assertNull(protein.getDataset()); |
1136 |
1 |
assertTrue(protein.getCodonFrames().contains(acf)); |
1137 |
|
|
1138 |
|
|
1139 |
|
|
1140 |
|
|
1141 |
|
|
1142 |
|
|
1143 |
|
|
1144 |
1 |
((Alignment) protein).createDatasetAlignment(); |
1145 |
|
|
1146 |
1 |
AlignmentI ds = protein.getDataset(); |
1147 |
|
|
1148 |
|
|
1149 |
1 |
assertNotNull(protein.getSequenceAt(1).getDatasetSequence()); |
1150 |
|
|
1151 |
1 |
assertEquals(ds.getSequenceAt(0), |
1152 |
|
protein.getSequenceAt(0).getDatasetSequence()); |
1153 |
1 |
assertEquals(ds.getSequenceAt(1), |
1154 |
|
protein.getSequenceAt(1).getDatasetSequence()); |
1155 |
|
|
1156 |
|
|
1157 |
|
|
1158 |
1 |
assertTrue(protein.getCodonFrames().contains(acf)); |
1159 |
|
|
1160 |
1 |
assertTrue(ds.getCodonFrames().contains(acf)); |
1161 |
|
} |
1162 |
|
|
1163 |
|
|
1164 |
|
|
1165 |
|
|
1166 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (21) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
1167 |
1 |
@Test(groups = "Functional")... |
1168 |
|
public void testCreateDatasetAlignmentWithMappedToSeqs() |
1169 |
|
{ |
1170 |
|
|
1171 |
1 |
SequenceI sq1 = new Sequence("sq1", "A--SDF"); |
1172 |
1 |
SequenceI sq2 = new Sequence("sq2", "G--TRQ"); |
1173 |
|
|
1174 |
|
|
1175 |
1 |
DBRefEntry dbr = new DBRefEntry("SQ1", "", "sq3"); |
1176 |
1 |
SequenceI sq3 = new Sequence("sq3", "VWANG"); |
1177 |
1 |
dbr.setMap( |
1178 |
|
new Mapping(sq3, new MapList(new int[] |
1179 |
|
{ 1, 4 }, new int[] { 2, 5 }, 1, 1))); |
1180 |
1 |
sq1.addDBRef(dbr); |
1181 |
|
|
1182 |
1 |
SequenceI sq4 = new Sequence("sq4", "ERKWI"); |
1183 |
1 |
DBRefEntry dbr2 = new DBRefEntry("SQ2", "", "sq4"); |
1184 |
1 |
dbr2.setMap( |
1185 |
|
new Mapping(sq4, new MapList(new int[] |
1186 |
|
{ 1, 4 }, new int[] { 2, 5 }, 1, 1))); |
1187 |
1 |
sq2.addDBRef(dbr2); |
1188 |
|
|
1189 |
1 |
AlignedCodonFrame alc = new AlignedCodonFrame(); |
1190 |
1 |
alc.addMap(sq1, sq2, |
1191 |
|
new MapList(new int[] |
1192 |
|
{ 1, 4 }, new int[] { 1, 4 }, 1, 1)); |
1193 |
|
|
1194 |
1 |
AlignmentI protein = new Alignment(new SequenceI[] { sq1, sq2 }); |
1195 |
|
|
1196 |
|
|
1197 |
|
|
1198 |
|
|
1199 |
|
|
1200 |
|
|
1201 |
|
|
1202 |
|
|
1203 |
1 |
((Alignment) protein).createDatasetAlignment(); |
1204 |
|
|
1205 |
1 |
AlignmentI ds = protein.getDataset(); |
1206 |
|
|
1207 |
|
|
1208 |
|
|
1209 |
1 |
assertEquals(4, ds.getHeight()); |
1210 |
1 |
assertTrue(ds.getSequences().contains(sq1.getDatasetSequence())); |
1211 |
1 |
assertTrue(ds.getSequences().contains(sq2.getDatasetSequence())); |
1212 |
1 |
assertTrue(ds.getSequences().contains(sq3)); |
1213 |
1 |
assertTrue(ds.getSequences().contains(sq4)); |
1214 |
|
|
1215 |
|
|
1216 |
1 |
assertEquals(ds.getCodonFrame(sq1.getDatasetSequence()), |
1217 |
|
ds.getCodonFrame(sq2.getDatasetSequence())); |
1218 |
|
} |
1219 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (13) |
Complexity: 1 |
Complexity Density: 0.08 |
1PASS
|
|
1220 |
1 |
@Test(groups = "Functional")... |
1221 |
|
public void testAddCodonFrame() |
1222 |
|
{ |
1223 |
1 |
AlignmentI align = new Alignment(new SequenceI[] {}); |
1224 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
1225 |
1 |
align.addCodonFrame(acf); |
1226 |
1 |
assertEquals(1, align.getCodonFrames().size()); |
1227 |
1 |
assertTrue(align.getCodonFrames().contains(acf)); |
1228 |
|
|
1229 |
1 |
align.addCodonFrame(acf); |
1230 |
1 |
assertEquals(1, align.getCodonFrames().size()); |
1231 |
|
|
1232 |
|
|
1233 |
1 |
((Alignment) align).createDatasetAlignment(); |
1234 |
1 |
assertSame(align.getCodonFrames(), align.getDataset().getCodonFrames()); |
1235 |
1 |
assertEquals(1, align.getCodonFrames().size()); |
1236 |
|
|
1237 |
1 |
AlignedCodonFrame acf2 = new AlignedCodonFrame(); |
1238 |
1 |
align.addCodonFrame(acf2); |
1239 |
1 |
assertTrue(align.getDataset().getCodonFrames().contains(acf)); |
1240 |
|
} |
1241 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (12) |
Complexity: 1 |
Complexity Density: 0.08 |
1PASS
|
|
1242 |
1 |
@Test(groups = "Functional")... |
1243 |
|
public void testAddSequencePreserveDatasetIntegrity() |
1244 |
|
{ |
1245 |
1 |
Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); |
1246 |
1 |
Alignment align = new Alignment(new SequenceI[] { seq }); |
1247 |
1 |
align.createDatasetAlignment(); |
1248 |
1 |
AlignmentI ds = align.getDataset(); |
1249 |
1 |
SequenceI copy = new Sequence(seq); |
1250 |
1 |
copy.insertCharAt(3, 5, '-'); |
1251 |
1 |
align.addSequence(copy); |
1252 |
1 |
Assert.assertEquals(align.getDataset().getHeight(), 1, |
1253 |
|
"Dataset shouldn't have more than one sequence."); |
1254 |
|
|
1255 |
1 |
Sequence seq2 = new Sequence("newtestSeq", |
1256 |
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"); |
1257 |
1 |
align.addSequence(seq2); |
1258 |
1 |
Assert.assertEquals(align.getDataset().getHeight(), 2, |
1259 |
|
"Dataset should now have two sequences."); |
1260 |
|
|
1261 |
1 |
assertAlignmentDatasetRefs(align, |
1262 |
|
"addSequence broke dataset reference integrity"); |
1263 |
|
} |
1264 |
|
|
1265 |
|
|
1266 |
|
|
1267 |
|
|
1268 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (30) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
1269 |
1 |
@Test(groups = "Functional")... |
1270 |
|
public void testCreateDataset_updateDbrefMappings() |
1271 |
|
{ |
1272 |
1 |
SequenceI pep = new Sequence("pep", "ASD"); |
1273 |
1 |
SequenceI dna = new Sequence("dna", "aaaGCCTCGGATggg"); |
1274 |
1 |
SequenceI cds = new Sequence("cds", "GCCTCGGAT"); |
1275 |
|
|
1276 |
|
|
1277 |
1 |
DBRefEntry dbr = new DBRefEntry("UNIPROT", "", "pep"); |
1278 |
1 |
dbr.setMap( |
1279 |
|
new Mapping(pep, new MapList(new int[] |
1280 |
|
{ 4, 15 }, new int[] { 1, 4 }, 3, 1))); |
1281 |
1 |
dna.addDBRef(dbr); |
1282 |
|
|
1283 |
|
|
1284 |
1 |
DBRefEntry dbr2 = new DBRefEntry("UNIPROT", "", "pep"); |
1285 |
1 |
dbr2.setMap( |
1286 |
|
new Mapping(pep, new MapList(new int[] |
1287 |
|
{ 1, 12 }, new int[] { 1, 4 }, 3, 1))); |
1288 |
1 |
cds.addDBRef(dbr2); |
1289 |
|
|
1290 |
|
|
1291 |
1 |
DBRefEntry dbr3 = new DBRefEntry("EMBL", "", "dna"); |
1292 |
1 |
dbr3.setMap( |
1293 |
|
new Mapping(dna, new MapList(new int[] |
1294 |
|
{ 1, 4 }, new int[] { 4, 15 }, 1, 3))); |
1295 |
1 |
pep.addDBRef(dbr3); |
1296 |
|
|
1297 |
|
|
1298 |
1 |
DBRefEntry dbr4 = new DBRefEntry("EMBLCDS", "", "cds"); |
1299 |
1 |
dbr4.setMap( |
1300 |
|
new Mapping(cds, new MapList(new int[] |
1301 |
|
{ 1, 4 }, new int[] { 1, 12 }, 1, 3))); |
1302 |
1 |
pep.addDBRef(dbr4); |
1303 |
|
|
1304 |
1 |
AlignmentI protein = new Alignment(new SequenceI[] { pep }); |
1305 |
|
|
1306 |
|
|
1307 |
|
|
1308 |
|
|
1309 |
1 |
((Alignment) protein).createDatasetAlignment(); |
1310 |
|
|
1311 |
1 |
AlignmentI ds = protein.getDataset(); |
1312 |
|
|
1313 |
|
|
1314 |
1 |
assertEquals(3, ds.getHeight()); |
1315 |
1 |
assertTrue(ds.getSequences().contains(pep.getDatasetSequence())); |
1316 |
1 |
assertTrue(ds.getSequences().contains(dna)); |
1317 |
1 |
assertTrue(ds.getSequences().contains(cds)); |
1318 |
|
|
1319 |
|
|
1320 |
|
|
1321 |
|
|
1322 |
1 |
List<DBRefEntry> dbRefs = pep.getDBRefs(); |
1323 |
1 |
assertEquals(2, dbRefs.size()); |
1324 |
1 |
assertSame(dna, dbRefs.get(0).map.to); |
1325 |
1 |
assertSame(cds, dbRefs.get(1).map.to); |
1326 |
1 |
assertEquals(1, dna.getDBRefs().size()); |
1327 |
1 |
assertSame(pep.getDatasetSequence(), dna.getDBRefs().get(0).map.to); |
1328 |
1 |
assertEquals(1, cds.getDBRefs().size()); |
1329 |
1 |
assertSame(pep.getDatasetSequence(), cds.getDBRefs().get(0).map.to); |
1330 |
|
} |
1331 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (33) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
1332 |
1 |
@Test(groups = { "Functional" })... |
1333 |
|
public void testFindGroup() |
1334 |
|
{ |
1335 |
1 |
SequenceI seq1 = new Sequence("seq1", "ABCDEF---GHI"); |
1336 |
1 |
SequenceI seq2 = new Sequence("seq2", "---JKLMNO---"); |
1337 |
1 |
AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2 }); |
1338 |
|
|
1339 |
1 |
assertNull(a.findGroup(null, 0)); |
1340 |
1 |
assertNull(a.findGroup(seq1, 1)); |
1341 |
1 |
assertNull(a.findGroup(seq1, -1)); |
1342 |
|
|
1343 |
|
|
1344 |
|
|
1345 |
|
|
1346 |
1 |
SequenceGroup sg1 = new SequenceGroup(); |
1347 |
1 |
sg1.addSequence(seq1, false); |
1348 |
1 |
sg1.setStartRes(3); |
1349 |
1 |
sg1.setEndRes(5); |
1350 |
1 |
a.addGroup(sg1); |
1351 |
|
|
1352 |
1 |
assertNull(a.findGroup(seq1, 2)); |
1353 |
1 |
assertNull(a.findGroup(seq1, 6)); |
1354 |
1 |
assertNull(a.findGroup(seq2, 5)); |
1355 |
1 |
assertSame(a.findGroup(seq1, 3), sg1); |
1356 |
1 |
assertSame(a.findGroup(seq1, 4), sg1); |
1357 |
1 |
assertSame(a.findGroup(seq1, 5), sg1); |
1358 |
|
|
1359 |
|
|
1360 |
|
|
1361 |
|
|
1362 |
|
|
1363 |
|
|
1364 |
1 |
SequenceGroup sg2 = new SequenceGroup(); |
1365 |
1 |
sg2.addSequence(seq1, false); |
1366 |
1 |
sg2.addSequence(seq2, false); |
1367 |
1 |
sg2.setStartRes(4); |
1368 |
1 |
sg2.setEndRes(7); |
1369 |
1 |
a.addGroup(sg2); |
1370 |
|
|
1371 |
1 |
assertNull(a.findGroup(seq1, 2)); |
1372 |
1 |
assertSame(a.findGroup(seq1, 3), sg1); |
1373 |
|
|
1374 |
|
|
1375 |
|
|
1376 |
|
|
1377 |
1 |
assertSame(a.findGroup(seq1, 4), sg1); |
1378 |
1 |
assertSame(a.findGroup(seq1, 5), sg1); |
1379 |
|
|
1380 |
|
|
1381 |
|
|
1382 |
|
|
1383 |
1 |
assertSame(a.findGroup(seq2, 4), sg2); |
1384 |
1 |
assertSame(a.findGroup(seq2, 5), sg2); |
1385 |
1 |
assertSame(a.findGroup(seq2, 6), sg2); |
1386 |
1 |
assertSame(a.findGroup(seq2, 7), sg2); |
1387 |
1 |
assertNull(a.findGroup(seq2, 3)); |
1388 |
1 |
assertNull(a.findGroup(seq2, 8)); |
1389 |
|
} |
1390 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (9) |
Complexity: 1 |
Complexity Density: 0.11 |
1PASS
|
|
1391 |
1 |
@Test(groups = { "Functional" })... |
1392 |
|
public void testDeleteSequenceByIndex() |
1393 |
|
{ |
1394 |
|
|
1395 |
1 |
AlignmentGenerator gen = new AlignmentGenerator(false); |
1396 |
1 |
AlignmentI a = gen.generate(20, 15, 123, 5, 5); |
1397 |
|
|
1398 |
|
|
1399 |
1 |
int height = a.getAbsoluteHeight(); |
1400 |
1 |
a.deleteSequence(10); |
1401 |
1 |
assertEquals(a.getAbsoluteHeight(), height - 1); |
1402 |
|
|
1403 |
|
|
1404 |
1 |
a.deleteSequence(-1); |
1405 |
1 |
assertEquals(a.getAbsoluteHeight(), height - 1); |
1406 |
|
|
1407 |
|
|
1408 |
1 |
a.deleteSequence(14); |
1409 |
1 |
assertEquals(a.getAbsoluteHeight(), height - 1); |
1410 |
|
} |
1411 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 1 |
Complexity Density: 0.12 |
1PASS
|
|
1412 |
1 |
@Test(groups = { "Functional" })... |
1413 |
|
public void testDeleteSequenceBySeq() |
1414 |
|
{ |
1415 |
|
|
1416 |
1 |
AlignmentGenerator gen = new AlignmentGenerator(false); |
1417 |
1 |
AlignmentI a = gen.generate(20, 15, 123, 5, 5); |
1418 |
|
|
1419 |
|
|
1420 |
1 |
int height = a.getAbsoluteHeight(); |
1421 |
1 |
SequenceI seq = a.getSequenceAt(10); |
1422 |
1 |
a.deleteSequence(seq); |
1423 |
1 |
assertEquals(a.getAbsoluteHeight(), height - 1); |
1424 |
|
|
1425 |
|
|
1426 |
1 |
seq = new Sequence("cds", "GCCTCGGAT"); |
1427 |
1 |
assertEquals(a.getAbsoluteHeight(), height - 1); |
1428 |
|
} |
1429 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (12) |
Complexity: 1 |
Complexity Density: 0.08 |
1PASS
|
|
1430 |
1 |
@Test(groups = { "Functional" })... |
1431 |
|
public void testDeleteHiddenSequence() |
1432 |
|
{ |
1433 |
|
|
1434 |
1 |
AlignmentGenerator gen = new AlignmentGenerator(false); |
1435 |
1 |
AlignmentI a = gen.generate(20, 15, 123, 5, 5); |
1436 |
|
|
1437 |
|
|
1438 |
|
|
1439 |
1 |
int height = a.getAbsoluteHeight(); |
1440 |
1 |
SequenceI seq = a.getSequenceAt(2); |
1441 |
1 |
a.getHiddenSequences().hideSequence(seq); |
1442 |
1 |
assertEquals(a.getHiddenSequences().getSize(), 1); |
1443 |
1 |
a.deleteSequence(2); |
1444 |
1 |
assertEquals(a.getAbsoluteHeight(), height - 1); |
1445 |
1 |
assertEquals(a.getHiddenSequences().getSize(), 1); |
1446 |
|
|
1447 |
|
|
1448 |
|
|
1449 |
1 |
a.deleteSequence(10); |
1450 |
1 |
assertEquals(a.getAbsoluteHeight(), height - 2); |
1451 |
1 |
assertEquals(a.getHiddenSequences().getSize(), 1); |
1452 |
|
} |
1453 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0.33 |
1PASS
|
|
1454 |
1 |
@Test(... |
1455 |
|
groups = "Functional", |
1456 |
|
expectedExceptions = |
1457 |
|
{ IllegalArgumentException.class }) |
1458 |
|
public void testSetDataset_selfReference() |
1459 |
|
{ |
1460 |
1 |
SequenceI seq = new Sequence("a", "a"); |
1461 |
1 |
AlignmentI alignment = new Alignment(new SequenceI[] { seq }); |
1462 |
1 |
alignment.setDataset(alignment); |
1463 |
|
} |
1464 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (10) |
Complexity: 1 |
Complexity Density: 0.1 |
1PASS
|
|
1465 |
1 |
@Test(groups = "Functional")... |
1466 |
|
public void testAppend() |
1467 |
|
{ |
1468 |
1 |
SequenceI seq = new Sequence("seq1", "FRMLPSRT-A--L-"); |
1469 |
1 |
AlignmentI alignment = new Alignment(new SequenceI[] { seq }); |
1470 |
1 |
alignment.setGapCharacter('-'); |
1471 |
1 |
SequenceI seq2 = new Sequence("seq1", "KP..L.FQII."); |
1472 |
1 |
AlignmentI alignment2 = new Alignment(new SequenceI[] { seq2 }); |
1473 |
1 |
alignment2.setGapCharacter('.'); |
1474 |
|
|
1475 |
1 |
alignment.append(alignment2); |
1476 |
|
|
1477 |
1 |
assertEquals('-', alignment.getGapCharacter()); |
1478 |
1 |
assertSame(seq, alignment.getSequenceAt(0)); |
1479 |
1 |
assertEquals("KP--L-FQII-", |
1480 |
|
alignment.getSequenceAt(1).getSequenceAsString()); |
1481 |
|
|
1482 |
|
|
1483 |
|
|
1484 |
|
} |
1485 |
|
|
1486 |
|
|
1487 |
|
|
1488 |
|
|
1489 |
|
|
1490 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0.17 |
1PASS
|
|
1491 |
1 |
@Test(groups = "Functional")... |
1492 |
|
public void testFindOrCreateForNullCalcId() |
1493 |
|
{ |
1494 |
1 |
SequenceI seq = new Sequence("seq1", "FRMLPSRT-A--L-"); |
1495 |
1 |
AlignmentI alignment = new Alignment(new SequenceI[] { seq }); |
1496 |
|
|
1497 |
1 |
AlignmentAnnotation ala = alignment.findOrCreateAnnotation( |
1498 |
|
"Temperature Factor", null, false, seq, null); |
1499 |
1 |
assertNotNull(ala); |
1500 |
1 |
assertEquals(seq, ala.sequenceRef); |
1501 |
1 |
assertEquals("", ala.calcId); |
1502 |
|
} |
1503 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (33) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
1504 |
1 |
@Test(groups = "Functional")... |
1505 |
|
public void testPropagateInsertions() |
1506 |
|
{ |
1507 |
|
|
1508 |
|
|
1509 |
1 |
AlignmentGenerator gen = new AlignmentGenerator(false); |
1510 |
1 |
AlignmentI al = gen.generate(25, 10, 1234, 0, 0); |
1511 |
|
|
1512 |
|
|
1513 |
1 |
SequenceI profileseq = al.getSequenceAt(0); |
1514 |
1 |
SequenceI gappedseq = new Sequence(profileseq); |
1515 |
1 |
gappedseq.insertCharAt(5, al.getGapCharacter()); |
1516 |
1 |
gappedseq.insertCharAt(6, al.getGapCharacter()); |
1517 |
1 |
gappedseq.insertCharAt(7, al.getGapCharacter()); |
1518 |
1 |
gappedseq.insertCharAt(8, al.getGapCharacter()); |
1519 |
|
|
1520 |
|
|
1521 |
1 |
al.getSequenceAt(3).deleteChars(2, 23); |
1522 |
1 |
al.getSequenceAt(4).deleteChars(2, 27); |
1523 |
1 |
al.getSequenceAt(5).deleteChars(10, 27); |
1524 |
|
|
1525 |
|
|
1526 |
1 |
SequenceI[] seqs = new SequenceI[1]; |
1527 |
1 |
seqs[0] = gappedseq; |
1528 |
1 |
AlignmentI newal = new Alignment(seqs); |
1529 |
1 |
HiddenColumns hidden = new HiddenColumns(); |
1530 |
1 |
hidden.hideColumns(15, 17); |
1531 |
|
|
1532 |
1 |
AlignmentView view = new AlignmentView(newal, hidden, null, true, false, |
1533 |
|
false); |
1534 |
|
|
1535 |
|
|
1536 |
1 |
Iterator<int[]> visible = hidden.getVisContigsIterator(0, 25, false); |
1537 |
1 |
int[] region = visible.next(); |
1538 |
1 |
assertEquals("[0, 14]", Arrays.toString(region)); |
1539 |
1 |
region = visible.next(); |
1540 |
1 |
assertEquals("[18, 24]", Arrays.toString(region)); |
1541 |
|
|
1542 |
|
|
1543 |
1 |
HiddenColumns result = al.propagateInsertions(profileseq, view); |
1544 |
|
|
1545 |
|
|
1546 |
1 |
visible = result.getVisContigsIterator(0, 25, false); |
1547 |
1 |
region = visible.next(); |
1548 |
1 |
assertEquals("[0, 10]", Arrays.toString(region)); |
1549 |
1 |
region = visible.next(); |
1550 |
1 |
assertEquals("[14, 24]", Arrays.toString(region)); |
1551 |
|
|
1552 |
|
|
1553 |
|
|
1554 |
1 |
assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[10])); |
1555 |
1 |
assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[11])); |
1556 |
1 |
assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[12])); |
1557 |
1 |
assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[13])); |
1558 |
1 |
assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[14])); |
1559 |
|
|
1560 |
|
} |
1561 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (31) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
1562 |
1 |
@Test(groups = "Functional")... |
1563 |
|
public void testPropagateInsertionsOverlap() |
1564 |
|
{ |
1565 |
|
|
1566 |
|
|
1567 |
|
|
1568 |
|
|
1569 |
1 |
AlignmentGenerator gen = new AlignmentGenerator(false); |
1570 |
1 |
AlignmentI al = gen.generate(20, 10, 1234, 0, 0); |
1571 |
|
|
1572 |
|
|
1573 |
1 |
SequenceI profileseq = al.getSequenceAt(0); |
1574 |
1 |
SequenceI gappedseq = new Sequence(profileseq); |
1575 |
1 |
gappedseq.insertCharAt(5, al.getGapCharacter()); |
1576 |
1 |
gappedseq.insertCharAt(6, al.getGapCharacter()); |
1577 |
1 |
gappedseq.insertCharAt(7, al.getGapCharacter()); |
1578 |
1 |
gappedseq.insertCharAt(8, al.getGapCharacter()); |
1579 |
|
|
1580 |
|
|
1581 |
1 |
SequenceI[] seqs = new SequenceI[1]; |
1582 |
1 |
seqs[0] = gappedseq; |
1583 |
1 |
AlignmentI newal = new Alignment(seqs); |
1584 |
|
|
1585 |
|
|
1586 |
1 |
HiddenColumns hidden = new HiddenColumns(); |
1587 |
1 |
hidden.hideColumns(7, 10); |
1588 |
|
|
1589 |
1 |
AlignmentView view = new AlignmentView(newal, hidden, null, true, false, |
1590 |
|
false); |
1591 |
|
|
1592 |
|
|
1593 |
1 |
Iterator<int[]> visible = hidden.getVisContigsIterator(0, 20, false); |
1594 |
1 |
int[] region = visible.next(); |
1595 |
1 |
assertEquals("[0, 6]", Arrays.toString(region)); |
1596 |
1 |
region = visible.next(); |
1597 |
1 |
assertEquals("[11, 19]", Arrays.toString(region)); |
1598 |
1 |
assertFalse(visible.hasNext()); |
1599 |
|
|
1600 |
|
|
1601 |
1 |
HiddenColumns result = al.propagateInsertions(profileseq, view); |
1602 |
|
|
1603 |
|
|
1604 |
1 |
visible = result.getVisContigsIterator(0, 20, false); |
1605 |
1 |
region = visible.next(); |
1606 |
1 |
assertEquals("[0, 4]", Arrays.toString(region)); |
1607 |
1 |
region = visible.next(); |
1608 |
1 |
assertEquals("[7, 19]", Arrays.toString(region)); |
1609 |
1 |
assertFalse(visible.hasNext()); |
1610 |
|
|
1611 |
|
|
1612 |
|
|
1613 |
1 |
assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[4])); |
1614 |
1 |
assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[5])); |
1615 |
1 |
assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[6])); |
1616 |
1 |
assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[7])); |
1617 |
|
} |
1618 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (10) |
Complexity: 1 |
Complexity Density: 0.1 |
1PASS
|
|
1619 |
1 |
@Test(groups = { "Functional" })... |
1620 |
|
public void testPadGaps() |
1621 |
|
{ |
1622 |
1 |
SequenceI seq1 = new Sequence("seq1", "ABCDEF--"); |
1623 |
1 |
SequenceI seq2 = new Sequence("seq2", "-JKLMNO--"); |
1624 |
1 |
SequenceI seq3 = new Sequence("seq2", "-PQR"); |
1625 |
1 |
AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2, seq3 }); |
1626 |
1 |
a.setGapCharacter('.'); |
1627 |
1 |
assertEquals("ABCDEF..", seq1.getSequenceAsString()); |
1628 |
1 |
a.padGaps(); |
1629 |
|
|
1630 |
1 |
assertEquals("ABCDEF.", seq1.getSequenceAsString()); |
1631 |
1 |
assertEquals(".JKLMNO", seq2.getSequenceAsString()); |
1632 |
1 |
assertEquals(".PQR...", seq3.getSequenceAsString()); |
1633 |
|
} |
1634 |
|
|
1635 |
|
|
1636 |
|
|
1637 |
|
|
1638 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (24) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
1639 |
1 |
@Test(groups = { "Functional" })... |
1640 |
|
public void testSetHiddenColumns() |
1641 |
|
{ |
1642 |
1 |
AlignmentI al = new Alignment(new SequenceI[] {}); |
1643 |
1 |
assertFalse(al.getHiddenColumns().hasHiddenColumns()); |
1644 |
|
|
1645 |
1 |
HiddenColumns hc = new HiddenColumns(); |
1646 |
1 |
assertFalse(al.setHiddenColumns(hc)); |
1647 |
1 |
assertSame(hc, al.getHiddenColumns()); |
1648 |
|
|
1649 |
1 |
hc.hideColumns(2, 4); |
1650 |
1 |
assertTrue(al.getHiddenColumns().hasHiddenColumns()); |
1651 |
|
|
1652 |
|
|
1653 |
|
|
1654 |
|
|
1655 |
1 |
HiddenColumns hc2 = new HiddenColumns(); |
1656 |
1 |
hc2.hideColumns(2, 4); |
1657 |
1 |
assertFalse(al.setHiddenColumns(hc2)); |
1658 |
1 |
assertSame(hc2, al.getHiddenColumns()); |
1659 |
|
|
1660 |
1 |
assertTrue(al.setHiddenColumns(null)); |
1661 |
1 |
assertNull(al.getHiddenColumns()); |
1662 |
1 |
assertTrue(al.setHiddenColumns(hc)); |
1663 |
1 |
assertSame(hc, al.getHiddenColumns()); |
1664 |
|
|
1665 |
1 |
al.getHiddenColumns().hideColumns(10, 12); |
1666 |
1 |
hc2.hideColumns(10, 12); |
1667 |
1 |
assertFalse(al.setHiddenColumns(hc2)); |
1668 |
|
|
1669 |
|
|
1670 |
|
|
1671 |
|
|
1672 |
|
|
1673 |
|
|
1674 |
|
|
1675 |
1 |
assertSame(hc2, al.getHiddenColumns()); |
1676 |
1 |
hc.hideColumns(15, 16); |
1677 |
1 |
hc.hideColumns(17, 18); |
1678 |
1 |
hc2.hideColumns(15, 18); |
1679 |
1 |
assertFalse(hc.equals(hc2)); |
1680 |
1 |
assertTrue(al.setHiddenColumns(hc)); |
1681 |
|
} |
1682 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0.14 |
1PASS
|
|
1683 |
1 |
@Test(groups = { "Functional" })... |
1684 |
|
public void testGetWidth() |
1685 |
|
{ |
1686 |
1 |
SequenceI seq1 = new Sequence("seq1", "ABCDEF--"); |
1687 |
1 |
SequenceI seq2 = new Sequence("seq2", "-JKLMNO--"); |
1688 |
1 |
SequenceI seq3 = new Sequence("seq2", "-PQR"); |
1689 |
1 |
AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2, seq3 }); |
1690 |
|
|
1691 |
1 |
assertEquals(9, a.getWidth()); |
1692 |
|
|
1693 |
|
|
1694 |
1 |
a.getHiddenColumns().hideColumns(2, 5); |
1695 |
1 |
assertEquals(9, a.getWidth()); |
1696 |
|
} |
1697 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0.14 |
1PASS
|
|
1698 |
1 |
@Test(groups = { "Functional" })... |
1699 |
|
public void testGetVisibleWidth() |
1700 |
|
{ |
1701 |
1 |
SequenceI seq1 = new Sequence("seq1", "ABCDEF--"); |
1702 |
1 |
SequenceI seq2 = new Sequence("seq2", "-JKLMNO--"); |
1703 |
1 |
SequenceI seq3 = new Sequence("seq2", "-PQR"); |
1704 |
1 |
AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2, seq3 }); |
1705 |
|
|
1706 |
1 |
assertEquals(9, a.getVisibleWidth()); |
1707 |
|
|
1708 |
|
|
1709 |
1 |
a.getHiddenColumns().hideColumns(2, 5); |
1710 |
1 |
assertEquals(5, a.getVisibleWidth()); |
1711 |
|
} |
1712 |
|
|
|
|
| - |
Uncovered Elements: 0 (0) |
Complexity: 1 |
Complexity Density: - |
1PASS
|
|
1713 |
1 |
@Test(groups = { "Functional" })... |
1714 |
|
public void testGetContactMap() |
1715 |
|
{ |
1716 |
|
|
1717 |
|
|
1718 |
|
|
1719 |
|
|
1720 |
|
|
1721 |
|
|
1722 |
|
|
1723 |
|
|
1724 |
|
} |
1725 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0.17 |
1PASS
|
|
1726 |
1 |
@Test(groups = { "Functional" })... |
1727 |
|
public void testEquals() |
1728 |
|
{ |
1729 |
1 |
SequenceI seq1 = new Sequence("seq1", "ABCDEF--"); |
1730 |
1 |
SequenceI seq2 = new Sequence("seq2", "-JKLMNO--"); |
1731 |
1 |
SequenceI seq3 = new Sequence("seq2", "-PQR"); |
1732 |
1 |
AlignmentI a = new Alignment(new SequenceI[] { seq1, seq2, seq3 }); |
1733 |
1 |
a.setDataset(null); |
1734 |
1 |
assertEquals(a.getDataset(), a.getDataset()); |
1735 |
|
} |
1736 |
|
} |