test/jalview/analysis/GeneticCodesTest.java

   1 package jalview.analysis;
   2
   3 import static org.testng.Assert.assertEquals;
   4 import static org.testng.Assert.assertFalse;
   5 import static org.testng.Assert.assertNull;
   6 import static org.testng.Assert.assertSame;
   7
   8 import java.util.Iterator;
   9
  10 import org.testng.annotations.Test;
  11
  12 public class GeneticCodesTest
  13 {
  14   @Test(groups = "Functional")
  15   public void testGetCodeTable()
  16   {
  17     assertEquals(GeneticCodes.getStandardCodeTable().getName(), "Standard");
  18     assertEquals(GeneticCodes.getStandardCodeTable().getId(), "1");
  19     assertSame(GeneticCodes.getStandardCodeTable(),
  20             GeneticCodes.getCodeTable("1"));
  21     assertEquals(GeneticCodes.getCodeTable("2").getName(),
  22             "Vertebrate Mitochondrial");
  23     assertEquals(GeneticCodes.getCodeTable("11").getName(),
  24             "Bacterial, Archaeal and Plant Plastid");
  25     assertEquals(GeneticCodes.getCodeTable("31").getName(),
  26             "Blastocrithidia Nuclear");
  27   }
  28
  29   @Test(groups = "Functional")
  30   public void testGetCodeTables()
  31   {
  32     Iterator<GeneticCodeI> tableIterator = GeneticCodes.getCodeTables()
  33             .iterator();
  34     String[] ids = new String[] { "1", "2", "3", "4", "5", "6", "9", "10",
  35         "11", "12", "13", "14", "15", "16", "21", "22", "23", "24", "25",
  36         "26", "27", "28", "29", "30", "31" };
  37     for (int i = 0; i < ids.length; i++)
  38     {
  39       assertEquals(tableIterator.next().getId(), ids[i]);
  40     }
  41     assertFalse(tableIterator.hasNext());
  42   }
  43
  44   @Test(groups = "Functional")
  45   public void testTranslate()
  46   {
  47     GeneticCodeI gc = GeneticCodes.getCodeTable("1");
  48     assertNull(gc.translate("XYZ"));
  49     assertEquals(gc.translate("AGA"), "R");
  50
  51     gc = GeneticCodes.getCodeTable("2");
  52     assertEquals(gc.translate("AGA"), "*"); // variant
  53     assertEquals(gc.translate("ttc"), "F"); // non-variant
  54
  55     // table 11 has no variant translations - should serve the standard values
  56     gc = GeneticCodes.getCodeTable("11");
  57     assertEquals(gc.translate("ttc"), "F");
  58
  59     gc = GeneticCodes.getCodeTable("31");
  60     assertEquals(gc.translate("TGA"), "W"); // variant
  61     assertEquals(gc.translate("tag"), "E"); // variant
  62     assertEquals(gc.translate("AGC"), "S"); // non-variant
  63   }
  64
  65   /**
  66    * Test 'standard' codon translations (no ambiguity codes)
  67    */
  68   @Test(groups = { "Functional" })
  69   public void testTranslate_standardTable()
  70   {
  71     GeneticCodeI st = GeneticCodes.getStandardCodeTable();
  72     assertEquals("F", st.translate("TTT"));
  73     assertEquals("F", st.translate("TTC"));
  74     assertEquals("L", st.translate("TTA"));
  75     assertEquals("L", st.translate("TTG"));
  76     assertEquals("L", st.translate("CTT"));
  77     assertEquals("L", st.translate("CTC"));
  78     assertEquals("L", st.translate("CTA"));
  79     assertEquals("L", st.translate("CTG"));
  80     assertEquals("I", st.translate("ATT"));
  81     assertEquals("I", st.translate("ATC"));
  82     assertEquals("I", st.translate("ATA"));
  83     assertEquals("M", st.translate("ATG"));
  84     assertEquals("V", st.translate("GTT"));
  85     assertEquals("V", st.translate("GTC"));
  86     assertEquals("V", st.translate("GTA"));
  87     assertEquals("V", st.translate("GTG"));
  88     assertEquals("S", st.translate("TCT"));
  89     assertEquals("S", st.translate("TCC"));
  90     assertEquals("S", st.translate("TCA"));
  91     assertEquals("S", st.translate("TCG"));
  92     assertEquals("P", st.translate("CCT"));
  93     assertEquals("P", st.translate("CCC"));
  94     assertEquals("P", st.translate("CCA"));
  95     assertEquals("P", st.translate("CCG"));
  96     assertEquals("T", st.translate("ACT"));
  97     assertEquals("T", st.translate("ACC"));
  98     assertEquals("T", st.translate("ACA"));
  99     assertEquals("T", st.translate("ACG"));
 100     assertEquals("A", st.translate("GCT"));
 101     assertEquals("A", st.translate("GCC"));
 102     assertEquals("A", st.translate("GCA"));
 103     assertEquals("A", st.translate("GCG"));
 104     assertEquals("Y", st.translate("TAT"));
 105     assertEquals("Y", st.translate("TAC"));
 106     assertEquals("*", st.translate("TAA"));
 107     assertEquals("*", st.translate("TAG"));
 108     assertEquals("H", st.translate("CAT"));
 109     assertEquals("H", st.translate("CAC"));
 110     assertEquals("Q", st.translate("CAA"));
 111     assertEquals("Q", st.translate("CAG"));
 112     assertEquals("N", st.translate("AAT"));
 113     assertEquals("N", st.translate("AAC"));
 114     assertEquals("K", st.translate("AAA"));
 115     assertEquals("K", st.translate("AAG"));
 116     assertEquals("D", st.translate("GAT"));
 117     assertEquals("D", st.translate("GAC"));
 118     assertEquals("E", st.translate("GAA"));
 119     assertEquals("E", st.translate("GAG"));
 120     assertEquals("C", st.translate("TGT"));
 121     assertEquals("C", st.translate("TGC"));
 122     assertEquals("*", st.translate("TGA"));
 123     assertEquals("W", st.translate("TGG"));
 124     assertEquals("R", st.translate("CGT"));
 125     assertEquals("R", st.translate("CGC"));
 126     assertEquals("R", st.translate("CGA"));
 127     assertEquals("R", st.translate("CGG"));
 128     assertEquals("S", st.translate("AGT"));
 129     assertEquals("S", st.translate("AGC"));
 130     assertEquals("R", st.translate("AGA"));
 131     assertEquals("R", st.translate("AGG"));
 132     assertEquals("G", st.translate("GGT"));
 133     assertEquals("G", st.translate("GGC"));
 134     assertEquals("G", st.translate("GGA"));
 135     assertEquals("G", st.translate("GGG"));
 136   }
 137
 138   /**
 139    * Test a sample of codon translations involving ambiguity codes. Should
 140    * return a protein value where the ambiguity does not affect the translation.
 141    */
 142   @Test(groups = { "Functional" })
 143   public void testTranslate_standardTableAmbiguityCodes()
 144   {
 145     GeneticCodeI st = GeneticCodes.getStandardCodeTable();
 146     // Y is C or T
 147     assertEquals("C", st.translate("TGY"));
 148     // Phenylalanine first base variation
 149     assertEquals("L", st.translate("YTA"));
 150
 151     // W is A or T
 152     assertEquals("L", st.translate("CTW"));
 153     assertNull(st.translate("TTW"));
 154
 155     // S is G or C
 156     assertEquals("G", st.translate("GGS"));
 157     assertNull(st.translate("ATS"));
 158
 159     // K is T or G
 160     assertEquals("S", st.translate("TCK"));
 161     assertNull(st.translate("ATK"));
 162
 163     // M is C or A
 164     assertEquals("T", st.translate("ACM"));
 165     // Arginine first base variation
 166     assertEquals("R", st.translate("MGA"));
 167     assertEquals("R", st.translate("MGG"));
 168     assertNull(st.translate("TAM"));
 169
 170     // D is A, G or T
 171     assertEquals("P", st.translate("CCD"));
 172     assertNull(st.translate("AAD"));
 173
 174     // V is A, C or G
 175     assertEquals("V", st.translate("GTV"));
 176     assertNull(st.translate("TTV"));
 177
 178     // H is A, C or T
 179     assertEquals("A", st.translate("GCH"));
 180     assertEquals("I", st.translate("ATH"));
 181     assertNull(st.translate("AGH"));
 182
 183     // B is C, G or T
 184     assertEquals("P", st.translate("CCB"));
 185     assertNull(st.translate("TAB"));
 186
 187     // R is A or G
 188     // additional tests for JAL-1685 (resolved)
 189     assertEquals("L", st.translate("CTR"));
 190     assertEquals("V", st.translate("GTR"));
 191     assertEquals("S", st.translate("TCR"));
 192     assertEquals("P", st.translate("CCR"));
 193     assertEquals("T", st.translate("ACR"));
 194     assertEquals("A", st.translate("GCR"));
 195     assertEquals("R", st.translate("CGR"));
 196     assertEquals("G", st.translate("GGR"));
 197     assertEquals("R", st.translate("AGR"));
 198     assertEquals("E", st.translate("GAR"));
 199     assertEquals("K", st.translate("AAR"));
 200     assertEquals("L", st.translate("TTR"));
 201     assertEquals("Q", st.translate("CAR"));
 202     assertEquals("*", st.translate("TAR"));
 203     assertEquals("*", st.translate("TRA"));
 204     // Arginine first and third base ambiguity
 205     assertEquals("R", st.translate("MGR"));
 206     assertNull(st.translate("ATR"));
 207
 208     // N is any base; 8 proteins accept any base in 3rd position
 209     assertEquals("L", st.translate("CTN"));
 210     assertEquals("V", st.translate("GTN"));
 211     assertEquals("S", st.translate("TCN"));
 212     assertEquals("P", st.translate("CCN"));
 213     assertEquals("T", st.translate("ACN"));
 214     assertEquals("A", st.translate("GCN"));
 215     assertEquals("R", st.translate("CGN"));
 216     assertEquals("G", st.translate("GGN"));
 217     assertNull(st.translate("ATN"));
 218     assertNull(st.translate("ANT"));
 219     assertNull(st.translate("NAT"));
 220     assertNull(st.translate("ANN"));
 221     assertNull(st.translate("NNA"));
 222     assertNull(st.translate("NNN"));
 223
 224     // some random stuff
 225     assertNull(st.translate("YWB"));
 226     assertNull(st.translate("VHD"));
 227     assertNull(st.translate("WSK"));
 228   }
 229
 230   /**
 231    * Test a sample of codon translations involving ambiguity codes. Should
 232    * return a protein value where the ambiguity does not affect the translation.
 233    */
 234   @Test(groups = { "Functional" })
 235   public void testTranslate_nonStandardTableAmbiguityCodes()
 236   {
 237     GeneticCodeI standard = GeneticCodes
 238             .getStandardCodeTable();
 239
 240     /*
 241      * Vertebrate Mitochondrial (Table 2)
 242      */
 243     GeneticCodeI gc = GeneticCodes.getCodeTable("2");
 244     // AGR is AGA or AGG - R in standard code, * in table 2
 245     assertEquals(gc.translate("AGR"), "*");
 246     assertEquals(standard.translate("AGR"), "R");
 247     // TGR is TGA or TGG - ambiguous in standard code, W in table 2
 248     assertEquals(gc.translate("TGR"), "W");
 249     assertNull(standard.translate("TGR"));
 250
 251     /*
 252      * Yeast Mitochondrial (Table 3)
 253      */
 254     gc = GeneticCodes.getCodeTable("3");
 255     // CTN is L in standard code, T in table 3
 256     assertEquals(gc.translate("ctn"), "T");
 257     assertEquals(standard.translate("CTN"), "L");
 258
 259     /*
 260      * Alternative Yeast Nuclear (Table 12)
 261      */
 262     gc = GeneticCodes.getCodeTable("12");
 263     // CTG is S; in the standard code CTN is L
 264     assertEquals(gc.translate("CTG"), "S");
 265     assertNull(gc.translate("CTK")); // K is G or T -> S or L
 266     assertEquals(standard.translate("CTK"), "L");
 267     assertEquals(gc.translate("CTH"), "L"); // H is anything other than G
 268     assertEquals(standard.translate("CTH"), "L");
 269     assertEquals(standard.translate("CTN"), "L");
 270
 271     /*
 272      * Trematode Mitochondrial (Table 21)
 273      */
 274     gc = GeneticCodes.getCodeTable("21");
 275     // AAR is K in standard code, ambiguous in table 21 as AAA=N not K
 276     assertNull(gc.translate("AAR"));
 277     assertEquals(standard.translate("AAR"), "K");
 278   }
 279
 280   @Test(groups = "Functional")
 281   public void testTranslateCanonical()
 282   {
 283     GeneticCodeI gc = GeneticCodes.getCodeTable("1");
 284     assertNull(gc.translateCanonical("XYZ"));
 285     assertEquals(gc.translateCanonical("AGA"), "R");
 286     // translateCanonical should not resolve ambiguity codes
 287     assertNull(gc.translateCanonical("TGY"));
 288
 289     gc = GeneticCodes.getCodeTable("2");
 290     assertNull(gc.translateCanonical("AGR"));
 291     assertEquals(gc.translateCanonical("AGA"), "*"); // variant
 292     assertEquals(gc.translateCanonical("ttc"), "F"); // non-variant
 293   }
 294 }