test/jalview/analysis/RnaTest.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   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.
  11  *
  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.
  16  *
  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.
  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
  31 import java.util.Vector;
  32
  33 import org.testng.annotations.Test;
  34
  35 public class RnaTest
  36 {
  37   @Test(groups = { "Functional" })
  38   public void testGetSimpleBPs() throws WUSSParseException
  39   {
  40     String rna = "([{})]"; // JAL-1081 example
  41     Vector<SimpleBP> bps = Rna.getSimpleBPs(rna);
  42     assertEquals(3, bps.size());
  43
  44     /*
  45      * the base pairs are added in the order in which the matching base is found
  46      * (popping the stack of unmatched opening brackets)
  47      */
  48     assertEquals(2, bps.get(0).bp5); // {
  49     assertEquals(3, bps.get(0).bp3); // }
  50     assertEquals(0, bps.get(1).bp5); // (
  51     assertEquals(4, bps.get(1).bp3); // )
  52     assertEquals(1, bps.get(2).bp5); // [
  53     assertEquals(5, bps.get(2).bp3); // ]
  54   }
  55
  56   @Test(groups = { "Functional" })
  57   public void testGetSimpleBPs_unmatchedOpener()
  58   {
  59     String rna = "(([{})]";
  60     try
  61     {
  62       Rna.getSimpleBPs(rna);
  63       fail("expected exception");
  64     } catch (WUSSParseException e)
  65     {
  66       // error reported as after end of input string
  67       assertEquals(rna.length(), e.getProblemPos());
  68     }
  69   }
  70
  71   @Test(groups = { "Functional" })
  72   public void testGetSimpleBPs_unmatchedCloser()
  73   {
  74     String rna = "([{})]]]";
  75     try
  76     {
  77       Rna.getSimpleBPs(rna);
  78       fail("expected exception");
  79     } catch (WUSSParseException e)
  80     {
  81       // error reported as at first unmatched close
  82       assertEquals(6, e.getProblemPos());
  83     }
  84
  85     /*
  86      * a variant where we have no opening bracket of the same type
  87      * as the unmatched closing bracket (no stack rather than empty stack)
  88      */
  89     rna = "((()])";
  90     try
  91     {
  92       Rna.getSimpleBPs(rna);
  93       fail("expected exception");
  94     } catch (WUSSParseException e)
  95     {
  96       assertEquals(4, e.getProblemPos());
  97     }
  98   }
  99
 100   @Test(groups = { "Functional" })
 101   public void testGetRNASecStrucState()
 102   {
 103     assertNull(Rna.getRNASecStrucState(null));
 104     for (int i = 0; i <= 255; i++)
 105     {
 106       String s = String.valueOf((char) i);
 107       String ss = Rna.getRNASecStrucState(s);
 108
 109       /*
 110        * valid SS chars are a-z, A-Z, and various brackets;
 111        * anything else is returned as a space
 112        */
 113       if ((i >= 'a' && i <= 'z') || (i >= 'A' && i <= 'Z')
 114               || "()[]{}<>".indexOf(s) > -1)
 115       {
 116         assertEquals("" + i, s, ss);
 117       }
 118       else
 119       {
 120         assertEquals(" ", ss);
 121       }
 122     }
 123
 124     /*
 125      * a string is processed character by character
 126      */
 127     assertEquals("a [K ]z} {Q b(w)p><i",
 128             Rna.getRNASecStrucState("a.[K-]z}?{Q b(w)p><i"));
 129   }
 130
 131   /**
 132    * Tests for isClosingParenthesis with char or String argument
 133    */
 134   @Test(groups = { "Functional" })
 135   public void testIsClosingParenthesis()
 136   {
 137     assertFalse(Rna.isClosingParenthesis(null));
 138
 139     /*
 140      * only a-z, )]}> are closing bracket symbols
 141      */
 142     for (int i = 0; i <= 255; i++)
 143     {
 144       boolean isClosingChar = Rna.isClosingParenthesis((char) i);
 145       boolean isClosingString = Rna.isClosingParenthesis(String
 146               .valueOf((char) i));
 147       if ((i >= 'a' && i <= 'z') || i == ')' || i == '}' || i == ']'
 148               || i == '>')
 149       {
 150         assertTrue(String.format("close base pair %c", i), isClosingChar);
 151         assertTrue(String.format("close base pair %c", i), isClosingString);
 152       }
 153       else
 154       {
 155         assertFalse(String.format("close base pair %c", i), isClosingChar);
 156         assertFalse(String.format("close base pair %c", i), isClosingString);
 157       }
 158       assertFalse(Rna.isClosingParenthesis(String.valueOf((char) i) + " "));
 159     }
 160   }
 161
 162   @Test(groups = { "Functional" })
 163   public void testIsCanonicalOrWobblePair()
 164   {
 165     String bases = "acgtuACGTU";
 166     for (int i = 0; i < bases.length(); i++)
 167     {
 168       for (int j = 0; j < bases.length(); j++)
 169       {
 170         char first = bases.charAt(i);
 171         char second = bases.charAt(j);
 172         boolean result = Rna.isCanonicalOrWobblePair(first, second);
 173         String pair = new String(new char[] { first, second })
 174                 .toUpperCase();
 175         if (pair.equals("AT") || pair.equals("TA") || pair.equals("AU")
 176                 || pair.equals("UA") || pair.equals("GC")
 177                 || pair.equals("CG") || pair.equals("GT")
 178                 || pair.equals("TG") || pair.equals("GU")
 179                 || pair.equals("UG"))
 180         {
 181           assertTrue(pair + " should be valid", result);
 182         }
 183         else
 184         {
 185           assertFalse(pair + " should be invalid", result);
 186         }
 187       }
 188     }
 189   }
 190
 191   /**
 192    * Tests for isOpeningParenthesis with char or String argument
 193    */
 194   @Test(groups = { "Functional" })
 195   public void testIsOpeningParenthesis()
 196   {
 197     /*
 198      * only A-Z, ([{< are opening bracket symbols
 199      */
 200     for (int i = 0; i <= 255; i++)
 201     {
 202       boolean isOpeningChar = Rna.isOpeningParenthesis((char) i);
 203       boolean isOpeningString = Rna.isOpeningParenthesis(String
 204               .valueOf((char) i));
 205       if ((i >= 'A' && i <= 'Z') || i == '(' || i == '{' || i == '['
 206               || i == '<')
 207       {
 208         assertTrue(String.format("Open base pair %c", i), isOpeningChar);
 209         assertTrue(String.format("Open base pair %c", i), isOpeningString);
 210       }
 211       else
 212       {
 213         assertFalse(String.format("Open base pair %c", i), isOpeningChar);
 214         assertFalse(String.format("Open base pair %c", i), isOpeningString);
 215       }
 216       assertFalse(Rna.isOpeningParenthesis(String.valueOf((char) i) + " "));
 217     }
 218   }
 219
 220   @Test(groups = { "Functional" })
 221   public void testGetMatchingOpeningParenthesis() throws WUSSParseException
 222   {
 223     for (int i = 0; i <= 255; i++)
 224     {
 225       boolean isClosing = Rna.isClosingParenthesis((char) i);
 226       if (isClosing)
 227       {
 228         char opening = Rna.getMatchingOpeningParenthesis((char) i);
 229         if (i >= 'a' && i <= 'z')
 230         {
 231           assertEquals(i + 'A' - 'a', opening);
 232         }
 233         else if (i == ')' && opening == '(' || i == ']' && opening == '['
 234                 || i == '}' && opening == '{' || i == '>' && opening == '<')
 235         {
 236           // ok
 237         }
 238         else
 239         {
 240           fail("Got " + opening + " as opening bracket pair for "
 241                   + ((char) i));
 242         }
 243       }
 244     }
 245   }
 246
 247   /**
 248    * Tests for isRnaSecondaryStructureSymbol with char or String argument
 249    */
 250   @Test(groups = { "Functional" })
 251   public void testIsRnaSecondaryStructureSymbol()
 252   {
 253     assertFalse(Rna.isRnaSecondaryStructureSymbol(null));
 254
 255     /*
 256      * only A-Z,  a-z, ()[]{}<> are valid symbols
 257      */
 258     for (int i = 0; i <= 255; i++)
 259     {
 260       boolean isValidChar = Rna.isRnaSecondaryStructureSymbol((char) i);
 261       boolean isValidString = Rna.isRnaSecondaryStructureSymbol(String
 262               .valueOf((char) i));
 263       if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z') || i == '('
 264               || i == ')' || i == '{' || i == '}' || i == '[' || i == ']'
 265               || i == '<' || i == '>')
 266       {
 267         assertTrue(String.format("close base pair %c", i), isValidChar);
 268         assertTrue(String.format("close base pair %c", i), isValidString);
 269       }
 270       else
 271       {
 272         assertFalse(String.format("close base pair %c", i), isValidChar);
 273         assertFalse(String.format("close base pair %c", i), isValidString);
 274       }
 275       assertFalse(Rna.isRnaSecondaryStructureSymbol(String
 276               .valueOf((char) i) + " "));
 277     }
 278   }
 279 }