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   @Test(groups = { "Functional" })
 192   public void testIsCanonicalPair()
 193   {
 194     String bases = "acgtuACGTU";
 195     for (int i = 0; i < bases.length(); i++)
 196     {
 197       for (int j = 0; j < bases.length(); j++)
 198       {
 199         char first = bases.charAt(i);
 200         char second = bases.charAt(j);
 201         boolean result = Rna.isCanonicalPair(first, second);
 202         String pair = new String(new char[] { first, second })
 203                 .toUpperCase();
 204         if (pair.equals("AT") || pair.equals("TA") || pair.equals("AU")
 205                 || pair.equals("UA") || pair.equals("GC")
 206                 || pair.equals("CG"))
 207         {
 208           assertTrue(pair + " should be valid", result);
 209         }
 210         else
 211         {
 212           assertFalse(pair + " should be invalid", result);
 213         }
 214       }
 215     }
 216   }
 217
 218   /**
 219    * Tests for isOpeningParenthesis with char or String argument
 220    */
 221   @Test(groups = { "Functional" })
 222   public void testIsOpeningParenthesis()
 223   {
 224     /*
 225      * only A-Z, ([{< are opening bracket symbols
 226      */
 227     for (int i = 0; i <= 255; i++)
 228     {
 229       boolean isOpeningChar = Rna.isOpeningParenthesis((char) i);
 230       boolean isOpeningString = Rna.isOpeningParenthesis(String
 231               .valueOf((char) i));
 232       if ((i >= 'A' && i <= 'Z') || i == '(' || i == '{' || i == '['
 233               || i == '<')
 234       {
 235         assertTrue(String.format("Open base pair %c", i), isOpeningChar);
 236         assertTrue(String.format("Open base pair %c", i), isOpeningString);
 237       }
 238       else
 239       {
 240         assertFalse(String.format("Open base pair %c", i), isOpeningChar);
 241         assertFalse(String.format("Open base pair %c", i), isOpeningString);
 242       }
 243       assertFalse(Rna.isOpeningParenthesis(String.valueOf((char) i) + " "));
 244     }
 245   }
 246
 247   @Test(groups = { "Functional" })
 248   public void testGetMatchingOpeningParenthesis() throws WUSSParseException
 249   {
 250     for (int i = 0; i <= 255; i++)
 251     {
 252       boolean isClosing = Rna.isClosingParenthesis((char) i);
 253       if (isClosing)
 254       {
 255         char opening = Rna.getMatchingOpeningParenthesis((char) i);
 256         if (i >= 'a' && i <= 'z')
 257         {
 258           assertEquals(i + 'A' - 'a', opening);
 259         }
 260         else if (i == ')' && opening == '(' || i == ']' && opening == '['
 261                 || i == '}' && opening == '{' || i == '>' && opening == '<')
 262         {
 263           // ok
 264         }
 265         else
 266         {
 267           fail("Got " + opening + " as opening bracket pair for "
 268                   + ((char) i));
 269         }
 270       }
 271     }
 272   }
 273
 274   /**
 275    * Tests for isRnaSecondaryStructureSymbol with char or String argument
 276    */
 277   @Test(groups = { "Functional" })
 278   public void testIsRnaSecondaryStructureSymbol()
 279   {
 280     assertFalse(Rna.isRnaSecondaryStructureSymbol(null));
 281
 282     /*
 283      * only A-Z,  a-z, ()[]{}<> are valid symbols
 284      */
 285     for (int i = 0; i <= 255; i++)
 286     {
 287       boolean isValidChar = Rna.isRnaSecondaryStructureSymbol((char) i);
 288       boolean isValidString = Rna.isRnaSecondaryStructureSymbol(String
 289               .valueOf((char) i));
 290       if ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z') || i == '('
 291               || i == ')' || i == '{' || i == '}' || i == '[' || i == ']'
 292               || i == '<' || i == '>')
 293       {
 294         assertTrue(String.format("close base pair %c", i), isValidChar);
 295         assertTrue(String.format("close base pair %c", i), isValidString);
 296       }
 297       else
 298       {
 299         assertFalse(String.format("close base pair %c", i), isValidChar);
 300         assertFalse(String.format("close base pair %c", i), isValidString);
 301       }
 302       assertFalse(Rna.isRnaSecondaryStructureSymbol(String
 303               .valueOf((char) i) + " "));
 304     }
 305   }
 306 }