2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
7 * Jalview is free software: you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation, either version 3
10 * of the License, or (at your option) any later version.
12 * Jalview is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty
14 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
19 * The Jalview Authors are detailed in the 'AUTHORS' file.
21 package jalview.analysis;
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;
29 import jalview.analysis.SecStrConsensus.SimpleBP;
30 import jalview.gui.JvOptionPane;
32 import java.util.Vector;
34 import org.testng.annotations.BeforeClass;
35 import org.testng.annotations.Test;
40 @BeforeClass(alwaysRun = true)
41 public void setUpJvOptionPane()
43 JvOptionPane.setInteractiveMode(false);
44 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
47 @Test(groups = { "Functional" })
48 public void testGetSimpleBPs() throws WUSSParseException
50 String rna = "([{})]"; // JAL-1081 example
51 Vector<SimpleBP> bps = Rna.getSimpleBPs(rna);
52 assertEquals(3, bps.size());
55 * the base pairs are added in the order in which the matching base is found
56 * (popping the stack of unmatched opening brackets)
58 assertEquals(2, bps.get(0).bp5); // {
59 assertEquals(3, bps.get(0).bp3); // }
60 assertEquals(0, bps.get(1).bp5); // (
61 assertEquals(4, bps.get(1).bp3); // )
62 assertEquals(1, bps.get(2).bp5); // [
63 assertEquals(5, bps.get(2).bp3); // ]
66 @Test(groups = { "Functional" })
67 public void testGetSimpleBPs_unmatchedOpener()
69 String rna = "(([{})]";
72 Rna.getSimpleBPs(rna);
73 fail("expected exception");
74 } catch (WUSSParseException e)
76 // error reported as after end of input string
77 assertEquals(rna.length(), e.getProblemPos());
81 @Test(groups = { "Functional" })
82 public void testGetSimpleBPs_unmatchedCloser()
84 String rna = "([{})]]]";
87 Rna.getSimpleBPs(rna);
88 fail("expected exception");
89 } catch (WUSSParseException e)
91 // error reported as at first unmatched close
92 assertEquals(6, e.getProblemPos());
96 * a variant where we have no opening bracket of the same type
97 * as the unmatched closing bracket (no stack rather than empty stack)
102 Rna.getSimpleBPs(rna);
103 fail("expected exception");
104 } catch (WUSSParseException e)
106 assertEquals(4, e.getProblemPos());
110 @Test(groups = { "Functional" })
111 public void testGetRNASecStrucState()
113 assertNull(Rna.getRNASecStrucState(null));
114 for (int i = 0; i <= 255; i++)
116 String s = String.valueOf((char) i);
117 String ss = Rna.getRNASecStrucState(s);
120 * valid SS chars are a-z, A-Z, and various brackets;
121 * anything else is returned as a space
123 if ((i >= 'a' && i <= 'z') || (i >= 'A' && i <= 'Z')
124 || "()[]{}<>".indexOf(s) > -1)
126 assertEquals("" + i, s, ss);
130 assertEquals(" ", ss);
135 * a string is processed character by character
137 assertEquals("a [K ]z} {Q b(w)p><i",
138 Rna.getRNASecStrucState("a.[K-]z}?{Q b(w)p><i"));
142 * Tests for isClosingParenthesis with char or String argument
144 @Test(groups = { "Functional" })
145 public void testIsClosingParenthesis()
147 assertFalse(Rna.isClosingParenthesis(null));
150 * only a-z, )]}> are closing bracket symbols
152 for (int i = 0; i <= 255; i++)
154 boolean isClosingChar = Rna.isClosingParenthesis((char) i);
155 boolean isClosingString = Rna.isClosingParenthesis(String
157 if ((i >= 'a' && i <= 'z') || i == ')' || i == '}' || i == ']'
160 assertTrue(String.format("close base pair %c", i), isClosingChar);
161 assertTrue(String.format("close base pair %c", i), isClosingString);
165 assertFalse(String.format("close base pair %c", i), isClosingChar);
166 assertFalse(String.format("close base pair %c", i), isClosingString);
168 assertFalse(Rna.isClosingParenthesis(String.valueOf((char) i) + " "));
172 @Test(groups = { "Functional" })
173 public void testIsCanonicalOrWobblePair()
175 String bases = "acgtuACGTU";
176 for (int i = 0; i < bases.length(); i++)
178 for (int j = 0; j < bases.length(); j++)
180 char first = bases.charAt(i);
181 char second = bases.charAt(j);
182 boolean result = Rna.isCanonicalOrWobblePair(first, second);
183 String pair = new String(new char[] { first, second })
185 if (pair.equals("AT") || pair.equals("TA") || pair.equals("AU")
186 || pair.equals("UA") || pair.equals("GC")
187 || pair.equals("CG") || pair.equals("GT")
188 || pair.equals("TG") || pair.equals("GU")
189 || pair.equals("UG"))
191 assertTrue(pair + " should be valid", result);
195 assertFalse(pair + " should be invalid", result);
201 @Test(groups = { "Functional" })
202 public void testIsCanonicalPair()
204 String bases = "acgtuACGTU";
205 for (int i = 0; i < bases.length(); i++)
207 for (int j = 0; j < bases.length(); j++)
209 char first = bases.charAt(i);
210 char second = bases.charAt(j);
211 boolean result = Rna.isCanonicalPair(first, second);
212 String pair = new String(new char[] { first, second })
214 if (pair.equals("AT") || pair.equals("TA") || pair.equals("AU")
215 || pair.equals("UA") || pair.equals("GC")
216 || pair.equals("CG"))
218 assertTrue(pair + " should be valid", result);
222 assertFalse(pair + " should be invalid", result);
229 * Tests for isOpeningParenthesis with char or String argument
231 @Test(groups = { "Functional" })
232 public void testIsOpeningParenthesis()
235 * only A-Z, ([{< are opening bracket symbols
237 for (int i = 0; i <= 255; i++)
239 boolean isOpeningChar = Rna.isOpeningParenthesis((char) i);
240 boolean isOpeningString = Rna.isOpeningParenthesis(String
242 if ((i >= 'A' && i <= 'Z') || i == '(' || i == '{' || i == '['
245 assertTrue(String.format("Open base pair %c", i), isOpeningChar);
246 assertTrue(String.format("Open base pair %c", i), isOpeningString);
250 assertFalse(String.format("Open base pair %c", i), isOpeningChar);
251 assertFalse(String.format("Open base pair %c", i), isOpeningString);
253 assertFalse(Rna.isOpeningParenthesis(String.valueOf((char) i) + " "));
257 @Test(groups = { "Functional" })
258 public void testGetMatchingOpeningParenthesis() throws WUSSParseException
260 for (int i = 0; i <= 255; i++)
262 boolean isClosing = Rna.isClosingParenthesis((char) i);
265 char opening = Rna.getMatchingOpeningParenthesis((char) i);
266 if (i >= 'a' && i <= 'z')
268 assertEquals(i + 'A' - 'a', opening);
270 else if (i == ')' && opening == '(' || i == ']' && opening == '['
271 || i == '}' && opening == '{' || i == '>' && opening == '<')
277 fail("Got " + opening + " as opening bracket pair for "
285 * Tests for isRnaSecondaryStructureSymbol with char or String argument
287 @Test(groups = { "Functional" })
288 public void testIsRnaSecondaryStructureSymbol()
290 assertFalse(Rna.isRnaSecondaryStructureSymbol(null));
293 * only A-Z, a-z, ()[]{}<> are valid symbols
295 for (int i = 0; i <= 255; i++)
297 boolean isValidChar = Rna.isRnaSecondaryStructureSymbol((char) i);
298 boolean isValidString = Rna.isRnaSecondaryStructureSymbol(String
300 if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z') || i == '('
301 || i == ')' || i == '{' || i == '}' || i == '[' || i == ']'
302 || i == '<' || i == '>')
304 assertTrue(String.format("close base pair %c", i), isValidChar);
305 assertTrue(String.format("close base pair %c", i), isValidString);
309 assertFalse(String.format("close base pair %c", i), isValidChar);
310 assertFalse(String.format("close base pair %c", i), isValidString);
312 assertFalse(Rna.isRnaSecondaryStructureSymbol(String
313 .valueOf((char) i) + " "));