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