X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=test%2Fjalview%2Fanalysis%2FRnaTest.java;h=1faf3f2a85ff767931ed15526443a68728881e69;hb=3edf7ac9c103688aa89a9a7f7bc56fca46403ad4;hp=2c51a1ba01752ef157198c99461d661f53bcd934;hpb=0715e493687eeb93d3b3f39cd1ff25e2671ce0e9;p=jalview.git diff --git a/test/jalview/analysis/RnaTest.java b/test/jalview/analysis/RnaTest.java index 2c51a1b..1faf3f2 100644 --- a/test/jalview/analysis/RnaTest.java +++ b/test/jalview/analysis/RnaTest.java @@ -27,18 +27,29 @@ import static org.testng.AssertJUnit.assertTrue; import static org.testng.AssertJUnit.fail; import jalview.analysis.SecStrConsensus.SimpleBP; +import jalview.datamodel.SequenceFeature; +import jalview.gui.JvOptionPane; -import java.util.Vector; +import java.util.List; +import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; public class RnaTest { + + @BeforeClass(alwaysRun = true) + public void setUpJvOptionPane() + { + JvOptionPane.setInteractiveMode(false); + JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); + } + @Test(groups = { "Functional" }) public void testGetSimpleBPs() throws WUSSParseException { String rna = "([{})]"; // JAL-1081 example - Vector bps = Rna.getSimpleBPs(rna); + List bps = Rna.getSimpleBPs(rna); assertEquals(3, bps.size()); /* @@ -105,7 +116,7 @@ public class RnaTest { String s = String.valueOf((char) i); String ss = Rna.getRNASecStrucState(s); - + /* * valid SS chars are a-z, A-Z, and various brackets; * anything else is returned as a space @@ -120,7 +131,7 @@ public class RnaTest assertEquals(" ", ss); } } - + /* * a string is processed character by character */ @@ -128,24 +139,34 @@ public class RnaTest Rna.getRNASecStrucState("a.[K-]z}?{Q b(w)p> are closing bracket symbols */ for (int i = 0; i <= 255; i++) { - boolean isClosing = Rna.isClosingParenthesis((char) i); + boolean isClosingChar = Rna.isClosingParenthesis((char) i); + boolean isClosingString = Rna.isClosingParenthesis(String + .valueOf((char) i)); if ((i >= 'a' && i <= 'z') || i == ')' || i == '}' || i == ']' || i == '>') { - assertTrue(String.format("close base pair %c", i), isClosing); + assertTrue(String.format("close base pair %c", i), isClosingChar); + assertTrue(String.format("close base pair %c", i), isClosingString); } else { - assertFalse(String.format("close base pair %c", i), isClosing); + assertFalse(String.format("close base pair %c", i), isClosingChar); + assertFalse(String.format("close base pair %c", i), isClosingString); } + assertFalse(Rna.isClosingParenthesis(String.valueOf((char) i) + " ")); } } @@ -179,6 +200,36 @@ public class RnaTest } @Test(groups = { "Functional" }) + public void testIsCanonicalPair() + { + String bases = "acgtuACGTU"; + for (int i = 0; i < bases.length(); i++) + { + for (int j = 0; j < bases.length(); j++) + { + char first = bases.charAt(i); + char second = bases.charAt(j); + boolean result = Rna.isCanonicalPair(first, second); + String pair = new String(new char[] { first, second }) + .toUpperCase(); + if (pair.equals("AT") || pair.equals("TA") || pair.equals("AU") + || pair.equals("UA") || pair.equals("GC") + || pair.equals("CG")) + { + assertTrue(pair + " should be valid", result); + } + else + { + assertFalse(pair + " should be invalid", result); + } + } + } + } + + /** + * Tests for isOpeningParenthesis with char or String argument + */ + @Test(groups = { "Functional" }) public void testIsOpeningParenthesis() { /* @@ -186,16 +237,131 @@ public class RnaTest */ for (int i = 0; i <= 255; i++) { - boolean isOpening = Rna.isOpeningParenthesis((char) i); + boolean isOpeningChar = Rna.isOpeningParenthesis((char) i); + boolean isOpeningString = Rna.isOpeningParenthesis(String + .valueOf((char) i)); if ((i >= 'A' && i <= 'Z') || i == '(' || i == '{' || i == '[' || i == '<') { - assertTrue(String.format("Open base pair %c", i), isOpening); + assertTrue(String.format("Open base pair %c", i), isOpeningChar); + assertTrue(String.format("Open base pair %c", i), isOpeningString); + } + else + { + assertFalse(String.format("Open base pair %c", i), isOpeningChar); + assertFalse(String.format("Open base pair %c", i), isOpeningString); + } + assertFalse(Rna.isOpeningParenthesis(String.valueOf((char) i) + " ")); + } + } + + @Test(groups = { "Functional" }) + public void testGetMatchingOpeningParenthesis() throws WUSSParseException + { + for (int i = 0; i <= 255; i++) + { + boolean isClosing = Rna.isClosingParenthesis((char) i); + if (isClosing) + { + char opening = Rna.getMatchingOpeningParenthesis((char) i); + if (i >= 'a' && i <= 'z') + { + assertEquals(i + 'A' - 'a', opening); + } + else if (i == ')' && opening == '(' || i == ']' && opening == '[' + || i == '}' && opening == '{' || i == '>' && opening == '<') + { + // ok + } + else + { + fail("Got " + opening + " as opening bracket pair for " + + ((char) i)); + } + } + } + } + + /** + * Tests for isRnaSecondaryStructureSymbol with char or String argument + */ + @Test(groups = { "Functional" }) + public void testIsRnaSecondaryStructureSymbol() + { + assertFalse(Rna.isRnaSecondaryStructureSymbol(null)); + + /* + * only A-Z, a-z, ()[]{}<> are valid symbols + */ + for (int i = 0; i <= 255; i++) + { + boolean isValidChar = Rna.isRnaSecondaryStructureSymbol((char) i); + boolean isValidString = Rna.isRnaSecondaryStructureSymbol(String + .valueOf((char) i)); + if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z') || i == '(' + || i == ')' || i == '{' || i == '}' || i == '[' || i == ']' + || i == '<' || i == '>') + { + assertTrue(String.format("close base pair %c", i), isValidChar); + assertTrue(String.format("close base pair %c", i), isValidString); } else { - assertFalse(String.format("Open base pair %c", i), isOpening); + assertFalse(String.format("close base pair %c", i), isValidChar); + assertFalse(String.format("close base pair %c", i), isValidString); } + assertFalse(Rna.isRnaSecondaryStructureSymbol(String + .valueOf((char) i) + " ")); } } + + @Test(groups = "Functional") + public void testGetHelixMap_oneHelix() throws WUSSParseException + { + String rna = ".(..[{.<..>}..].)"; + SequenceFeature[] sfs = Rna.getHelixMap(rna); + assertEquals(4, sfs.length); + + /* + * pairs are added in the order in which the closing bracket is found + * (see testGetSimpleBPs) + */ + assertEquals(7, sfs[0].getBegin()); + assertEquals(10, sfs[0].getEnd()); + assertEquals("0", sfs[0].getFeatureGroup()); + assertEquals(5, sfs[1].getBegin()); + assertEquals(11, sfs[1].getEnd()); + assertEquals("0", sfs[1].getFeatureGroup()); + assertEquals(4, sfs[2].getBegin()); + assertEquals(14, sfs[2].getEnd()); + assertEquals("0", sfs[2].getFeatureGroup()); + assertEquals(1, sfs[3].getBegin()); + assertEquals(16, sfs[3].getEnd()); + assertEquals("0", sfs[3].getFeatureGroup()); + } + + @Test(groups = "Functional") + public void testGetHelixMap_twoHelices() throws WUSSParseException + { + String rna = ".([.)]..{.<}.>"; + SequenceFeature[] sfs = Rna.getHelixMap(rna); + assertEquals(4, sfs.length); + + /* + * pairs are added in the order in which the closing bracket is found + * (see testGetSimpleBPs) + */ + assertEquals(1, sfs[0].getBegin()); + assertEquals(4, sfs[0].getEnd()); + assertEquals("0", sfs[0].getFeatureGroup()); + assertEquals(2, sfs[1].getBegin()); + assertEquals(5, sfs[1].getEnd()); + assertEquals("0", sfs[1].getFeatureGroup()); + assertEquals(8, sfs[2].getBegin()); + assertEquals(11, sfs[2].getEnd()); + assertEquals("1", sfs[2].getFeatureGroup()); + assertEquals(10, sfs[3].getBegin()); + assertEquals(13, sfs[3].getEnd()); + assertEquals("1", sfs[3].getFeatureGroup()); + } }