X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FAlignedCodonFrameTest.java;h=3474880f8575a45d7c8d3aa1bcadccad3c623fac;hb=57738a1f3c19b1c3a00bd3ac5108f8cd0af32f99;hp=989ed7c3d8ff660f99d538ccdc9e4ec0ff1681e3;hpb=da768251d307c7ce11283d72e0e522b2c5fac526;p=jalview.git diff --git a/test/jalview/datamodel/AlignedCodonFrameTest.java b/test/jalview/datamodel/AlignedCodonFrameTest.java index 989ed7c..3474880 100644 --- a/test/jalview/datamodel/AlignedCodonFrameTest.java +++ b/test/jalview/datamodel/AlignedCodonFrameTest.java @@ -22,21 +22,32 @@ package jalview.datamodel; import static org.testng.AssertJUnit.assertEquals; import static org.testng.AssertJUnit.assertFalse; +import static org.testng.AssertJUnit.assertNotNull; import static org.testng.AssertJUnit.assertNull; import static org.testng.AssertJUnit.assertSame; import static org.testng.AssertJUnit.assertTrue; import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals; -import jalview.util.MapList; - import java.util.Arrays; import java.util.List; +import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; +import jalview.datamodel.AlignedCodonFrame.SequenceToSequenceMapping; +import jalview.gui.JvOptionPane; +import jalview.util.MapList; + public class AlignedCodonFrameTest { + @BeforeClass(alwaysRun = true) + public void setUpJvOptionPane() + { + JvOptionPane.setInteractiveMode(false); + JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); + } + /** * Test the method that locates the first aligned sequence that has a mapping. */ @@ -72,11 +83,14 @@ public class AlignedCodonFrameTest /* * DNA seq1 maps to AA seq2 */ - assertEquals(aa.getSequenceAt(1), acf.findAlignedSequence(cdna - .getSequenceAt(0).getDatasetSequence(), aa)); - - assertEquals(cdna.getSequenceAt(0), acf.findAlignedSequence(aa - .getSequenceAt(1).getDatasetSequence(), cdna)); + assertEquals(aa.getSequenceAt(1), acf.findAlignedSequence( + cdna.getSequenceAt(0).getDatasetSequence(), aa)); + // can also find this from the dna aligned sequence + assertEquals(aa.getSequenceAt(1), + acf.findAlignedSequence(cdna.getSequenceAt(0), aa)); + + assertEquals(cdna.getSequenceAt(0), acf.findAlignedSequence( + aa.getSequenceAt(1).getDatasetSequence(), cdna)); } /** @@ -86,52 +100,69 @@ public class AlignedCodonFrameTest public void testGetMappedRegion() { // introns lower case, exons upper case - final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); - seq1.createDatasetSequence(); - final Sequence seq2 = new Sequence("Seq2", "-TA-gG-Gg-CG-a"); - seq2.createDatasetSequence(); + final Sequence dna1 = new Sequence("Seq1/10-18", "c-G-TA-gC-gT-T"); + dna1.createDatasetSequence(); + final Sequence dna2 = new Sequence("Seq2/20-28", "-TA-gG-Gg-CG-a"); + dna2.createDatasetSequence(); - final Sequence aseq1 = new Sequence("Seq1", "-P-R"); - aseq1.createDatasetSequence(); - final Sequence aseq2 = new Sequence("Seq2", "-LY-Q"); - aseq2.createDatasetSequence(); + final Sequence pep1 = new Sequence("Seq1/3-4", "-P-R"); + pep1.createDatasetSequence(); + final Sequence pep2 = new Sequence("Seq2/7-9", "-LY-Q"); + pep2.createDatasetSequence(); /* * First with no mappings */ AlignedCodonFrame acf = new AlignedCodonFrame(); - assertNull(acf.getMappedRegion(seq1, aseq1, 1)); + assertNull(acf.getMappedRegion(dna1, pep1, 3)); /* * Set up the mappings for the exons (upper-case bases) * Note residue Q is unmapped */ - MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, new int[] { - 1, 2 }, 3, 1); - acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); - map = new MapList(new int[] { 1, 2, 4, 5, 7, 8 }, new int[] { 1, 2 }, - 3, 1); - acf.addMap(seq2.getDatasetSequence(), aseq2.getDatasetSequence(), map); + MapList map1 = new MapList(new int[] { 11, 13, 15, 15, 17, 18 }, + new int[] + { 3, 4 }, 3, 1); + acf.addMap(dna1.getDatasetSequence(), pep1.getDatasetSequence(), map1); + MapList map2 = new MapList(new int[] { 20, 21, 23, 24, 26, 27 }, + new int[] + { 7, 9 }, 3, 1); + acf.addMap(dna2.getDatasetSequence(), pep2.getDatasetSequence(), map2); - assertArrayEquals(new int[] { 2, 4 }, - acf.getMappedRegion(seq1, aseq1, 1)); - assertArrayEquals(new int[] { 6, 6, 8, 9 }, - acf.getMappedRegion(seq1, aseq1, 2)); - assertArrayEquals(new int[] { 1, 2, 4, 4 }, - acf.getMappedRegion(seq2, aseq2, 1)); - assertArrayEquals(new int[] { 5, 5, 7, 8 }, - acf.getMappedRegion(seq2, aseq2, 2)); + /* + * get codon positions for peptide position + */ + assertArrayEquals(new int[] { 11, 13 }, + acf.getMappedRegion(dna1, pep1, 3)); + assertArrayEquals(new int[] { 15, 15, 17, 18 }, + acf.getMappedRegion(dna1, pep1, 4)); + assertArrayEquals(new int[] { 20, 21, 23, 23 }, + acf.getMappedRegion(dna2, pep2, 7)); + assertArrayEquals(new int[] { 24, 24, 26, 27 }, + acf.getMappedRegion(dna2, pep2, 8)); /* - * No mapping from seq2 to Q + * No mapping from dna2 to Q */ - assertNull(acf.getMappedRegion(seq2, aseq2, 3)); + assertNull(acf.getMappedRegion(dna2, pep2, 9)); /* - * No mapping from sequence 1 to sequence 2 + * No mapping from dna1 to pep2 */ - assertNull(acf.getMappedRegion(seq1, aseq2, 1)); + assertNull(acf.getMappedRegion(dna1, pep2, 7)); + + /* + * get peptide position for codon position + */ + assertArrayEquals(new int[] { 3, 3 }, + acf.getMappedRegion(pep1, dna1, 11)); + assertArrayEquals(new int[] { 3, 3 }, + acf.getMappedRegion(pep1, dna1, 12)); + assertArrayEquals(new int[] { 3, 3 }, + acf.getMappedRegion(pep1, dna1, 13)); + assertNull(acf.getMappedRegion(pep1, dna1, 14)); // intron base, not mapped + } @Test(groups = { "Functional" }) @@ -152,20 +183,17 @@ public class AlignedCodonFrameTest /* * Set up the mappings for the exons (upper-case bases) */ - MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, new int[] { - 1, 2 }, 3, 1); + MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, + new int[] + { 1, 2 }, 3, 1); acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); - assertEquals(1, acf.getMappedCodons(aseq1.getDatasetSequence(), 1) - .size()); - assertEquals( - "[G, T, A]", - Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), - 1).get(0))); - assertEquals( - "[C, T, T]", - Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), - 2).get(0))); + assertEquals(1, + acf.getMappedCodons(aseq1.getDatasetSequence(), 1).size()); + assertEquals("[G, T, A]", Arrays.toString( + acf.getMappedCodons(aseq1.getDatasetSequence(), 1).get(0))); + assertEquals("[C, T, T]", Arrays.toString( + acf.getMappedCodons(aseq1.getDatasetSequence(), 2).get(0))); } /** @@ -187,19 +215,20 @@ public class AlignedCodonFrameTest /* * Set up the mappings for the exons (upper-case bases) */ - MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, new int[] { - 1, 2 }, 3, 1); + MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, + new int[] + { 1, 2 }, 3, 1); acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); acf.addMap(seq2.getDatasetSequence(), aseq1.getDatasetSequence(), map); - assertEquals(2, acf.getMappedCodons(aseq1.getDatasetSequence(), 1) - .size()); - List codonsForV = acf.getMappedCodons( - aseq1.getDatasetSequence(), 1); + assertEquals(2, + acf.getMappedCodons(aseq1.getDatasetSequence(), 1).size()); + List codonsForV = acf + .getMappedCodons(aseq1.getDatasetSequence(), 1); assertEquals("[G, T, A]", Arrays.toString(codonsForV.get(0))); assertEquals("[G, T, T]", Arrays.toString(codonsForV.get(1))); - List codonsForL = acf.getMappedCodons( - aseq1.getDatasetSequence(), 2); + List codonsForL = acf + .getMappedCodons(aseq1.getDatasetSequence(), 2); assertEquals("[C, T, T]", Arrays.toString(codonsForL.get(0))); assertEquals("[T, T, A]", Arrays.toString(codonsForL.get(1))); } @@ -221,17 +250,14 @@ public class AlignedCodonFrameTest */ AlignedCodonFrame acf = new AlignedCodonFrame(); MapList map = new MapList(new int[] { 28, 30, 32, 32, 34, 35 }, - new int[] { 12, 13 }, 3, 1); + new int[] + { 12, 13 }, 3, 1); acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); - assertEquals( - "[G, T, A]", - Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), - 12).get(0))); - assertEquals( - "[C, T, T]", - Arrays.toString(acf.getMappedCodons(aseq1.getDatasetSequence(), - 13).get(0))); + assertEquals("[G, T, A]", Arrays.toString( + acf.getMappedCodons(aseq1.getDatasetSequence(), 12).get(0))); + assertEquals("[C, T, T]", Arrays.toString( + acf.getMappedCodons(aseq1.getDatasetSequence(), 13).get(0))); } @Test(groups = { "Functional" }) @@ -244,13 +270,13 @@ public class AlignedCodonFrameTest assertTrue(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 12, 17)); // map to region overlapping sequence is ok - assertTrue(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 5, - 10)); + assertTrue( + AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 5, 10)); assertTrue(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 21, 26)); // map to region before sequence is not ok - assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 4, - 9)); + assertFalse( + AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 4, 9)); // map to region after sequence is not ok assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 22, 27)); @@ -283,7 +309,8 @@ public class AlignedCodonFrameTest * a real sequence can't replace a real one */ SequenceI seq1a = new Sequence("Seq1/10-21", "aaacccgggttt"); - assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1, seq1a, 12, 17)); + assertFalse( + AlignedCodonFrame.couldRealiseSequence(seq1, seq1a, 12, 17)); } /** @@ -405,7 +432,8 @@ public class AlignedCodonFrameTest * map Seq1 to all of Seq2 and part of Seq3 */ AlignedCodonFrame acf = new AlignedCodonFrame(); - MapList map = new MapList(new int[] { 1, 12 }, new int[] { 1, 4 }, 3, 1); + MapList map = new MapList(new int[] { 1, 12 }, new int[] { 1, 4 }, 3, + 1); acf.addMap(seq1.getDatasetSequence(), seq2.getDatasetSequence(), map); map = new MapList(new int[] { 1, 12 }, new int[] { 3, 6 }, 3, 1); acf.addMap(seq1.getDatasetSequence(), seq3.getDatasetSequence(), map); @@ -448,4 +476,242 @@ public class AlignedCodonFrameTest assertArrayEquals(new int[] { 2, 2 }, acf.getMappedRegion(seq2, seq1, 6)); } + + /** + * Tests for addMap. See also tests for MapList.addMapList + */ + @Test(groups = { "Functional" }) + public void testAddMap() + { + final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); + seq1.createDatasetSequence(); + final Sequence aseq1 = new Sequence("Seq1", "-V-L"); + aseq1.createDatasetSequence(); + + AlignedCodonFrame acf = new AlignedCodonFrame(); + MapList map = new MapList(new int[] { 2, 4, 6, 6, 8, 9 }, + new int[] + { 1, 2 }, 3, 1); + acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); + assertEquals(1, acf.getMappingsFromSequence(seq1).size()); + Mapping before = acf.getMappingsFromSequence(seq1).get(0); + + /* + * add the same map again, verify it doesn't get duplicated + */ + acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); + assertEquals(1, acf.getMappingsFromSequence(seq1).size()); + assertSame(before, acf.getMappingsFromSequence(seq1).get(0)); + } + + @Test(groups = { "Functional" }) + public void testGetCoveringMapping() + { + SequenceI dna = new Sequence("dna", "acttcaATGGCGGACtaattt"); + SequenceI cds = new Sequence("cds/7-15", "ATGGCGGAC"); + cds.setDatasetSequence(dna); + SequenceI pep = new Sequence("pep", "MAD"); + + /* + * with null argument or no mappings + */ + AlignedCodonFrame acf = new AlignedCodonFrame(); + assertNull(acf.getCoveringMapping(null, null)); + assertNull(acf.getCoveringMapping(dna, null)); + assertNull(acf.getCoveringMapping(null, pep)); + assertNull(acf.getCoveringMapping(dna, pep)); + + /* + * with a non-covering mapping e.g. overlapping exon + */ + MapList map = new MapList(new int[] { 7, 9 }, new int[] { 1, 1 }, 3, 1); + acf.addMap(dna, pep, map); + assertNull(acf.getCoveringMapping(dna, pep)); + + acf = new AlignedCodonFrame(); + MapList map2 = new MapList(new int[] { 13, 18 }, new int[] { 2, 2 }, 3, + 1); + acf.addMap(dna, pep, map2); + assertNull(acf.getCoveringMapping(dna, pep)); + + /* + * with a covering mapping from CDS (dataset) to protein + */ + acf = new AlignedCodonFrame(); + MapList map3 = new MapList(new int[] { 7, 15 }, new int[] { 1, 3 }, 3, + 1); + acf.addMap(dna, pep, map3); + assertNull(acf.getCoveringMapping(dna, pep)); + SequenceToSequenceMapping mapping = acf.getCoveringMapping(cds, pep); + assertNotNull(mapping); + + /* + * with a mapping that extends to stop codon + */ + acf = new AlignedCodonFrame(); + MapList map4 = new MapList(new int[] { 7, 18 }, new int[] { 1, 3 }, 3, + 1); + acf.addMap(dna, pep, map4); + assertNull(acf.getCoveringMapping(dna, pep)); + assertNull(acf.getCoveringMapping(cds, pep)); + SequenceI cds2 = new Sequence("cds/7-18", "ATGGCGGACtaa"); + cds2.setDatasetSequence(dna); + mapping = acf.getCoveringMapping(cds2, pep); + assertNotNull(mapping); + } + + /** + * Test the method that adds mapped positions to SearchResults + */ + @Test(groups = { "Functional" }) + public void testMarkMappedRegion() + { + // introns lower case, exons upper case + final Sequence dna1 = new Sequence("Seq1/10-18", "c-G-TA-gC-gT-T"); + dna1.createDatasetSequence(); + final Sequence dna2 = new Sequence("Seq2/20-28", "-TA-gG-Gg-CG-a"); + dna2.createDatasetSequence(); + + final Sequence pep1 = new Sequence("Seq1/3-4", "-P-R"); + pep1.createDatasetSequence(); + final Sequence pep2 = new Sequence("Seq2/7-9", "-LY-Q"); + pep2.createDatasetSequence(); + + /* + * First with no mappings + */ + AlignedCodonFrame acf = new AlignedCodonFrame(); + SearchResults sr = new SearchResults(); + acf.markMappedRegion(dna1, 12, sr); + assertTrue(sr.isEmpty()); + + /* + * Set up the mappings for the exons (upper-case bases) + * Note residue Q is unmapped + */ + MapList map1 = new MapList(new int[] { 11, 13, 15, 15, 17, 18 }, + new int[] + { 3, 4 }, 3, 1); + acf.addMap(dna1.getDatasetSequence(), pep1.getDatasetSequence(), map1); + MapList map2 = new MapList(new int[] { 20, 21, 23, 24, 26, 27 }, + new int[] + { 7, 8 }, 3, 1); + acf.addMap(dna2.getDatasetSequence(), pep2.getDatasetSequence(), map2); + + /* + * intron bases are not mapped + */ + acf.markMappedRegion(dna1, 10, sr); + assertTrue(sr.isEmpty()); + + /* + * Q is not mapped + */ + acf.markMappedRegion(pep2, 9, sr); + assertTrue(sr.isEmpty()); + + /* + * mark peptide position for exon position (of aligned sequence) + */ + acf.markMappedRegion(dna1, 11, sr); + SearchResults expected = new SearchResults(); + expected.addResult(pep1.getDatasetSequence(), 3, 3); + assertEquals(sr, expected); + + /* + * mark peptide position for exon position of dataset sequence - same result + */ + sr = new SearchResults(); + acf.markMappedRegion(dna1.getDatasetSequence(), 11, sr); + assertEquals(sr, expected); + + /* + * marking the same position a second time should not create a duplicate match + */ + acf.markMappedRegion(dna1.getDatasetSequence(), 12, sr); + assertEquals(sr, expected); + + /* + * mark exon positions for peptide position (of aligned sequence) + */ + sr = new SearchResults(); + acf.markMappedRegion(pep2, 7, sr); // codon positions 20, 21, 23 + expected = new SearchResults(); + expected.addResult(dna2.getDatasetSequence(), 20, 21); + expected.addResult(dna2.getDatasetSequence(), 23, 23); + assertEquals(sr, expected); + + /* + * add another codon to the same SearchResults + */ + acf.markMappedRegion(pep1.getDatasetSequence(), 4, sr); // codon positions + // 15, 17, 18 + expected.addResult(dna1.getDatasetSequence(), 15, 15); + expected.addResult(dna1.getDatasetSequence(), 17, 18); + assertEquals(sr, expected); + } + + @Test(groups = { "Functional" }) + public void testGetCoveringCodonMapping() + { + SequenceI dna = new Sequence("dna/10-30", "acttcaATGGCGGACtaattt"); + // CDS sequence with its own dataset sequence (JAL-3763) + SequenceI cds = new Sequence("cds/1-9", "-A--TGGC-GGAC"); + cds.createDatasetSequence(); + SequenceI pep = new Sequence("pep/1-3", "MAD"); + + /* + * with null argument or no mappings + */ + AlignedCodonFrame acf = new AlignedCodonFrame(); + assertNull(acf.getCoveringCodonMapping(null)); + assertNull(acf.getCoveringCodonMapping(dna)); + assertNull(acf.getCoveringCodonMapping(pep)); + + /* + * with a non-covering mapping e.g. overlapping exon + */ + MapList map = new MapList(new int[] { 16, 18 }, new int[] { 1, 1 }, 3, + 1); + acf.addMap(dna, pep, map); + assertNull(acf.getCoveringCodonMapping(dna)); + assertNull(acf.getCoveringCodonMapping(pep)); + + acf = new AlignedCodonFrame(); + MapList map2 = new MapList(new int[] { 13, 18 }, new int[] { 2, 2 }, 3, + 1); + acf.addMap(dna, pep, map2); + assertNull(acf.getCoveringCodonMapping(dna)); + assertNull(acf.getCoveringCodonMapping(pep)); + + /* + * with a covering mapping from CDS (dataset) to protein + */ + acf = new AlignedCodonFrame(); + MapList map3 = new MapList(new int[] { 1, 9 }, new int[] { 1, 3 }, 3, + 1); + acf.addMap(cds.getDatasetSequence(), pep, map3); + assertNull(acf.getCoveringCodonMapping(dna)); + SequenceToSequenceMapping mapping = acf.getCoveringCodonMapping(pep); + assertNotNull(mapping); + SequenceToSequenceMapping mapping2 = acf + .getCoveringCodonMapping(cds.getDatasetSequence()); + assertSame(mapping, mapping2); + + /* + * with a mapping that extends to stop codon + * (EMBL CDS location often includes the stop codon) + * - getCoveringCodonMapping is lenient (doesn't require exact length match) + */ + SequenceI cds2 = new Sequence("cds/1-12", "-A--TGGC-GGACTAA"); + cds2.createDatasetSequence(); + acf = new AlignedCodonFrame(); + MapList map4 = new MapList(new int[] { 1, 12 }, new int[] { 1, 3 }, 3, + 1); + acf.addMap(cds2, pep, map4); + mapping = acf.getCoveringCodonMapping(cds2.getDatasetSequence()); + assertNotNull(mapping); + mapping2 = acf.getCoveringCodonMapping(pep); + assertSame(mapping, mapping2); + } }