test/jalview/datamodel/AlignedCodonIteratorTest.java

   1 package jalview.datamodel;
   2
   3 import static org.testng.AssertJUnit.assertEquals;
   4 import static org.testng.AssertJUnit.assertFalse;
   5
   6 import jalview.util.MapList;
   7
   8 import java.util.Iterator;
   9
  10 import org.testng.Assert;
  11 import org.testng.annotations.Test;
  12
  13 /**
  14  * Unit tests for Mapping$AlignedCodonIterator
  15  *
  16  * @author gmcarstairs
  17  *
  18  */
  19 public class AlignedCodonIteratorTest
  20 {
  21   /**
  22    * Test normal case for iterating over aligned codons.
  23    */
  24   @Test(groups = { "Functional" })
  25   public void testNext()
  26   {
  27     SequenceI from = new Sequence("Seq1", "-CgC-C-cCtAG-AtG-Gc");
  28     from.createDatasetSequence();
  29     SequenceI to = new Sequence("Seq1", "-PQ-R-");
  30     to.createDatasetSequence();
  31     MapList map = new MapList(
  32             new int[] { 1, 1, 3, 4, 6, 6, 8, 10, 12, 13 },
  33             new int[] { 1, 3 }, 3, 1);
  34     Mapping m = new Mapping(to.getDatasetSequence(), map);
  35
  36     Iterator<AlignedCodon> codons = m.getCodonIterator(from, '-');
  37     AlignedCodon codon = codons.next();
  38     assertEquals("[1, 3, 5]", codon.toString());
  39     assertEquals("P", codon.product);
  40     codon = codons.next();
  41     assertEquals("[8, 10, 11]", codon.toString());
  42     assertEquals("Q", codon.product);
  43     codon = codons.next();
  44     assertEquals("[13, 15, 17]", codon.toString());
  45     assertEquals("R", codon.product);
  46     assertFalse(codons.hasNext());
  47   }
  48
  49   /**
  50    * Test weird case where the mapping skips over a peptide.
  51    */
  52   @Test(groups = { "Functional" })
  53   public void testNext_unmappedPeptide()
  54   {
  55     SequenceI from = new Sequence("Seq1", "-CgC-C-cCtAG-AtG-Gc");
  56     from.createDatasetSequence();
  57     SequenceI to = new Sequence("Seq1", "-PQ-TR-");
  58     to.createDatasetSequence();
  59     MapList map = new MapList(
  60             new int[] { 1, 1, 3, 4, 6, 6, 8, 10, 12, 13 }, new int[] { 1,
  61                 2, 4, 4 }, 3, 1);
  62     Mapping m = new Mapping(to.getDatasetSequence(), map);
  63
  64     Iterator<AlignedCodon> codons = m.getCodonIterator(from, '-');
  65     AlignedCodon codon = codons.next();
  66     assertEquals("[1, 3, 5]", codon.toString());
  67     assertEquals("P", codon.product);
  68     codon = codons.next();
  69     assertEquals("[8, 10, 11]", codon.toString());
  70     assertEquals("Q", codon.product);
  71     codon = codons.next();
  72     assertEquals("[13, 15, 17]", codon.toString());
  73     assertEquals("R", codon.product);
  74     assertFalse(codons.hasNext());
  75   }
  76
  77   /**
  78    * Test for exception thrown for an incomplete codon.
  79    */
  80   @Test(groups = { "Functional" })
  81   public void testNext_incompleteCodon()
  82   {
  83     SequenceI from = new Sequence("Seq1", "-CgC-C-cCgTt");
  84     from.createDatasetSequence();
  85     SequenceI to = new Sequence("Seq1", "-PQ-R-");
  86     to.createDatasetSequence();
  87     MapList map = new MapList(new int[] { 1, 1, 3, 4, 6, 6, 8, 8 },
  88             new int[] { 1, 3 }, 3, 1);
  89     Mapping m = new Mapping(to.getDatasetSequence(), map);
  90
  91     Iterator<AlignedCodon> codons = m.getCodonIterator(from, '-');
  92     AlignedCodon codon = codons.next();
  93     assertEquals("[1, 3, 5]", codon.toString());
  94     assertEquals("P", codon.product);
  95     try
  96     {
  97       codon = codons.next();
  98       Assert.fail("expected exception");
  99     } catch (IncompleteCodonException e)
 100     {
 101       // expected
 102     }
 103   }
 104
 105   /**
 106    * Test normal case for iterating over aligned codons.
 107    */
 108   @Test(groups = { "Functional" })
 109   public void testAnother()
 110   {
 111     SequenceI from = new Sequence("Seq1", "TGCCATTACCAG-");
 112     from.createDatasetSequence();
 113     SequenceI to = new Sequence("Seq1", "CHYQ");
 114     to.createDatasetSequence();
 115     MapList map = new MapList(new int[] { 1, 12 }, new int[] { 1, 4 }, 3, 1);
 116     Mapping m = new Mapping(to.getDatasetSequence(), map);
 117
 118     Iterator<AlignedCodon> codons = m.getCodonIterator(from, '-');
 119     AlignedCodon codon = codons.next();
 120     assertEquals("[0, 1, 2]", codon.toString());
 121     assertEquals("C", codon.product);
 122     codon = codons.next();
 123     assertEquals("[3, 4, 5]", codon.toString());
 124     assertEquals("H", codon.product);
 125     codon = codons.next();
 126     assertEquals("[6, 7, 8]", codon.toString());
 127     assertEquals("Y", codon.product);
 128     codon = codons.next();
 129     assertEquals("[9, 10, 11]", codon.toString());
 130     assertEquals("Q", codon.product);
 131     assertFalse(codons.hasNext());
 132   }
 133 }