1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
|
|
19 |
|
|
20 |
|
|
21 |
|
package jalview.analysis; |
22 |
|
|
23 |
|
import static org.testng.AssertJUnit.assertEquals; |
24 |
|
import static org.testng.AssertJUnit.assertNotNull; |
25 |
|
import static org.testng.AssertJUnit.assertTrue; |
26 |
|
|
27 |
|
import jalview.api.AlignViewportI; |
28 |
|
import jalview.datamodel.AlignedCodon; |
29 |
|
import jalview.datamodel.Alignment; |
30 |
|
import jalview.datamodel.AlignmentI; |
31 |
|
import jalview.datamodel.HiddenColumns; |
32 |
|
import jalview.datamodel.Sequence; |
33 |
|
import jalview.datamodel.SequenceI; |
34 |
|
import jalview.gui.AlignViewport; |
35 |
|
import jalview.gui.JvOptionPane; |
36 |
|
import jalview.io.DataSourceType; |
37 |
|
import jalview.io.FileFormat; |
38 |
|
import jalview.io.FormatAdapter; |
39 |
|
|
40 |
|
import java.io.IOException; |
41 |
|
import java.util.Iterator; |
42 |
|
|
43 |
|
import org.testng.annotations.BeforeClass; |
44 |
|
import org.testng.annotations.Test; |
45 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (226) |
Complexity: 23 |
Complexity Density: 0.12 |
|
46 |
|
public class DnaTest |
47 |
|
{ |
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
48 |
1 |
@BeforeClass(alwaysRun = true)... |
49 |
|
public void setUpJvOptionPane() |
50 |
|
{ |
51 |
1 |
JvOptionPane.setInteractiveMode(false); |
52 |
1 |
JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); |
53 |
|
} |
54 |
|
|
55 |
|
|
56 |
|
|
57 |
|
private static String fasta = ">B\n" + "GCT" + "GCC" + "GCA" + "GCG" |
58 |
|
+ "TGT" + "TGC" + "GAT" + "GAC" + "GAA" + "GAG" + "TTT" + "TTC" |
59 |
|
+ "GGT" + "GGC" + "GGA" + "GGG" + "CAT" + "CAC" + "ATT" + "ATC" |
60 |
|
+ "ATA" + "AAA" + "AAG" + "TTG" + "TTA" + "CTT" + "CTC" + "CTA" |
61 |
|
+ "CTG" + "ATG" + "AAT" + "AAC" + "CCT" + "CCC" + "CCA" + "CCG" |
62 |
|
+ "CAA" + "CAG" + "CGT" + "CGC" + "CGA" + "CGG" + "AGA" + "AGG" |
63 |
|
+ "TCT" + "TCC" + "TCA" + "TCG" + "AGT" + "AGC" + "ACT" + "ACC" |
64 |
|
+ "ACA" + "ACG" + "GTT" + "GTC" + "GTA" + "GTG" + "TGG" + "TAT" |
65 |
|
+ "TAC" + "TAA" + "TAG" + "TGA"; |
66 |
|
|
67 |
|
private static String JAL_1312_example_align_fasta = ">B.FR.83.HXB2_LAI_IIIB_BRU_K03455/45-306\n" |
68 |
|
+ "ATGGGAAAAAATTCGGTTAAGGCCAGGGGGAAAGAAAAAATATAAATTAAAACATATAGTATGGGCAAGCAG\n" |
69 |
|
+ "GGAGCTAGAACGATTCGCAGTTAATCCTGGCCTGTTAGAAACATCAGAAGGCTGTAGACAAATACTGGGACA\n" |
70 |
|
+ "GCTACAACCATCCCTTCAGACAGGATCAGAAGAACTTAGATCATTATATAATACAGTAGCAACCCTCTATTG\n" |
71 |
|
+ "TGTGCATCAAAGGATAGAGATAAAAGACACCAAGGAAGCTTTAGAC\n" |
72 |
|
+ ">gi|27804621|gb|AY178912.1|/1-259\n" |
73 |
|
+ "-TGGGAGAA-ATTCGGTT-CGGCCAGGGGGAAAGAAAAAATATCAGTTAAAACATATAGTATGGGCAAGCAG\n" |
74 |
|
+ "AGAGCTAGAACGATTCGCAGTTAACCCTGGCCTTTTAGAGACATCACAAGGCTGTAGACAAATACTGGGACA\n" |
75 |
|
+ "GCTACAACCATCCCTTCAGACAGGATCAGAAGAACTTAAATCATTATATAATACAGTAGCAACCCTCTATTG\n" |
76 |
|
+ "TGTTCATCAAAGGATAGATATAAAAGACACCAAGGAAGCTTTAGAT\n" |
77 |
|
+ ">gi|27804623|gb|AY178913.1|/1-259\n" |
78 |
|
+ "-TGGGAGAA-ATTCGGTT-CGGCCAGGGGGAAAGAAAAAATATCAGTTAAAACATATAGTATGGGCAAGCAG\n" |
79 |
|
+ "AGAGCTAGAACGATTCGCAGTTAACCCTGGCCTTTTAGAGACATCACAAGGCTGTAGACAAATACTGGAACA\n" |
80 |
|
+ "GCTACAACCATCCCTTCAGACAGGATCAGAAGAACTTAAATCATTATATAATACAGTAGCAACCCTCTATTG\n" |
81 |
|
+ "TGTTCATCAAAGGATAGATGTAAAAGACACCAAGGAAGCTTTAGAT\n" |
82 |
|
+ ">gi|27804627|gb|AY178915.1|/1-260\n" |
83 |
|
+ "-TGGGAAAA-ATTCGGTTAAGGCCAGGGGGAAAGAAAAAATATAAGTTAAAACATATAGTATGGGCAAGCAG\n" |
84 |
|
+ "GGAGCTAGAACGATTCGCAGTTAACCCTGGCCTGTTAGAAACATCAGAAGGTTGTAGACAAATATTGGGACA\n" |
85 |
|
+ "GCTACAACCATCCCTTGAGACAGGATCAGAAGAACTTAAATCATTATWTAATACCATAGCAGTCCTCTATTG\n" |
86 |
|
+ "TGTACATCAAAGGATAGATATAAAAGACACCAAGGAAGCTTTAGAG\n" |
87 |
|
+ ">gi|27804631|gb|AY178917.1|/1-261\n" |
88 |
|
+ "-TGGGAAAAAATTCGGTTGAGGCCAGGGGGAAAGAAAAAATATAAGTTAAAACATATAGTATGGGCAAGCAG\n" |
89 |
|
+ "GGAGCTAGAACGATTCGCAGTCAACCCTGGCCTGTTAGAAACACCAGAAGGCTGTAGACAAATACTGGGACA\n" |
90 |
|
+ "GCTACAACCGTCCCTTCAGACAGGATCGGAAGAACTTAAATCATTATATAATACAGTAGCAACCCTCTATTG\n" |
91 |
|
+ "TGTGCATCAAAGGATAGATGTAAAAGACACCAAGGAGGCTTTAGAC\n" |
92 |
|
+ ">gi|27804635|gb|AY178919.1|/1-261\n" |
93 |
|
+ "-TGGGAGAGAATTCGGTTACGGCCAGGAGGAAAGAAAAAATATAAATTGAAACATATAGTATGGGCAGGCAG\n" |
94 |
|
+ "AGAGCTAGATCGATTCGCAGTCAATCCTGGCCTGTTAGAAACATCAGAAGGCTGCAGACAGATATTGGGACA\n" |
95 |
|
+ "GCTACAACCGTCCCTTAAGACAGGATCAGAAGAACTTAAATCATTATATAATACAGTAGCAACCCTCTATTG\n" |
96 |
|
+ "TGTACATCAAAGGATAGATGTAAAAGACACCAAGGAAGCTTTAGAT\n" |
97 |
|
+ ">gi|27804641|gb|AY178922.1|/1-261\n" |
98 |
|
+ "-TGGGAGAAAATTCGGTTACGGCCAGGGGGAAAGAAAAGATATAAGTTAAAACATATAGTATGGGCAAGCAG\n" |
99 |
|
+ "GGAGCTAGAACGATTCGCAGTCAACCCTGGCCTGTTAGAAACATCAGAAGGCTGCAGACAAATACTGGGACA\n" |
100 |
|
+ "GTTACACCCATCCCTTCATACAGGATCAGAAGAACTTAAATCATTATATAATACAGTAGCAACCCTCTATTG\n" |
101 |
|
+ "TGTGCATCAAAGGATAGAAGTAAAAGACACCAAGGAAGCTTTAGAC\n" |
102 |
|
+ ">gi|27804647|gb|AY178925.1|/1-261\n" |
103 |
|
+ "-TGGGAAAAAATTCGGTTAAGGCCAGGGGGAAAGAAAAAATATCAATTAAAACATGTAGTATGGGCAAGCAG\n" |
104 |
|
+ "GGAACTAGAACGATTCGCAGTTAATCCTGGCCTGTTAGAAACATCAGAAGGCTGTAGACAAATATTGGGACA\n" |
105 |
|
+ "GCTACAACCATCCCTTCAGACAGGATCAGAGGAACTTAAATCATTATTTAATACAGTAGCAGTCCTCTATTG\n" |
106 |
|
+ "TGTACATCAAAGAATAGATGTAAAAGACACCAAGGAAGCTCTAGAA\n" |
107 |
|
+ ">gi|27804649|gb|AY178926.1|/1-261\n" |
108 |
|
+ "-TGGGAAAAAATTCGGTTAAGGCCAGGGGGAAAGAAAAAATATAAGTTAAAACATATAGTATGGGCAAGCAG\n" |
109 |
|
+ "GGAGCTAGAACGATTCGCGGTCAATCCTGGCCTGTTAGAAACATCAGAAGGCTGTAGACAACTACTGGGACA\n" |
110 |
|
+ "GTTACAACCATCCCTTCAGACAGGATCAGAAGAACTCAAATCATTATATAATACAATAGCAACCCTCTATTG\n" |
111 |
|
+ "TGTGCATCAAAGGATAGAGATAAAAGACACCAAGGAAGCCTTAGAT\n" |
112 |
|
+ ">gi|27804653|gb|AY178928.1|/1-261\n" |
113 |
|
+ "-TGGGAAAGAATTCGGTTAAGGCCAGGGGGAAAGAAACAATATAAATTAAAACATATAGTATGGGCAAGCAG\n" |
114 |
|
+ "GGAGCTAGACCGATTCGCACTTAACCCCGGCCTGTTAGAAACATCAGAAGGCTGTAGACAAATATTGGGACA\n" |
115 |
|
+ "GCTACAATCGTCCCTTCAGACAGGATCAGAAGAACTTAGATCACTATATAATACAGTAGCAGTCCTCTATTG\n" |
116 |
|
+ "TGTGCATCAAAAGATAGATGTAAAAGACACCAAGGAAGCCTTAGAC\n" |
117 |
|
+ ">gi|27804659|gb|AY178931.1|/1-261\n" |
118 |
|
+ "-TGGGAAAAAATTCGGTTACGGCCAGGAGGAAAGAAAAGATATAAATTAAAACATATAGTATGGGCAAGCAG\n" |
119 |
|
+ "GGAGCTAGAACGATTYGCAGTTAATCCTGGCCTTTTAGAAACAGCAGAAGGCTGTAGACAAATACTGGGACA\n" |
120 |
|
+ "GCTACAACCATCCCTTCAGACAGGATCAGAAGAACTTAAATCATTATATAATACAGTAGCAACCCTCTATTG\n" |
121 |
|
+ "TGTACATCAAAGGATAGAGATAAAAGACACCAAGGAAGCTTTAGAA\n"; |
122 |
|
|
123 |
|
|
124 |
|
|
125 |
|
|
126 |
|
|
127 |
|
|
128 |
|
@throws |
129 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0.14 |
1PASS
|
|
130 |
1 |
@Test(groups = { "Functional" })... |
131 |
|
public void testTranslateCdna_withUntranslatableCodons() |
132 |
|
throws IOException |
133 |
|
{ |
134 |
1 |
AlignmentI alf = new FormatAdapter().readFile( |
135 |
|
JAL_1312_example_align_fasta, DataSourceType.PASTE, |
136 |
|
FileFormat.Fasta); |
137 |
1 |
HiddenColumns cs = new HiddenColumns(); |
138 |
1 |
AlignViewportI av = new AlignViewport(alf, cs); |
139 |
1 |
Iterator<int[]> contigs = cs.getVisContigsIterator(0, alf.getWidth(), |
140 |
|
false); |
141 |
1 |
Dna dna = new Dna(av, contigs); |
142 |
1 |
AlignmentI translated = dna.translateCdna(); |
143 |
1 |
assertNotNull("Couldn't do a full width translation of test data.", |
144 |
|
translated); |
145 |
|
} |
146 |
|
|
147 |
|
|
148 |
|
|
149 |
|
|
150 |
|
|
151 |
|
@throws |
152 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (18) |
Complexity: 3 |
Complexity Density: 0.21 |
1PASS
|
|
153 |
1 |
@Test(groups = { "Functional" })... |
154 |
|
public void testTranslateCdna_withUntranslatableCodonsAndHiddenColumns() |
155 |
|
throws IOException |
156 |
|
{ |
157 |
1 |
AlignmentI alf = new FormatAdapter().readFile( |
158 |
|
JAL_1312_example_align_fasta, DataSourceType.PASTE, |
159 |
|
FileFormat.Fasta); |
160 |
1 |
int vwidth = 15; |
161 |
18 |
for (int ipos = 0; ipos + vwidth < alf.getWidth(); ipos += vwidth) |
162 |
|
{ |
163 |
17 |
HiddenColumns cs = new HiddenColumns(); |
164 |
17 |
if (ipos > 0) |
165 |
|
{ |
166 |
16 |
cs.hideColumns(0, ipos - 1); |
167 |
|
} |
168 |
17 |
cs.hideColumns(ipos + vwidth, alf.getWidth()); |
169 |
17 |
Iterator<int[]> vcontigs = cs.getVisContigsIterator(0, |
170 |
|
alf.getWidth(), false); |
171 |
17 |
AlignViewportI av = new AlignViewport(alf, cs); |
172 |
17 |
Dna dna = new Dna(av, vcontigs); |
173 |
17 |
AlignmentI transAlf = dna.translateCdna(); |
174 |
|
|
175 |
17 |
assertTrue("Translation failed (ipos=" + ipos |
176 |
|
+ ") No alignment data.", transAlf != null); |
177 |
17 |
assertTrue("Translation failed (ipos=" + ipos + ") Empty alignment.", |
178 |
|
transAlf.getHeight() > 0); |
179 |
17 |
assertTrue("Translation failed (ipos=" + ipos + ") Translated " |
180 |
|
+ transAlf.getHeight() + " sequences from " + alf.getHeight() |
181 |
|
+ " sequences", alf.getHeight() == transAlf.getHeight()); |
182 |
|
} |
183 |
|
} |
184 |
|
|
185 |
|
|
186 |
|
|
187 |
|
|
188 |
|
@throws |
189 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 1 |
Complexity Density: 0.12 |
1PASS
|
|
190 |
1 |
@Test(groups = { "Functional" })... |
191 |
|
public void testTranslateCdna_simple() throws IOException |
192 |
|
{ |
193 |
1 |
AlignmentI alf = new FormatAdapter().readFile(fasta, |
194 |
|
DataSourceType.PASTE, FileFormat.Fasta); |
195 |
1 |
HiddenColumns cs = new HiddenColumns(); |
196 |
1 |
AlignViewportI av = new AlignViewport(alf, cs); |
197 |
1 |
Iterator<int[]> contigs = cs.getVisContigsIterator(0, alf.getWidth(), |
198 |
|
false); |
199 |
1 |
Dna dna = new Dna(av, contigs); |
200 |
1 |
AlignmentI translated = dna.translateCdna(); |
201 |
1 |
String aa = translated.getSequenceAt(0).getSequenceAsString(); |
202 |
1 |
assertEquals( |
203 |
|
"AAAACCDDEEFFGGGGHHIIIKKLLLLLLMNNPPPPQQRRRRRRSSSSSSTTTTVVVVWYY***", |
204 |
|
aa); |
205 |
|
} |
206 |
|
|
207 |
|
|
208 |
|
|
209 |
|
|
210 |
|
@throws |
211 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 1 |
Complexity Density: 0.09 |
1PASS
|
|
212 |
1 |
@Test(groups = { "Functional" })... |
213 |
|
public void testTranslateCdna_hiddenColumns() throws IOException |
214 |
|
{ |
215 |
1 |
AlignmentI alf = new FormatAdapter().readFile(fasta, |
216 |
|
DataSourceType.PASTE, FileFormat.Fasta); |
217 |
1 |
HiddenColumns cs = new HiddenColumns(); |
218 |
1 |
cs.hideColumns(6, 14); |
219 |
1 |
cs.hideColumns(24, 35); |
220 |
1 |
cs.hideColumns(177, 191); |
221 |
1 |
AlignViewportI av = new AlignViewport(alf, cs); |
222 |
1 |
Iterator<int[]> contigs = cs.getVisContigsIterator(0, alf.getWidth(), |
223 |
|
false); |
224 |
1 |
Dna dna = new Dna(av, contigs); |
225 |
1 |
AlignmentI translated = dna.translateCdna(); |
226 |
1 |
String aa = translated.getSequenceAt(0).getSequenceAsString(); |
227 |
1 |
assertEquals("AACDDGGGGHHIIIKKLLLLLLMNNPPPPQQRRRRRRSSSSSSTTTTVVVVW", aa); |
228 |
|
} |
229 |
|
|
230 |
|
|
231 |
|
|
232 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
1PASS
|
|
233 |
1 |
@Test(groups = { "Functional" })... |
234 |
|
public void testCompareCodonPos_oneOnly() |
235 |
|
{ |
236 |
1 |
assertFollows("-AA--A", "G--GG"); |
237 |
|
} |
238 |
|
|
239 |
|
|
240 |
|
|
241 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (29) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
242 |
1 |
@Test(groups = { "Functional" })... |
243 |
|
public void testCompareCodonPos() |
244 |
|
{ |
245 |
|
|
246 |
|
|
247 |
|
|
248 |
1 |
assertEquals(0, Dna.compareCodonPos(new AlignedCodon(1, 2, 3), null)); |
249 |
1 |
assertEquals(0, Dna.compareCodonPos(null, new AlignedCodon(1, 2, 3))); |
250 |
|
|
251 |
|
|
252 |
|
|
253 |
|
|
254 |
1 |
assertMatches("AAA", "GGG"); |
255 |
1 |
assertFollows("AA-A", "GGG"); |
256 |
1 |
assertPrecedes("AAA", "GG-G"); |
257 |
1 |
assertFollows("A-AA", "GG-G"); |
258 |
1 |
assertFollows("A-A-A", "GG-G"); |
259 |
1 |
assertPrecedes("A-AA", "GG--G"); |
260 |
1 |
assertPrecedes("AA-A", "G-GG"); |
261 |
1 |
assertFollows("AA--A", "G-GG"); |
262 |
1 |
assertPrecedes("AAA", "G-GG"); |
263 |
|
|
264 |
|
|
265 |
|
|
266 |
|
|
267 |
1 |
assertFollows("-AAA", "G-GG"); |
268 |
1 |
assertFollows("-AA-A", "G-GG"); |
269 |
|
|
270 |
1 |
assertFollows("-AAA", "G-G-G"); |
271 |
1 |
assertFollows("-A-AA", "G-G-G"); |
272 |
1 |
assertFollows("-A-A-A", "G-G-G"); |
273 |
|
|
274 |
1 |
assertFollows("-A-AA", "G-G--G"); |
275 |
1 |
assertFollows("-AA-A", "G--GG"); |
276 |
1 |
assertFollows("-AA--A", "G--GG"); |
277 |
1 |
assertPrecedes("-AAA", "G--GG"); |
278 |
|
|
279 |
|
|
280 |
|
|
281 |
|
|
282 |
1 |
assertPrecedes("A-AA", "-GGG"); |
283 |
1 |
assertPrecedes("A-A-A", "-GGG"); |
284 |
1 |
assertPrecedes("A-AA", "-GG-G"); |
285 |
1 |
assertPrecedes("A--AA", "-GG-G"); |
286 |
|
|
287 |
1 |
assertFollows("A--AA", "-GGG"); |
288 |
1 |
assertPrecedes("A--AA", "-GG--G"); |
289 |
1 |
assertPrecedes("AA-A", "-GGG"); |
290 |
1 |
assertPrecedes("AA--A", "-GGG"); |
291 |
1 |
assertPrecedes("AAA", "-GGG"); |
292 |
|
} |
293 |
|
|
294 |
|
|
295 |
|
|
296 |
|
|
297 |
|
|
298 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (26) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
299 |
1 |
@Test(groups = { "Functional" })... |
300 |
|
public void testTranslateCdna_sequenceOrderIndependent() |
301 |
|
{ |
302 |
|
|
303 |
|
|
304 |
|
|
305 |
1 |
AlignmentI cdna = new AlignmentGenerator(true) |
306 |
|
.generate(12, 8, 97, 5, 5); |
307 |
1 |
HiddenColumns cs = new HiddenColumns(); |
308 |
1 |
AlignViewportI av = new AlignViewport(cdna, cs); |
309 |
1 |
Iterator<int[]> contigs = cs.getVisContigsIterator(0, cdna.getWidth(), |
310 |
|
false); |
311 |
1 |
Dna dna = new Dna(av, contigs); |
312 |
1 |
AlignmentI translated = dna.translateCdna(); |
313 |
|
|
314 |
|
|
315 |
|
|
316 |
|
|
317 |
1 |
SequenceI[] sorted = new SequenceI[cdna.getHeight()]; |
318 |
1 |
final int[] jumbler = new int[] { 6, 7, 3, 4, 2, 0, 1, 5 }; |
319 |
1 |
int seqNo = 0; |
320 |
1 |
for (int i : jumbler) |
321 |
|
{ |
322 |
8 |
sorted[seqNo++] = cdna.getSequenceAt(i); |
323 |
|
} |
324 |
1 |
AlignmentI cdnaReordered = new Alignment(sorted); |
325 |
1 |
av = new AlignViewport(cdnaReordered, cs); |
326 |
1 |
contigs = cs.getVisContigsIterator(0, cdna.getWidth(), false); |
327 |
1 |
dna = new Dna(av, contigs); |
328 |
1 |
AlignmentI translated2 = dna.translateCdna(); |
329 |
|
|
330 |
|
|
331 |
|
|
332 |
|
|
333 |
1 |
System.out.println("Original"); |
334 |
1 |
System.out.println(translated.toString()); |
335 |
1 |
System.out.println("Sorted"); |
336 |
1 |
System.out.println(translated2.toString()); |
337 |
|
|
338 |
1 |
int sortedSequenceIndex = 0; |
339 |
1 |
for (int originalSequenceIndex : jumbler) |
340 |
|
{ |
341 |
8 |
final String translation1 = translated.getSequenceAt( |
342 |
|
originalSequenceIndex).getSequenceAsString(); |
343 |
8 |
final String translation2 = translated2.getSequenceAt( |
344 |
|
sortedSequenceIndex).getSequenceAsString(); |
345 |
8 |
assertEquals(translation2, translation1); |
346 |
8 |
sortedSequenceIndex++; |
347 |
|
} |
348 |
|
} |
349 |
|
|
350 |
|
|
351 |
|
|
352 |
|
|
353 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (27) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
354 |
1 |
@Test(groups = { "Functional" })... |
355 |
|
public void testCompareCodonPos_isSymmetric() |
356 |
|
{ |
357 |
1 |
assertSymmetric("AAA", "GGG"); |
358 |
1 |
assertSymmetric("AA-A", "GGG"); |
359 |
1 |
assertSymmetric("AAA", "GG-G"); |
360 |
1 |
assertSymmetric("A-AA", "GG-G"); |
361 |
1 |
assertSymmetric("A-A-A", "GG-G"); |
362 |
1 |
assertSymmetric("A-AA", "GG--G"); |
363 |
1 |
assertSymmetric("AA-A", "G-GG"); |
364 |
1 |
assertSymmetric("AA--A", "G-GG"); |
365 |
1 |
assertSymmetric("AAA", "G-GG"); |
366 |
1 |
assertSymmetric("-AAA", "G-GG"); |
367 |
1 |
assertSymmetric("-AA-A", "G-GG"); |
368 |
1 |
assertSymmetric("-AAA", "G-G-G"); |
369 |
1 |
assertSymmetric("-A-AA", "G-G-G"); |
370 |
1 |
assertSymmetric("-A-A-A", "G-G-G"); |
371 |
1 |
assertSymmetric("-A-AA", "G-G--G"); |
372 |
1 |
assertSymmetric("-AA-A", "G--GG"); |
373 |
1 |
assertSymmetric("-AA--A", "G--GG"); |
374 |
1 |
assertSymmetric("-AAA", "G--GG"); |
375 |
1 |
assertSymmetric("A-AA", "-GGG"); |
376 |
1 |
assertSymmetric("A-A-A", "-GGG"); |
377 |
1 |
assertSymmetric("A-AA", "-GG-G"); |
378 |
1 |
assertSymmetric("A--AA", "-GG-G"); |
379 |
1 |
assertSymmetric("A--AA", "-GGG"); |
380 |
1 |
assertSymmetric("A--AA", "-GG--G"); |
381 |
1 |
assertSymmetric("AA-A", "-GGG"); |
382 |
1 |
assertSymmetric("AA--A", "-GGG"); |
383 |
1 |
assertSymmetric("AAA", "-GGG"); |
384 |
|
} |
385 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
386 |
27 |
private void assertSymmetric(String codon1, String codon2)... |
387 |
|
{ |
388 |
27 |
assertEquals("Comparison of '" + codon1 + "' and '" + codon2 |
389 |
|
+ " not symmetric", Integer.signum(compare(codon1, codon2)), |
390 |
|
-Integer.signum(compare(codon2, codon1))); |
391 |
|
} |
392 |
|
|
393 |
|
|
394 |
|
|
395 |
|
|
396 |
|
|
397 |
|
|
398 |
|
@param |
399 |
|
@param |
400 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
401 |
1 |
private void assertMatches(String codon1, String codon2)... |
402 |
|
{ |
403 |
1 |
assertEquals("Expected '" + codon1 + "' matches '" + codon2 + "'", 0, |
404 |
|
compare(codon1, codon2)); |
405 |
1 |
assertEquals("Expected '" + codon2 + "' matches '" + codon1 + "'", 0, |
406 |
|
compare(codon2, codon1)); |
407 |
|
} |
408 |
|
|
409 |
|
|
410 |
|
|
411 |
|
|
412 |
|
|
413 |
|
@param |
414 |
|
@param |
415 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
416 |
13 |
private void assertPrecedes(String codon1, String codon2)... |
417 |
|
{ |
418 |
13 |
assertEquals("Expected '" + codon1 + "' precedes '" + codon2 + "'", |
419 |
|
-1, compare(codon1, codon2)); |
420 |
|
} |
421 |
|
|
422 |
|
|
423 |
|
|
424 |
|
|
425 |
|
|
426 |
|
@param |
427 |
|
@param |
428 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
429 |
14 |
private void assertFollows(String codon1, String codon2)... |
430 |
|
{ |
431 |
14 |
assertEquals("Expected '" + codon1 + "' follows '" + codon2 + "'", 1, |
432 |
|
compare(codon1, codon2)); |
433 |
|
} |
434 |
|
|
435 |
|
|
436 |
|
|
437 |
|
|
438 |
|
|
439 |
|
@param |
440 |
|
@param |
441 |
|
@return |
442 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0.17 |
|
443 |
83 |
private int compare(String s1, String s2)... |
444 |
|
{ |
445 |
83 |
final AlignedCodon cd1 = convertCodon(s1); |
446 |
83 |
final AlignedCodon cd2 = convertCodon(s2); |
447 |
83 |
System.out.println("K: " + s1 + " " + cd1.toString()); |
448 |
83 |
System.out.println("G: " + s2 + " " + cd2.toString()); |
449 |
83 |
System.out.println(); |
450 |
83 |
return Dna.compareCodonPos(cd1, cd2); |
451 |
|
} |
452 |
|
|
453 |
|
|
454 |
|
|
455 |
|
|
456 |
|
|
457 |
|
@param |
458 |
|
@return |
459 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (10) |
Complexity: 3 |
Complexity Density: 0.5 |
|
460 |
169 |
private AlignedCodon convertCodon(String s)... |
461 |
|
{ |
462 |
169 |
int[] codon = new int[3]; |
463 |
169 |
int i = 0; |
464 |
915 |
for (int j = 0; j < s.length(); j++) |
465 |
|
{ |
466 |
746 |
if (s.charAt(j) != '-') |
467 |
|
{ |
468 |
507 |
codon[i++] = j; |
469 |
|
} |
470 |
|
} |
471 |
169 |
return new AlignedCodon(codon[0], codon[1], codon[2]); |
472 |
|
} |
473 |
|
|
474 |
|
|
475 |
|
|
476 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0.33 |
1PASS
|
|
477 |
1 |
@Test(groups = { "Functional" })... |
478 |
|
public void testConvertCodon() |
479 |
|
{ |
480 |
1 |
assertEquals("[0, 1, 2]", convertCodon("AAA").toString()); |
481 |
1 |
assertEquals("[0, 2, 5]", convertCodon("A-A--A").toString()); |
482 |
1 |
assertEquals("[1, 3, 4]", convertCodon("-A-AA-").toString()); |
483 |
|
} |
484 |
|
|
485 |
|
|
486 |
|
|
487 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (27) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
488 |
1 |
@Test(groups = "Functional")... |
489 |
|
public void testGetComplement() |
490 |
|
{ |
491 |
1 |
assertEquals('t', Dna.getComplement('a')); |
492 |
1 |
assertEquals('T', Dna.getComplement('A')); |
493 |
1 |
assertEquals('a', Dna.getComplement('t')); |
494 |
1 |
assertEquals('A', Dna.getComplement('T')); |
495 |
1 |
assertEquals('c', Dna.getComplement('g')); |
496 |
1 |
assertEquals('C', Dna.getComplement('G')); |
497 |
1 |
assertEquals('g', Dna.getComplement('c')); |
498 |
1 |
assertEquals('G', Dna.getComplement('C')); |
499 |
|
|
500 |
1 |
assertEquals('a', Dna.getComplement('u')); |
501 |
1 |
assertEquals('A', Dna.getComplement('U')); |
502 |
|
|
503 |
1 |
assertEquals('r', Dna.getComplement('y')); |
504 |
1 |
assertEquals('R', Dna.getComplement('Y')); |
505 |
1 |
assertEquals('y', Dna.getComplement('r')); |
506 |
1 |
assertEquals('Y', Dna.getComplement('R')); |
507 |
1 |
assertEquals('k', Dna.getComplement('m')); |
508 |
1 |
assertEquals('K', Dna.getComplement('M')); |
509 |
1 |
assertEquals('m', Dna.getComplement('k')); |
510 |
1 |
assertEquals('M', Dna.getComplement('K')); |
511 |
1 |
assertEquals('b', Dna.getComplement('v')); |
512 |
1 |
assertEquals('B', Dna.getComplement('V')); |
513 |
1 |
assertEquals('v', Dna.getComplement('b')); |
514 |
1 |
assertEquals('V', Dna.getComplement('B')); |
515 |
1 |
assertEquals('d', Dna.getComplement('h')); |
516 |
1 |
assertEquals('D', Dna.getComplement('H')); |
517 |
1 |
assertEquals('h', Dna.getComplement('d')); |
518 |
1 |
assertEquals('H', Dna.getComplement('D')); |
519 |
1 |
assertEquals('Q', Dna.getComplement('Q')); |
520 |
|
} |
521 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 1 |
Complexity Density: 0.09 |
1PASS
|
|
522 |
1 |
@Test(groups = "Functional")... |
523 |
|
public void testReverseSequence() |
524 |
|
{ |
525 |
1 |
String seq = "-Ac-GtU--rYkMbVdHNX-"; |
526 |
1 |
String seqRev = new StringBuilder(seq).reverse().toString(); |
527 |
|
|
528 |
|
|
529 |
1 |
SequenceI reversed = Dna.reverseSequence("Seq1", seq, false); |
530 |
1 |
assertEquals(1, reversed.getStart()); |
531 |
1 |
assertEquals(15, reversed.getEnd()); |
532 |
1 |
assertEquals(20, reversed.getLength()); |
533 |
1 |
assertEquals(seqRev, reversed.getSequenceAsString()); |
534 |
1 |
assertEquals("Seq1|rev", reversed.getName()); |
535 |
|
|
536 |
|
|
537 |
1 |
SequenceI revcomp = Dna.reverseSequence("Seq1", seq, true); |
538 |
1 |
assertEquals("-XNDhBvKmRy--AaC-gT-", revcomp.getSequenceAsString()); |
539 |
1 |
assertEquals("Seq1|revcomp", revcomp.getName()); |
540 |
|
} |
541 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (16) |
Complexity: 1 |
Complexity Density: 0.06 |
1PASS
|
|
542 |
1 |
@Test(groups = "Functional")... |
543 |
|
public void testReverseCdna() |
544 |
|
{ |
545 |
1 |
String seq = "-Ac-GtU--rYkMbVdHNX-"; |
546 |
1 |
String seqRev = new StringBuilder(seq).reverse().toString(); |
547 |
1 |
String seqDs = seq.replaceAll("-", ""); |
548 |
1 |
String seqDsRev = new StringBuilder(seqDs).reverse().toString(); |
549 |
|
|
550 |
1 |
SequenceI dna = new Sequence("Seq1", seq); |
551 |
1 |
Alignment al = new Alignment(new SequenceI[] { dna }); |
552 |
1 |
al.createDatasetAlignment(); |
553 |
1 |
assertEquals(seqDs, al.getSequenceAt(0).getDatasetSequence() |
554 |
|
.getSequenceAsString()); |
555 |
|
|
556 |
1 |
HiddenColumns cs = new HiddenColumns(); |
557 |
1 |
AlignViewportI av = new AlignViewport(al, cs); |
558 |
1 |
Iterator<int[]> contigs = cs.getVisContigsIterator(0, al.getWidth(), |
559 |
|
false); |
560 |
1 |
Dna testee = new Dna(av, contigs); |
561 |
1 |
AlignmentI reversed = testee.reverseCdna(false); |
562 |
1 |
assertEquals(1, reversed.getHeight()); |
563 |
1 |
assertEquals(seqRev, reversed.getSequenceAt(0).getSequenceAsString()); |
564 |
1 |
assertEquals(seqDsRev, reversed.getSequenceAt(0).getDatasetSequence() |
565 |
|
.getSequenceAsString()); |
566 |
|
} |
567 |
|
} |