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.assertNull; |
25 |
|
|
26 |
|
import jalview.datamodel.AlignmentAnnotation; |
27 |
|
import jalview.datamodel.Annotation; |
28 |
|
import jalview.datamodel.Profile; |
29 |
|
import jalview.datamodel.ProfileI; |
30 |
|
import jalview.datamodel.ProfilesI; |
31 |
|
import jalview.datamodel.ResidueCount; |
32 |
|
import jalview.datamodel.Sequence; |
33 |
|
import jalview.datamodel.SequenceI; |
34 |
|
import jalview.gui.JvOptionPane; |
35 |
|
|
36 |
|
import java.util.Hashtable; |
37 |
|
|
38 |
|
import org.testng.annotations.BeforeClass; |
39 |
|
import org.testng.annotations.Test; |
40 |
|
|
|
|
| 92.6% |
Uncovered Elements: 15 (204) |
Complexity: 11 |
Complexity Density: 0.06 |
|
41 |
|
public class AAFrequencyTest |
42 |
|
{ |
43 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
44 |
1 |
@BeforeClass(alwaysRun = true)... |
45 |
|
public void setUpJvOptionPane() |
46 |
|
{ |
47 |
1 |
JvOptionPane.setInteractiveMode(false); |
48 |
1 |
JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); |
49 |
|
} |
50 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (33) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
51 |
1 |
@Test(groups = { "Functional" })... |
52 |
|
public void testCalculate_noProfile() |
53 |
|
{ |
54 |
1 |
SequenceI seq1 = new Sequence("Seq1", "CAG-T"); |
55 |
1 |
SequenceI seq2 = new Sequence("Seq2", "CAC-T"); |
56 |
1 |
SequenceI seq3 = new Sequence("Seq3", "C---G"); |
57 |
1 |
SequenceI seq4 = new Sequence("Seq4", "CA--t"); |
58 |
1 |
SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 }; |
59 |
1 |
int width = seq1.getLength(); |
60 |
1 |
ProfilesI result = AAFrequency.calculate(seqs, width, 0, width, |
61 |
|
false); |
62 |
|
|
63 |
|
|
64 |
1 |
ProfileI col = result.get(0); |
65 |
1 |
assertEquals(100f, col.getPercentageIdentity(false)); |
66 |
1 |
assertEquals(100f, col.getPercentageIdentity(true)); |
67 |
1 |
assertEquals(4, col.getMaxCount()); |
68 |
1 |
assertEquals("C", col.getModalResidue()); |
69 |
1 |
assertNull(col.getCounts()); |
70 |
|
|
71 |
|
|
72 |
1 |
col = result.get(1); |
73 |
1 |
assertEquals(75f, col.getPercentageIdentity(false)); |
74 |
1 |
assertEquals(100f, col.getPercentageIdentity(true)); |
75 |
1 |
assertEquals(3, col.getMaxCount()); |
76 |
1 |
assertEquals("A", col.getModalResidue()); |
77 |
|
|
78 |
|
|
79 |
1 |
col = result.get(2); |
80 |
1 |
assertEquals(25f, col.getPercentageIdentity(false)); |
81 |
1 |
assertEquals(50f, col.getPercentageIdentity(true)); |
82 |
1 |
assertEquals(1, col.getMaxCount()); |
83 |
1 |
assertEquals("CG", col.getModalResidue()); |
84 |
|
|
85 |
|
|
86 |
1 |
col = result.get(3); |
87 |
1 |
assertEquals(0f, col.getPercentageIdentity(false)); |
88 |
1 |
assertEquals(0f, col.getPercentageIdentity(true)); |
89 |
1 |
assertEquals(0, col.getMaxCount()); |
90 |
1 |
assertEquals("", col.getModalResidue()); |
91 |
|
|
92 |
|
|
93 |
1 |
col = result.get(4); |
94 |
1 |
assertEquals(75f, col.getPercentageIdentity(false)); |
95 |
1 |
assertEquals(75f, col.getPercentageIdentity(true)); |
96 |
1 |
assertEquals(3, col.getMaxCount()); |
97 |
1 |
assertEquals("T", col.getModalResidue()); |
98 |
|
} |
99 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (25) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
100 |
1 |
@Test(groups = { "Functional" })... |
101 |
|
public void testCalculate_withProfile() |
102 |
|
{ |
103 |
1 |
SequenceI seq1 = new Sequence("Seq1", "CAGT"); |
104 |
1 |
SequenceI seq2 = new Sequence("Seq2", "CACT"); |
105 |
1 |
SequenceI seq3 = new Sequence("Seq3", "C--G"); |
106 |
1 |
SequenceI seq4 = new Sequence("Seq4", "CA-t"); |
107 |
1 |
SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 }; |
108 |
1 |
int width = seq1.getLength(); |
109 |
1 |
ProfilesI result = AAFrequency.calculate(seqs, width, 0, width, |
110 |
|
true); |
111 |
|
|
112 |
1 |
ProfileI profile = result.get(0); |
113 |
1 |
assertEquals(4, profile.getCounts().getCount('C')); |
114 |
1 |
assertEquals(4, profile.getHeight()); |
115 |
1 |
assertEquals(4, profile.getNonGapped()); |
116 |
|
|
117 |
1 |
profile = result.get(1); |
118 |
1 |
assertEquals(3, profile.getCounts().getCount('A')); |
119 |
1 |
assertEquals(4, profile.getHeight()); |
120 |
1 |
assertEquals(3, profile.getNonGapped()); |
121 |
|
|
122 |
1 |
profile = result.get(2); |
123 |
1 |
assertEquals(1, profile.getCounts().getCount('C')); |
124 |
1 |
assertEquals(1, profile.getCounts().getCount('G')); |
125 |
1 |
assertEquals(4, profile.getHeight()); |
126 |
1 |
assertEquals(2, profile.getNonGapped()); |
127 |
|
|
128 |
1 |
profile = result.get(3); |
129 |
1 |
assertEquals(3, profile.getCounts().getCount('T')); |
130 |
1 |
assertEquals(1, profile.getCounts().getCount('G')); |
131 |
1 |
assertEquals(4, profile.getHeight()); |
132 |
1 |
assertEquals(4, profile.getNonGapped()); |
133 |
|
} |
134 |
|
|
|
|
| 0% |
Uncovered Elements: 14 (14) |
Complexity: 2 |
Complexity Density: 0.17 |
1PASS
|
|
135 |
0 |
@Test(groups = { "Functional" }, enabled = false)... |
136 |
|
public void testCalculate_withProfileTiming() |
137 |
|
{ |
138 |
0 |
SequenceI seq1 = new Sequence("Seq1", "CAGT"); |
139 |
0 |
SequenceI seq2 = new Sequence("Seq2", "CACT"); |
140 |
0 |
SequenceI seq3 = new Sequence("Seq3", "C--G"); |
141 |
0 |
SequenceI seq4 = new Sequence("Seq4", "CA-t"); |
142 |
0 |
SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 }; |
143 |
|
|
144 |
|
|
145 |
0 |
int width = seq1.getLength(); |
146 |
0 |
AAFrequency.calculate(seqs, width, 0, width, true); |
147 |
|
|
148 |
0 |
int reps = 100000; |
149 |
0 |
long start = System.currentTimeMillis(); |
150 |
0 |
for (int i = 0; i < reps; i++) |
151 |
|
{ |
152 |
0 |
AAFrequency.calculate(seqs, width, 0, width, true); |
153 |
|
} |
154 |
0 |
System.out.println(System.currentTimeMillis() - start); |
155 |
|
} |
156 |
|
|
157 |
|
|
158 |
|
|
159 |
|
|
160 |
|
|
161 |
|
|
162 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (24) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
163 |
1 |
@Test(groups = { "Functional" })... |
164 |
|
public void testCompleteConsensus_includeGaps_showLogo() |
165 |
|
{ |
166 |
|
|
167 |
|
|
168 |
|
|
169 |
1 |
SequenceI seq1 = new Sequence("Seq1", "CAG-T"); |
170 |
1 |
SequenceI seq2 = new Sequence("Seq2", "CAC-T"); |
171 |
1 |
SequenceI seq3 = new Sequence("Seq3", "C---G"); |
172 |
1 |
SequenceI seq4 = new Sequence("Seq4", "CA--t"); |
173 |
1 |
SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 }; |
174 |
1 |
int width = seq1.getLength(); |
175 |
1 |
ProfilesI profiles = AAFrequency.calculate(seqs, width, 0, width, true); |
176 |
|
|
177 |
1 |
AlignmentAnnotation consensus = new AlignmentAnnotation("Consensus", |
178 |
|
"PID", new Annotation[width]); |
179 |
1 |
AAFrequency |
180 |
|
.completeConsensus(consensus, profiles, 0, 5, false, true, 4); |
181 |
|
|
182 |
1 |
Annotation ann = consensus.annotations[0]; |
183 |
1 |
assertEquals("C 100%", ann.description); |
184 |
1 |
assertEquals("C", ann.displayCharacter); |
185 |
1 |
ann = consensus.annotations[1]; |
186 |
1 |
assertEquals("A 75%", ann.description); |
187 |
1 |
assertEquals("A", ann.displayCharacter); |
188 |
1 |
ann = consensus.annotations[2]; |
189 |
1 |
assertEquals("C 25%; G 25%", ann.description); |
190 |
1 |
assertEquals("+", ann.displayCharacter); |
191 |
1 |
ann = consensus.annotations[3]; |
192 |
1 |
assertEquals("", ann.description); |
193 |
1 |
assertEquals("-", ann.displayCharacter); |
194 |
1 |
ann = consensus.annotations[4]; |
195 |
1 |
assertEquals("T 75%; G 25%", ann.description); |
196 |
1 |
assertEquals("T", ann.displayCharacter); |
197 |
|
} |
198 |
|
|
199 |
|
|
200 |
|
|
201 |
|
|
202 |
|
|
203 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (24) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
204 |
1 |
@Test(groups = { "Functional" })... |
205 |
|
public void testCompleteConsensus_ignoreGaps_noLogo() |
206 |
|
{ |
207 |
|
|
208 |
|
|
209 |
|
|
210 |
1 |
SequenceI seq1 = new Sequence("Seq1", "CAG-T"); |
211 |
1 |
SequenceI seq2 = new Sequence("Seq2", "CAC-T"); |
212 |
1 |
SequenceI seq3 = new Sequence("Seq3", "C---G"); |
213 |
1 |
SequenceI seq4 = new Sequence("Seq4", "CA--t"); |
214 |
1 |
SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3, seq4 }; |
215 |
1 |
int width = seq1.getLength(); |
216 |
1 |
ProfilesI profiles = AAFrequency.calculate(seqs, width, 0, width, true); |
217 |
|
|
218 |
1 |
AlignmentAnnotation consensus = new AlignmentAnnotation("Consensus", |
219 |
|
"PID", new Annotation[width]); |
220 |
1 |
AAFrequency |
221 |
|
.completeConsensus(consensus, profiles, 0, 5, true, false, 4); |
222 |
|
|
223 |
1 |
Annotation ann = consensus.annotations[0]; |
224 |
1 |
assertEquals("C 100%", ann.description); |
225 |
1 |
assertEquals("C", ann.displayCharacter); |
226 |
1 |
ann = consensus.annotations[1]; |
227 |
1 |
assertEquals("A 100%", ann.description); |
228 |
1 |
assertEquals("A", ann.displayCharacter); |
229 |
1 |
ann = consensus.annotations[2]; |
230 |
1 |
assertEquals("[CG] 50%", ann.description); |
231 |
1 |
assertEquals("+", ann.displayCharacter); |
232 |
1 |
ann = consensus.annotations[3]; |
233 |
1 |
assertEquals("", ann.description); |
234 |
1 |
assertEquals("-", ann.displayCharacter); |
235 |
1 |
ann = consensus.annotations[4]; |
236 |
1 |
assertEquals("T 75%", ann.description); |
237 |
1 |
assertEquals("T", ann.displayCharacter); |
238 |
|
} |
239 |
|
|
240 |
|
|
241 |
|
|
242 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (16) |
Complexity: 1 |
Complexity Density: 0.06 |
1PASS
|
|
243 |
1 |
@Test(groups = { "Functional" })... |
244 |
|
public void testExtractProfile() |
245 |
|
{ |
246 |
|
|
247 |
|
|
248 |
|
|
249 |
|
|
250 |
1 |
ProfileI profile = new Profile(200, 30, 70, "G"); |
251 |
1 |
ResidueCount counts = new ResidueCount(); |
252 |
1 |
counts.put('G', 70); |
253 |
1 |
counts.put('R', 60); |
254 |
1 |
counts.put('L', 38); |
255 |
1 |
counts.put('H', 2); |
256 |
1 |
profile.setCounts(counts); |
257 |
|
|
258 |
|
|
259 |
|
|
260 |
|
|
261 |
|
|
262 |
|
|
263 |
|
|
264 |
|
|
265 |
|
|
266 |
1 |
int[] extracted = AAFrequency.extractProfile(profile, true); |
267 |
1 |
int[] expected = new int[] { 0, 4, 99, 'G', 41, 'R', 35, 'L', 22, 'H', |
268 |
|
1 }; |
269 |
1 |
org.testng.Assert.assertEquals(extracted, expected); |
270 |
|
|
271 |
|
|
272 |
|
|
273 |
|
|
274 |
1 |
counts.put('G', 68); |
275 |
1 |
counts.put('Q', 1); |
276 |
1 |
counts.put('K', 1); |
277 |
1 |
extracted = AAFrequency.extractProfile(profile, true); |
278 |
1 |
expected = new int[] { 0, 4, 98, 'G', 40, 'R', 35, 'L', 22, 'H', 1 }; |
279 |
1 |
org.testng.Assert.assertEquals(extracted, expected); |
280 |
|
|
281 |
|
} |
282 |
|
|
283 |
|
|
284 |
|
|
285 |
|
|
286 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (16) |
Complexity: 1 |
Complexity Density: 0.06 |
1PASS
|
|
287 |
1 |
@Test(groups = { "Functional" })... |
288 |
|
public void testExtractProfile_countGaps() |
289 |
|
{ |
290 |
|
|
291 |
|
|
292 |
|
|
293 |
|
|
294 |
1 |
ProfileI profile = new Profile(200, 30, 70, "G"); |
295 |
1 |
ResidueCount counts = new ResidueCount(); |
296 |
1 |
counts.put('G', 70); |
297 |
1 |
counts.put('R', 60); |
298 |
1 |
counts.put('L', 38); |
299 |
1 |
counts.put('H', 2); |
300 |
1 |
profile.setCounts(counts); |
301 |
|
|
302 |
|
|
303 |
|
|
304 |
|
|
305 |
|
|
306 |
|
|
307 |
|
|
308 |
|
|
309 |
|
|
310 |
1 |
int[] extracted = AAFrequency.extractProfile(profile, false); |
311 |
1 |
int[] expected = new int[] { AlignmentAnnotation.SEQUENCE_PROFILE, 4, |
312 |
|
85, 'G', 35, 'R', 30, 'L', 19, 'H', |
313 |
|
1 }; |
314 |
1 |
org.testng.Assert.assertEquals(extracted, expected); |
315 |
|
|
316 |
|
|
317 |
|
|
318 |
|
|
319 |
1 |
counts.put('G', 68); |
320 |
1 |
counts.put('Q', 1); |
321 |
1 |
counts.put('K', 1); |
322 |
1 |
extracted = AAFrequency.extractProfile(profile, false); |
323 |
1 |
expected = new int[] { AlignmentAnnotation.SEQUENCE_PROFILE, 4, 84, 'G', |
324 |
|
34, 'R', 30, 'L', 19, 'H', 1 }; |
325 |
1 |
org.testng.Assert.assertEquals(extracted, expected); |
326 |
|
|
327 |
|
} |
328 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (20) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
329 |
1 |
@Test(groups = { "Functional" })... |
330 |
|
public void testExtractCdnaProfile() |
331 |
|
{ |
332 |
|
|
333 |
|
|
334 |
|
|
335 |
|
|
336 |
1 |
Hashtable profile = new Hashtable(); |
337 |
|
|
338 |
|
|
339 |
|
|
340 |
|
|
341 |
|
|
342 |
|
|
343 |
1 |
int[] codonCounts = new int[66]; |
344 |
1 |
char[] codon1 = new char[] { 'G', 'C', 'A' }; |
345 |
1 |
char[] codon2 = new char[] { 'c', 'C', 'A' }; |
346 |
1 |
char[] codon3 = new char[] { 't', 'g', 'A' }; |
347 |
1 |
char[] codon4 = new char[] { 'G', 'C', 't' }; |
348 |
1 |
int encoded1 = CodingUtils.encodeCodon(codon1); |
349 |
1 |
int encoded2 = CodingUtils.encodeCodon(codon2); |
350 |
1 |
int encoded3 = CodingUtils.encodeCodon(codon3); |
351 |
1 |
int encoded4 = CodingUtils.encodeCodon(codon4); |
352 |
1 |
codonCounts[2 + encoded1] = 30; |
353 |
1 |
codonCounts[2 + encoded2] = 70; |
354 |
1 |
codonCounts[2 + encoded3] = 9; |
355 |
1 |
codonCounts[2 + encoded4] = 1; |
356 |
1 |
codonCounts[0] = 120; |
357 |
1 |
codonCounts[1] = 110; |
358 |
1 |
profile.put(AAFrequency.PROFILE, codonCounts); |
359 |
|
|
360 |
|
|
361 |
|
|
362 |
|
|
363 |
|
|
364 |
|
|
365 |
|
|
366 |
|
|
367 |
|
|
368 |
1 |
int[] extracted = AAFrequency.extractCdnaProfile(profile, true); |
369 |
1 |
int[] expected = new int[] { AlignmentAnnotation.CDNA_PROFILE, 3, 98, |
370 |
|
encoded2, 63, encoded1, 27, encoded3, 8 }; |
371 |
1 |
org.testng.Assert.assertEquals(extracted, expected); |
372 |
|
} |
373 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (20) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
374 |
1 |
@Test(groups = { "Functional" })... |
375 |
|
public void testExtractCdnaProfile_countGaps() |
376 |
|
{ |
377 |
|
|
378 |
|
|
379 |
|
|
380 |
|
|
381 |
1 |
Hashtable profile = new Hashtable(); |
382 |
|
|
383 |
|
|
384 |
|
|
385 |
|
|
386 |
|
|
387 |
|
|
388 |
1 |
int[] codonCounts = new int[66]; |
389 |
1 |
char[] codon1 = new char[] { 'G', 'C', 'A' }; |
390 |
1 |
char[] codon2 = new char[] { 'c', 'C', 'A' }; |
391 |
1 |
char[] codon3 = new char[] { 't', 'g', 'A' }; |
392 |
1 |
char[] codon4 = new char[] { 'G', 'C', 't' }; |
393 |
1 |
int encoded1 = CodingUtils.encodeCodon(codon1); |
394 |
1 |
int encoded2 = CodingUtils.encodeCodon(codon2); |
395 |
1 |
int encoded3 = CodingUtils.encodeCodon(codon3); |
396 |
1 |
int encoded4 = CodingUtils.encodeCodon(codon4); |
397 |
1 |
codonCounts[2 + encoded1] = 30; |
398 |
1 |
codonCounts[2 + encoded2] = 70; |
399 |
1 |
codonCounts[2 + encoded3] = 9; |
400 |
1 |
codonCounts[2 + encoded4] = 1; |
401 |
1 |
codonCounts[0] = 120; |
402 |
1 |
codonCounts[1] = 110; |
403 |
1 |
profile.put(AAFrequency.PROFILE, codonCounts); |
404 |
|
|
405 |
|
|
406 |
|
|
407 |
|
|
408 |
|
|
409 |
|
|
410 |
|
|
411 |
|
|
412 |
|
|
413 |
1 |
int[] extracted = AAFrequency.extractCdnaProfile(profile, false); |
414 |
1 |
int[] expected = new int[] { AlignmentAnnotation.CDNA_PROFILE, 3, 90, |
415 |
|
encoded2, 58, encoded1, 25, encoded3, 7 }; |
416 |
1 |
org.testng.Assert.assertEquals(extracted, expected); |
417 |
|
} |
418 |
|
} |