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.assertNull; |
26 |
|
import static org.testng.AssertJUnit.assertSame; |
27 |
|
import static org.testng.AssertJUnit.assertTrue; |
28 |
|
import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals; |
29 |
|
|
30 |
|
import jalview.gui.JvOptionPane; |
31 |
|
import jalview.util.MapList; |
32 |
|
|
33 |
|
import java.util.Arrays; |
34 |
|
import java.util.List; |
35 |
|
|
36 |
|
import org.testng.annotations.BeforeClass; |
37 |
|
import org.testng.annotations.Test; |
38 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (188) |
Complexity: 11 |
Complexity Density: 0.06 |
|
39 |
|
public class AlignedCodonFrameTest |
40 |
|
{ |
41 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
42 |
1 |
@BeforeClass(alwaysRun = true)... |
43 |
|
public void setUpJvOptionPane() |
44 |
|
{ |
45 |
1 |
JvOptionPane.setInteractiveMode(false); |
46 |
1 |
JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); |
47 |
|
} |
48 |
|
|
49 |
|
|
50 |
|
|
51 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (21) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
52 |
1 |
@Test(groups = { "Functional" })... |
53 |
|
public void testFindAlignedSequence() |
54 |
|
{ |
55 |
1 |
AlignmentI cdna = new Alignment(new SequenceI[] {}); |
56 |
1 |
final Sequence seq1 = new Sequence("Seq1", "C-G-TA-GC"); |
57 |
1 |
seq1.createDatasetSequence(); |
58 |
1 |
cdna.addSequence(seq1); |
59 |
1 |
final Sequence seq2 = new Sequence("Seq2", "-TA-GG-GG"); |
60 |
1 |
seq2.createDatasetSequence(); |
61 |
1 |
cdna.addSequence(seq2); |
62 |
|
|
63 |
1 |
AlignmentI aa = new Alignment(new SequenceI[] {}); |
64 |
1 |
final Sequence aseq1 = new Sequence("Seq1", "-P-R"); |
65 |
1 |
aseq1.createDatasetSequence(); |
66 |
1 |
aa.addSequence(aseq1); |
67 |
1 |
final Sequence aseq2 = new Sequence("Seq2", "-LY-"); |
68 |
1 |
aseq2.createDatasetSequence(); |
69 |
1 |
aa.addSequence(aseq2); |
70 |
|
|
71 |
|
|
72 |
|
|
73 |
|
|
74 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
75 |
|
|
76 |
1 |
assertNull(acf.findAlignedSequence(seq1, aa)); |
77 |
|
|
78 |
1 |
MapList map = new MapList(new int[] { 1, 6 }, new int[] { 1, 2 }, 3, 1); |
79 |
1 |
acf.addMap(seq1.getDatasetSequence(), aseq2.getDatasetSequence(), map); |
80 |
|
|
81 |
|
|
82 |
|
|
83 |
|
|
84 |
1 |
assertEquals(aa.getSequenceAt(1), acf.findAlignedSequence(cdna |
85 |
|
.getSequenceAt(0).getDatasetSequence(), aa)); |
86 |
|
|
87 |
1 |
assertEquals(aa.getSequenceAt(1), |
88 |
|
acf.findAlignedSequence(cdna.getSequenceAt(0), aa)); |
89 |
|
|
90 |
1 |
assertEquals(cdna.getSequenceAt(0), acf.findAlignedSequence(aa |
91 |
|
.getSequenceAt(1).getDatasetSequence(), cdna)); |
92 |
|
} |
93 |
|
|
94 |
|
|
95 |
|
|
96 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (20) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
97 |
1 |
@Test(groups = { "Functional" })... |
98 |
|
public void testGetMappedRegion() |
99 |
|
{ |
100 |
|
|
101 |
1 |
final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); |
102 |
1 |
seq1.createDatasetSequence(); |
103 |
1 |
final Sequence seq2 = new Sequence("Seq2", "-TA-gG-Gg-CG-a"); |
104 |
1 |
seq2.createDatasetSequence(); |
105 |
|
|
106 |
1 |
final Sequence aseq1 = new Sequence("Seq1", "-P-R"); |
107 |
1 |
aseq1.createDatasetSequence(); |
108 |
1 |
final Sequence aseq2 = new Sequence("Seq2", "-LY-Q"); |
109 |
1 |
aseq2.createDatasetSequence(); |
110 |
|
|
111 |
|
|
112 |
|
|
113 |
|
|
114 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
115 |
|
|
116 |
1 |
assertNull(acf.getMappedRegion(seq1, aseq1, 1)); |
117 |
|
|
118 |
|
|
119 |
|
|
120 |
|
|
121 |
|
|
122 |
1 |
MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, new int[] { |
123 |
|
1, 2 }, 3, 1); |
124 |
1 |
acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); |
125 |
1 |
map = new MapList(new int[] { 1, 2, 4, 5, 7, 8 }, new int[] { 1, 2 }, |
126 |
|
3, 1); |
127 |
1 |
acf.addMap(seq2.getDatasetSequence(), aseq2.getDatasetSequence(), map); |
128 |
|
|
129 |
1 |
assertArrayEquals(new int[] { 2, 4 }, |
130 |
|
acf.getMappedRegion(seq1, aseq1, 1)); |
131 |
1 |
assertArrayEquals(new int[] { 6, 6, 8, 9 }, |
132 |
|
acf.getMappedRegion(seq1, aseq1, 2)); |
133 |
1 |
assertArrayEquals(new int[] { 1, 2, 4, 4 }, |
134 |
|
acf.getMappedRegion(seq2, aseq2, 1)); |
135 |
1 |
assertArrayEquals(new int[] { 5, 5, 7, 8 }, |
136 |
|
acf.getMappedRegion(seq2, aseq2, 2)); |
137 |
|
|
138 |
|
|
139 |
|
|
140 |
|
|
141 |
1 |
assertNull(acf.getMappedRegion(seq2, aseq2, 3)); |
142 |
|
|
143 |
|
|
144 |
|
|
145 |
|
|
146 |
1 |
assertNull(acf.getMappedRegion(seq1, aseq2, 1)); |
147 |
|
} |
148 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 1 |
Complexity Density: 0.09 |
1PASS
|
|
149 |
1 |
@Test(groups = { "Functional" })... |
150 |
|
public void testGetMappedCodons() |
151 |
|
{ |
152 |
1 |
final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); |
153 |
1 |
seq1.createDatasetSequence(); |
154 |
1 |
final Sequence aseq1 = new Sequence("Seq1", "-V-L"); |
155 |
1 |
aseq1.createDatasetSequence(); |
156 |
|
|
157 |
|
|
158 |
|
|
159 |
|
|
160 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
161 |
|
|
162 |
1 |
assertNull(acf.getMappedCodons(seq1.getDatasetSequence(), 0)); |
163 |
|
|
164 |
|
|
165 |
|
|
166 |
|
|
167 |
1 |
MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, new int[] { |
168 |
|
1, 2 }, 3, 1); |
169 |
1 |
acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); |
170 |
|
|
171 |
1 |
assertEquals(1, acf.getMappedCodons(aseq1.getDatasetSequence(), 1) |
172 |
|
.size()); |
173 |
1 |
assertEquals( |
174 |
|
"[G, T, A]", |
175 |
|
Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), |
176 |
|
1).get(0))); |
177 |
1 |
assertEquals( |
178 |
|
"[C, T, T]", |
179 |
|
Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), |
180 |
|
2).get(0))); |
181 |
|
} |
182 |
|
|
183 |
|
|
184 |
|
|
185 |
|
|
186 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (17) |
Complexity: 1 |
Complexity Density: 0.06 |
1PASS
|
|
187 |
1 |
@Test(groups = { "Functional" })... |
188 |
|
public void testGetMappedCodons_dnaVariants() |
189 |
|
{ |
190 |
1 |
final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); |
191 |
1 |
seq1.createDatasetSequence(); |
192 |
1 |
final Sequence seq2 = new Sequence("Seq2", "c-G-TT-gT-gT-A"); |
193 |
1 |
seq2.createDatasetSequence(); |
194 |
1 |
final Sequence aseq1 = new Sequence("Seq1", "-V-L"); |
195 |
1 |
aseq1.createDatasetSequence(); |
196 |
|
|
197 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
198 |
|
|
199 |
|
|
200 |
|
|
201 |
|
|
202 |
1 |
MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, new int[] { |
203 |
|
1, 2 }, 3, 1); |
204 |
1 |
acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); |
205 |
1 |
acf.addMap(seq2.getDatasetSequence(), aseq1.getDatasetSequence(), map); |
206 |
|
|
207 |
1 |
assertEquals(2, acf.getMappedCodons(aseq1.getDatasetSequence(), 1) |
208 |
|
.size()); |
209 |
1 |
List<char[]> codonsForV = acf.getMappedCodons( |
210 |
|
aseq1.getDatasetSequence(), 1); |
211 |
1 |
assertEquals("[G, T, A]", Arrays.toString(codonsForV.get(0))); |
212 |
1 |
assertEquals("[G, T, T]", Arrays.toString(codonsForV.get(1))); |
213 |
1 |
List<char[]> codonsForL = acf.getMappedCodons( |
214 |
|
aseq1.getDatasetSequence(), 2); |
215 |
1 |
assertEquals("[C, T, T]", Arrays.toString(codonsForL.get(0))); |
216 |
1 |
assertEquals("[T, T, A]", Arrays.toString(codonsForL.get(1))); |
217 |
|
} |
218 |
|
|
219 |
|
|
220 |
|
|
221 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (9) |
Complexity: 1 |
Complexity Density: 0.11 |
1PASS
|
|
222 |
1 |
@Test(groups = { "Functional" })... |
223 |
|
public void testGetMappedCodons_forSubSequences() |
224 |
|
{ |
225 |
1 |
final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T", 27, 35); |
226 |
1 |
seq1.createDatasetSequence(); |
227 |
|
|
228 |
1 |
final Sequence aseq1 = new Sequence("Seq1", "-V-L", 12, 13); |
229 |
1 |
aseq1.createDatasetSequence(); |
230 |
|
|
231 |
|
|
232 |
|
|
233 |
|
|
234 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
235 |
1 |
MapList map = new MapList(new int[] { 28, 30, 32, 32, 34, 35 }, |
236 |
|
new int[] { 12, 13 }, 3, 1); |
237 |
1 |
acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); |
238 |
|
|
239 |
1 |
assertEquals( |
240 |
|
"[G, T, A]", |
241 |
|
Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), |
242 |
|
12).get(0))); |
243 |
1 |
assertEquals( |
244 |
|
"[C, T, T]", |
245 |
|
Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), |
246 |
|
13).get(0))); |
247 |
|
} |
248 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (17) |
Complexity: 1 |
Complexity Density: 0.06 |
1PASS
|
|
249 |
1 |
@Test(groups = { "Functional" })... |
250 |
|
public void testCouldReplaceSequence() |
251 |
|
{ |
252 |
1 |
SequenceI seq1 = new Sequence("Seq1/10-21", "aaacccgggttt"); |
253 |
1 |
SequenceI seq1proxy = new SequenceDummy("Seq1"); |
254 |
|
|
255 |
|
|
256 |
1 |
assertTrue(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 12, |
257 |
|
17)); |
258 |
|
|
259 |
1 |
assertTrue(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 5, |
260 |
|
10)); |
261 |
1 |
assertTrue(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 21, |
262 |
|
26)); |
263 |
|
|
264 |
1 |
assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 4, |
265 |
|
9)); |
266 |
|
|
267 |
1 |
assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 22, |
268 |
|
27)); |
269 |
|
|
270 |
|
|
271 |
|
|
272 |
|
|
273 |
1 |
seq1proxy.setName("Seq1a"); |
274 |
1 |
assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 12, |
275 |
|
17)); |
276 |
1 |
seq1proxy.setName("Seq1"); |
277 |
1 |
seq1.setName("Seq1a"); |
278 |
1 |
assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 12, |
279 |
|
17)); |
280 |
|
|
281 |
|
|
282 |
|
|
283 |
|
|
284 |
1 |
assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1, seq1proxy, 12, |
285 |
|
17)); |
286 |
|
|
287 |
|
|
288 |
|
|
289 |
|
|
290 |
1 |
SequenceI seq1proxy2 = new SequenceDummy("Seq1"); |
291 |
1 |
assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, |
292 |
|
seq1proxy2, 12, 17)); |
293 |
|
|
294 |
|
|
295 |
|
|
296 |
|
|
297 |
1 |
SequenceI seq1a = new Sequence("Seq1/10-21", "aaacccgggttt"); |
298 |
1 |
assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1, seq1a, 12, 17)); |
299 |
|
} |
300 |
|
|
301 |
|
|
302 |
|
|
303 |
|
|
304 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (26) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
305 |
1 |
@Test(groups = { "Functional" })... |
306 |
|
public void testIsRealisableWith() |
307 |
|
{ |
308 |
1 |
SequenceI seq1 = new Sequence("Seq1", "tttaaaCCCGGGtttaaa"); |
309 |
1 |
SequenceI seq2 = new Sequence("Seq2", "PG"); |
310 |
1 |
SequenceI seq1proxy = new SequenceDummy("Seq1"); |
311 |
1 |
seq1.createDatasetSequence(); |
312 |
1 |
seq2.createDatasetSequence(); |
313 |
1 |
MapList mapList = new MapList(new int[] { 7, 12 }, new int[] { 2, 3 }, |
314 |
|
3, 1); |
315 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
316 |
1 |
acf.addMap(seq1proxy, seq2, mapList); |
317 |
|
|
318 |
|
|
319 |
|
|
320 |
|
|
321 |
|
|
322 |
1 |
assertTrue(acf.isRealisableWith(seq1)); |
323 |
|
|
324 |
|
|
325 |
|
|
326 |
|
|
327 |
1 |
seq1proxy.setName("Seq1a"); |
328 |
1 |
assertFalse(acf.isRealisableWith(seq1)); |
329 |
1 |
seq1proxy.setName("Seq1"); |
330 |
|
|
331 |
1 |
SequenceI seq1ds = seq1.getDatasetSequence(); |
332 |
1 |
seq1ds.setName("Seq1a"); |
333 |
1 |
assertFalse(acf.isRealisableWith(seq1)); |
334 |
1 |
seq1ds.setName("Seq1"); |
335 |
|
|
336 |
|
|
337 |
|
|
338 |
|
|
339 |
|
|
340 |
1 |
seq1ds.setStart(1); |
341 |
1 |
seq1ds.setEnd(6); |
342 |
|
|
343 |
1 |
assertFalse(acf.isRealisableWith(seq1)); |
344 |
1 |
seq1ds.setEnd(7); |
345 |
|
|
346 |
1 |
assertTrue(acf.isRealisableWith(seq1)); |
347 |
1 |
seq1ds.setStart(13); |
348 |
1 |
seq1ds.setEnd(18); |
349 |
|
|
350 |
1 |
assertFalse(acf.isRealisableWith(seq1)); |
351 |
1 |
seq1ds.setStart(12); |
352 |
|
|
353 |
1 |
assertTrue(acf.isRealisableWith(seq1)); |
354 |
|
} |
355 |
|
|
356 |
|
|
357 |
|
|
358 |
|
|
359 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (21) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
360 |
1 |
@Test(groups = { "Functional" })... |
361 |
|
public void testRealiseWith() |
362 |
|
{ |
363 |
1 |
SequenceI seq1 = new Sequence("Seq1", "tttCAACCCGGGtttaaa"); |
364 |
1 |
SequenceI seq2 = new Sequence("Seq2", "QPG"); |
365 |
1 |
SequenceI seq2a = new Sequence("Seq2a", "QPG"); |
366 |
1 |
SequenceI seq1proxy = new SequenceDummy("Seq1"); |
367 |
1 |
seq1.createDatasetSequence(); |
368 |
1 |
seq2.createDatasetSequence(); |
369 |
1 |
seq2a.createDatasetSequence(); |
370 |
|
|
371 |
|
|
372 |
|
|
373 |
|
|
374 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
375 |
|
|
376 |
|
|
377 |
1 |
MapList mapping1 = new MapList(new int[] { 7, 12 }, new int[] { 2, 3 }, |
378 |
|
3, 1); |
379 |
1 |
acf.addMap(seq1proxy, seq2, mapping1); |
380 |
1 |
acf.addMap(seq1proxy, seq2a, mapping1); |
381 |
|
|
382 |
|
|
383 |
1 |
MapList mapping2 = new MapList(new int[] { 4, 9 }, new int[] { 1, 2 }, |
384 |
|
3, 1); |
385 |
1 |
acf.addMap(seq1proxy, seq2, mapping2); |
386 |
1 |
acf.addMap(seq1proxy, seq2a, mapping2); |
387 |
|
|
388 |
|
|
389 |
|
|
390 |
|
|
391 |
1 |
assertEquals(2, acf.getdnaSeqs().length); |
392 |
1 |
assertSame(seq1proxy, acf.getdnaSeqs()[0]); |
393 |
1 |
assertSame(seq1proxy, acf.getdnaSeqs()[1]); |
394 |
1 |
assertEquals(2, acf.getProtMappings().length); |
395 |
|
|
396 |
|
|
397 |
|
|
398 |
1 |
assertEquals(2, acf.realiseWith(seq1)); |
399 |
1 |
assertSame(seq1.getDatasetSequence(), acf.getdnaSeqs()[0]); |
400 |
1 |
assertSame(seq1.getDatasetSequence(), acf.getdnaSeqs()[1]); |
401 |
|
} |
402 |
|
|
403 |
|
|
404 |
|
|
405 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (21) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
406 |
1 |
@Test(groups = { "Functional" })... |
407 |
|
public void testGetMappedRegion_eitherWay() |
408 |
|
{ |
409 |
1 |
final Sequence seq1 = new Sequence("Seq1", "AAACCCGGGTTT"); |
410 |
1 |
seq1.createDatasetSequence(); |
411 |
1 |
final Sequence seq2 = new Sequence("Seq2", "KPGF"); |
412 |
1 |
seq2.createDatasetSequence(); |
413 |
1 |
final Sequence seq3 = new Sequence("Seq3", "QYKPGFSW"); |
414 |
1 |
seq3.createDatasetSequence(); |
415 |
|
|
416 |
|
|
417 |
|
|
418 |
|
|
419 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
420 |
1 |
MapList map = new MapList(new int[] { 1, 12 }, new int[] { 1, 4 }, 3, 1); |
421 |
1 |
acf.addMap(seq1.getDatasetSequence(), seq2.getDatasetSequence(), map); |
422 |
1 |
map = new MapList(new int[] { 1, 12 }, new int[] { 3, 6 }, 3, 1); |
423 |
1 |
acf.addMap(seq1.getDatasetSequence(), seq3.getDatasetSequence(), map); |
424 |
|
|
425 |
|
|
426 |
|
|
427 |
|
|
428 |
1 |
map = new MapList(new int[] { 3, 6 }, new int[] { 1, 4 }, 1, 1); |
429 |
1 |
acf.addMap(seq3.getDatasetSequence(), seq2.getDatasetSequence(), map); |
430 |
|
|
431 |
|
|
432 |
|
|
433 |
|
|
434 |
1 |
assertArrayEquals(new int[] { 4, 6 }, |
435 |
|
acf.getMappedRegion(seq1, seq2, 2)); |
436 |
1 |
assertArrayEquals(new int[] { 7, 9 }, |
437 |
|
acf.getMappedRegion(seq1, seq3, 5)); |
438 |
1 |
assertNull(acf.getMappedRegion(seq1, seq3, 1)); |
439 |
|
|
440 |
|
|
441 |
|
|
442 |
|
|
443 |
1 |
assertArrayEquals(new int[] { 4, 4 }, |
444 |
|
acf.getMappedRegion(seq3, seq2, 2)); |
445 |
|
|
446 |
|
|
447 |
|
|
448 |
|
|
449 |
1 |
assertArrayEquals(new int[] { 2, 2 }, |
450 |
|
acf.getMappedRegion(seq2, seq3, 4)); |
451 |
|
|
452 |
|
|
453 |
|
|
454 |
|
|
455 |
|
|
456 |
1 |
assertArrayEquals(new int[] { 2, 2 }, |
457 |
|
acf.getMappedRegion(seq2, seq1, 4)); |
458 |
1 |
assertArrayEquals(new int[] { 2, 2 }, |
459 |
|
acf.getMappedRegion(seq2, seq1, 5)); |
460 |
1 |
assertArrayEquals(new int[] { 2, 2 }, |
461 |
|
acf.getMappedRegion(seq2, seq1, 6)); |
462 |
|
} |
463 |
|
|
464 |
|
|
465 |
|
|
466 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (12) |
Complexity: 1 |
Complexity Density: 0.08 |
1PASS
|
|
467 |
1 |
@Test(groups = { "Functional" })... |
468 |
|
public void testAddMap() |
469 |
|
{ |
470 |
1 |
final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); |
471 |
1 |
seq1.createDatasetSequence(); |
472 |
1 |
final Sequence aseq1 = new Sequence("Seq1", "-V-L"); |
473 |
1 |
aseq1.createDatasetSequence(); |
474 |
|
|
475 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
476 |
1 |
MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, new int[] { |
477 |
|
1, 2 }, 3, 1); |
478 |
1 |
acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); |
479 |
1 |
assertEquals(1, acf.getMappingsFromSequence(seq1).size()); |
480 |
1 |
Mapping before = acf.getMappingsFromSequence(seq1).get(0); |
481 |
|
|
482 |
|
|
483 |
|
|
484 |
|
|
485 |
1 |
acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); |
486 |
1 |
assertEquals(1, acf.getMappingsFromSequence(seq1).size()); |
487 |
1 |
assertSame(before, acf.getMappingsFromSequence(seq1).get(0)); |
488 |
|
} |
489 |
|
} |