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.assertFalse; |
25 |
|
import static org.testng.AssertJUnit.assertNull; |
26 |
|
import static org.testng.AssertJUnit.assertTrue; |
27 |
|
import static org.testng.AssertJUnit.fail; |
28 |
|
|
29 |
|
import jalview.analysis.SecStrConsensus.SimpleBP; |
30 |
|
import jalview.datamodel.SequenceFeature; |
31 |
|
import jalview.gui.JvOptionPane; |
32 |
|
|
33 |
|
import java.util.List; |
34 |
|
|
35 |
|
import org.testng.annotations.BeforeClass; |
36 |
|
import org.testng.annotations.Test; |
37 |
|
|
|
|
| 97.1% |
Uncovered Elements: 5 (170) |
Complexity: 81 |
Complexity Density: 0.67 |
|
38 |
|
public class RnaTest |
39 |
|
{ |
40 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
41 |
1 |
@BeforeClass(alwaysRun = true)... |
42 |
|
public void setUpJvOptionPane() |
43 |
|
{ |
44 |
1 |
JvOptionPane.setInteractiveMode(false); |
45 |
1 |
JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); |
46 |
|
} |
47 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (9) |
Complexity: 1 |
Complexity Density: 0.11 |
1PASS
|
|
48 |
1 |
@Test(groups = { "Functional" })... |
49 |
|
public void testGetSimpleBPs() throws WUSSParseException |
50 |
|
{ |
51 |
1 |
String rna = "([{})]"; |
52 |
1 |
List<SimpleBP> bps = Rna.getSimpleBPs(rna); |
53 |
1 |
assertEquals(3, bps.size()); |
54 |
|
|
55 |
|
|
56 |
|
|
57 |
|
|
58 |
|
|
59 |
1 |
assertEquals(2, bps.get(0).bp5); |
60 |
1 |
assertEquals(3, bps.get(0).bp3); |
61 |
1 |
assertEquals(0, bps.get(1).bp5); |
62 |
1 |
assertEquals(4, bps.get(1).bp3); |
63 |
1 |
assertEquals(1, bps.get(2).bp5); |
64 |
1 |
assertEquals(5, bps.get(2).bp3); |
65 |
|
} |
66 |
|
|
|
|
| 80% |
Uncovered Elements: 1 (5) |
Complexity: 2 |
Complexity Density: 0.4 |
1PASS
|
|
67 |
1 |
@Test(groups = { "Functional" })... |
68 |
|
public void testGetSimpleBPs_unmatchedOpener() |
69 |
|
{ |
70 |
1 |
String rna = "(([{})]"; |
71 |
1 |
try |
72 |
|
{ |
73 |
1 |
Rna.getSimpleBPs(rna); |
74 |
0 |
fail("expected exception"); |
75 |
|
} catch (WUSSParseException e) |
76 |
|
{ |
77 |
|
|
78 |
1 |
assertEquals(rna.length(), e.getProblemPos()); |
79 |
|
} |
80 |
|
} |
81 |
|
|
|
|
| 80% |
Uncovered Elements: 2 (10) |
Complexity: 3 |
Complexity Density: 0.3 |
1PASS
|
|
82 |
1 |
@Test(groups = { "Functional" })... |
83 |
|
public void testGetSimpleBPs_unmatchedCloser() |
84 |
|
{ |
85 |
1 |
String rna = "([{})]]]"; |
86 |
1 |
try |
87 |
|
{ |
88 |
1 |
Rna.getSimpleBPs(rna); |
89 |
0 |
fail("expected exception"); |
90 |
|
} catch (WUSSParseException e) |
91 |
|
{ |
92 |
|
|
93 |
1 |
assertEquals(6, e.getProblemPos()); |
94 |
|
} |
95 |
|
|
96 |
|
|
97 |
|
|
98 |
|
|
99 |
|
|
100 |
1 |
rna = "((()])"; |
101 |
1 |
try |
102 |
|
{ |
103 |
1 |
Rna.getSimpleBPs(rna); |
104 |
0 |
fail("expected exception"); |
105 |
|
} catch (WUSSParseException e) |
106 |
|
{ |
107 |
1 |
assertEquals(4, e.getProblemPos()); |
108 |
|
} |
109 |
|
} |
110 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (12) |
Complexity: 7 |
Complexity Density: 0.88 |
1PASS
|
|
111 |
1 |
@Test(groups = { "Functional" })... |
112 |
|
public void testGetRNASecStrucState() |
113 |
|
{ |
114 |
1 |
assertNull(Rna.getRNASecStrucState(null)); |
115 |
257 |
for (int i = 0; i <= 255; i++) |
116 |
|
{ |
117 |
256 |
String s = String.valueOf((char) i); |
118 |
256 |
String ss = Rna.getRNASecStrucState(s); |
119 |
|
|
120 |
|
|
121 |
|
|
122 |
|
|
123 |
|
|
124 |
256 |
if ((i >= 'a' && i <= 'z') || (i >= 'A' && i <= 'Z') |
125 |
|
|| "()[]{}<>".indexOf(s) > -1) |
126 |
|
{ |
127 |
60 |
assertEquals("" + i, s, ss); |
128 |
|
} |
129 |
|
else |
130 |
|
{ |
131 |
196 |
assertEquals(" ", ss); |
132 |
|
} |
133 |
|
} |
134 |
|
|
135 |
|
|
136 |
|
|
137 |
|
|
138 |
1 |
assertEquals("a [K ]z} {Q b(w)p><i", |
139 |
|
Rna.getRNASecStrucState("a.[K-]z}?{Q b(w)p><i")); |
140 |
|
} |
141 |
|
|
142 |
|
|
143 |
|
|
144 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (14) |
Complexity: 8 |
Complexity Density: 0.8 |
1PASS
|
|
145 |
1 |
@Test(groups = { "Functional" })... |
146 |
|
public void testIsClosingParenthesis() |
147 |
|
{ |
148 |
1 |
assertFalse(Rna.isClosingParenthesis(null)); |
149 |
|
|
150 |
|
|
151 |
|
|
152 |
|
|
153 |
257 |
for (int i = 0; i <= 255; i++) |
154 |
|
{ |
155 |
256 |
boolean isClosingChar = Rna.isClosingParenthesis((char) i); |
156 |
256 |
boolean isClosingString = Rna.isClosingParenthesis(String |
157 |
|
.valueOf((char) i)); |
158 |
256 |
if ((i >= 'a' && i <= 'z') || i == ')' || i == '}' || i == ']' |
159 |
|
|| i == '>') |
160 |
|
{ |
161 |
30 |
assertTrue(String.format("close base pair %c", i), isClosingChar); |
162 |
30 |
assertTrue(String.format("close base pair %c", i), isClosingString); |
163 |
|
} |
164 |
|
else |
165 |
|
{ |
166 |
226 |
assertFalse(String.format("close base pair %c", i), isClosingChar); |
167 |
226 |
assertFalse(String.format("close base pair %c", i), isClosingString); |
168 |
|
} |
169 |
256 |
assertFalse(Rna.isClosingParenthesis(String.valueOf((char) i) + " ")); |
170 |
|
} |
171 |
|
} |
172 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (16) |
Complexity: 13 |
Complexity Density: 1.3 |
1PASS
|
|
173 |
1 |
@Test(groups = { "Functional" })... |
174 |
|
public void testIsCanonicalOrWobblePair() |
175 |
|
{ |
176 |
1 |
String bases = "acgtuACGTU"; |
177 |
11 |
for (int i = 0; i < bases.length(); i++) |
178 |
|
{ |
179 |
110 |
for (int j = 0; j < bases.length(); j++) |
180 |
|
{ |
181 |
100 |
char first = bases.charAt(i); |
182 |
100 |
char second = bases.charAt(j); |
183 |
100 |
boolean result = Rna.isCanonicalOrWobblePair(first, second); |
184 |
100 |
String pair = new String(new char[] { first, second }) |
185 |
|
.toUpperCase(); |
186 |
100 |
if (pair.equals("AT") || pair.equals("TA") || pair.equals("AU") |
187 |
|
|| pair.equals("UA") || pair.equals("GC") |
188 |
|
|| pair.equals("CG") || pair.equals("GT") |
189 |
|
|| pair.equals("TG") || pair.equals("GU") |
190 |
|
|| pair.equals("UG")) |
191 |
|
{ |
192 |
40 |
assertTrue(pair + " should be valid", result); |
193 |
|
} |
194 |
|
else |
195 |
|
{ |
196 |
60 |
assertFalse(pair + " should be invalid", result); |
197 |
|
} |
198 |
|
} |
199 |
|
} |
200 |
|
} |
201 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (16) |
Complexity: 9 |
Complexity Density: 0.9 |
1PASS
|
|
202 |
1 |
@Test(groups = { "Functional" })... |
203 |
|
public void testIsCanonicalPair() |
204 |
|
{ |
205 |
1 |
String bases = "acgtuACGTU"; |
206 |
11 |
for (int i = 0; i < bases.length(); i++) |
207 |
|
{ |
208 |
110 |
for (int j = 0; j < bases.length(); j++) |
209 |
|
{ |
210 |
100 |
char first = bases.charAt(i); |
211 |
100 |
char second = bases.charAt(j); |
212 |
100 |
boolean result = Rna.isCanonicalPair(first, second); |
213 |
100 |
String pair = new String(new char[] { first, second }) |
214 |
|
.toUpperCase(); |
215 |
100 |
if (pair.equals("AT") || pair.equals("TA") || pair.equals("AU") |
216 |
|
|| pair.equals("UA") || pair.equals("GC") |
217 |
|
|| pair.equals("CG")) |
218 |
|
{ |
219 |
24 |
assertTrue(pair + " should be valid", result); |
220 |
|
} |
221 |
|
else |
222 |
|
{ |
223 |
76 |
assertFalse(pair + " should be invalid", result); |
224 |
|
} |
225 |
|
} |
226 |
|
} |
227 |
|
} |
228 |
|
|
229 |
|
|
230 |
|
|
231 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (13) |
Complexity: 8 |
Complexity Density: 0.89 |
1PASS
|
|
232 |
1 |
@Test(groups = { "Functional" })... |
233 |
|
public void testIsOpeningParenthesis() |
234 |
|
{ |
235 |
|
|
236 |
|
|
237 |
|
|
238 |
257 |
for (int i = 0; i <= 255; i++) |
239 |
|
{ |
240 |
256 |
boolean isOpeningChar = Rna.isOpeningParenthesis((char) i); |
241 |
256 |
boolean isOpeningString = Rna.isOpeningParenthesis(String |
242 |
|
.valueOf((char) i)); |
243 |
256 |
if ((i >= 'A' && i <= 'Z') || i == '(' || i == '{' || i == '[' |
244 |
|
|| i == '<') |
245 |
|
{ |
246 |
30 |
assertTrue(String.format("Open base pair %c", i), isOpeningChar); |
247 |
30 |
assertTrue(String.format("Open base pair %c", i), isOpeningString); |
248 |
|
} |
249 |
|
else |
250 |
|
{ |
251 |
226 |
assertFalse(String.format("Open base pair %c", i), isOpeningChar); |
252 |
226 |
assertFalse(String.format("Open base pair %c", i), isOpeningString); |
253 |
|
} |
254 |
256 |
assertFalse(Rna.isOpeningParenthesis(String.valueOf((char) i) + " ")); |
255 |
|
} |
256 |
|
} |
257 |
|
|
|
|
| 87.5% |
Uncovered Elements: 2 (16) |
Complexity: 13 |
Complexity Density: 1.62 |
1PASS
|
|
258 |
1 |
@Test(groups = { "Functional" })... |
259 |
|
public void testGetMatchingOpeningParenthesis() throws WUSSParseException |
260 |
|
{ |
261 |
257 |
for (int i = 0; i <= 255; i++) |
262 |
|
{ |
263 |
256 |
boolean isClosing = Rna.isClosingParenthesis((char) i); |
264 |
256 |
if (isClosing) |
265 |
|
{ |
266 |
30 |
char opening = Rna.getMatchingOpeningParenthesis((char) i); |
267 |
30 |
if (i >= 'a' && i <= 'z') |
268 |
|
{ |
269 |
26 |
assertEquals(i + 'A' - 'a', opening); |
270 |
|
} |
271 |
4 |
else if (i == ')' && opening == '(' || i == ']' && opening == '[' |
272 |
|
|| i == '}' && opening == '{' || i == '>' && opening == '<') |
273 |
|
{ |
274 |
|
|
275 |
|
} |
276 |
|
else |
277 |
|
{ |
278 |
0 |
fail("Got " + opening + " as opening bracket pair for " |
279 |
|
+ ((char) i)); |
280 |
|
} |
281 |
|
} |
282 |
|
} |
283 |
|
} |
284 |
|
|
285 |
|
|
286 |
|
|
287 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (14) |
Complexity: 14 |
Complexity Density: 1.4 |
1PASS
|
|
288 |
1 |
@Test(groups = { "Functional" })... |
289 |
|
public void testIsRnaSecondaryStructureSymbol() |
290 |
|
{ |
291 |
1 |
assertFalse(Rna.isRnaSecondaryStructureSymbol(null)); |
292 |
|
|
293 |
|
|
294 |
|
|
295 |
|
|
296 |
257 |
for (int i = 0; i <= 255; i++) |
297 |
|
{ |
298 |
256 |
boolean isValidChar = Rna.isRnaSecondaryStructureSymbol((char) i); |
299 |
256 |
boolean isValidString = Rna.isRnaSecondaryStructureSymbol(String |
300 |
|
.valueOf((char) i)); |
301 |
256 |
if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z') || i == '(' |
302 |
|
|| i == ')' || i == '{' || i == '}' || i == '[' || i == ']' |
303 |
|
|| i == '<' || i == '>') |
304 |
|
{ |
305 |
60 |
assertTrue(String.format("close base pair %c", i), isValidChar); |
306 |
60 |
assertTrue(String.format("close base pair %c", i), isValidString); |
307 |
|
} |
308 |
|
else |
309 |
|
{ |
310 |
196 |
assertFalse(String.format("close base pair %c", i), isValidChar); |
311 |
196 |
assertFalse(String.format("close base pair %c", i), isValidString); |
312 |
|
} |
313 |
256 |
assertFalse(Rna.isRnaSecondaryStructureSymbol(String |
314 |
|
.valueOf((char) i) + " ")); |
315 |
|
} |
316 |
|
} |
317 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (15) |
Complexity: 1 |
Complexity Density: 0.07 |
1PASS
|
|
318 |
1 |
@Test(groups = "Functional")... |
319 |
|
public void testGetHelixMap_oneHelix() throws WUSSParseException |
320 |
|
{ |
321 |
1 |
String rna = ".(..[{.<..>}..].)"; |
322 |
1 |
SequenceFeature[] sfs = Rna.getHelixMap(rna); |
323 |
1 |
assertEquals(4, sfs.length); |
324 |
|
|
325 |
|
|
326 |
|
|
327 |
|
|
328 |
|
|
329 |
1 |
assertEquals(7, sfs[0].getBegin()); |
330 |
1 |
assertEquals(10, sfs[0].getEnd()); |
331 |
1 |
assertEquals("0", sfs[0].getFeatureGroup()); |
332 |
1 |
assertEquals(5, sfs[1].getBegin()); |
333 |
1 |
assertEquals(11, sfs[1].getEnd()); |
334 |
1 |
assertEquals("0", sfs[1].getFeatureGroup()); |
335 |
1 |
assertEquals(4, sfs[2].getBegin()); |
336 |
1 |
assertEquals(14, sfs[2].getEnd()); |
337 |
1 |
assertEquals("0", sfs[2].getFeatureGroup()); |
338 |
1 |
assertEquals(1, sfs[3].getBegin()); |
339 |
1 |
assertEquals(16, sfs[3].getEnd()); |
340 |
1 |
assertEquals("0", sfs[3].getFeatureGroup()); |
341 |
|
} |
342 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (15) |
Complexity: 1 |
Complexity Density: 0.07 |
1PASS
|
|
343 |
1 |
@Test(groups = "Functional")... |
344 |
|
public void testGetHelixMap_twoHelices() throws WUSSParseException |
345 |
|
{ |
346 |
1 |
String rna = ".([.)]..{.<}.>"; |
347 |
1 |
SequenceFeature[] sfs = Rna.getHelixMap(rna); |
348 |
1 |
assertEquals(4, sfs.length); |
349 |
|
|
350 |
|
|
351 |
|
|
352 |
|
|
353 |
|
|
354 |
1 |
assertEquals(1, sfs[0].getBegin()); |
355 |
1 |
assertEquals(4, sfs[0].getEnd()); |
356 |
1 |
assertEquals("0", sfs[0].getFeatureGroup()); |
357 |
1 |
assertEquals(2, sfs[1].getBegin()); |
358 |
1 |
assertEquals(5, sfs[1].getEnd()); |
359 |
1 |
assertEquals("0", sfs[1].getFeatureGroup()); |
360 |
1 |
assertEquals(8, sfs[2].getBegin()); |
361 |
1 |
assertEquals(11, sfs[2].getEnd()); |
362 |
1 |
assertEquals("1", sfs[2].getFeatureGroup()); |
363 |
1 |
assertEquals(10, sfs[3].getBegin()); |
364 |
1 |
assertEquals(13, sfs[3].getEnd()); |
365 |
1 |
assertEquals("1", sfs[3].getFeatureGroup()); |
366 |
|
} |
367 |
|
} |