X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FAlignedCodonFrameTest.java;h=0cfc38035d9034efd7a9424fc38f652775084fb2;hb=df0035d38851d468e8f6991ad6ed1c8f6cce2610;hp=16c0367a8827a671d555762e50c73185cd5fde2c;hpb=17e77c3f2949a0729322b4a8d907f3f34b6a9914;p=jalview.git diff --git a/test/jalview/datamodel/AlignedCodonFrameTest.java b/test/jalview/datamodel/AlignedCodonFrameTest.java index 16c0367..0cfc380 100644 --- a/test/jalview/datamodel/AlignedCodonFrameTest.java +++ b/test/jalview/datamodel/AlignedCodonFrameTest.java @@ -1,6 +1,6 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9) - * Copyright (C) 2015 The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors * * This file is part of Jalview. * @@ -21,17 +21,33 @@ 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 jalview.util.MapList; +import static org.testng.AssertJUnit.assertSame; +import static org.testng.AssertJUnit.assertTrue; +import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals; 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. */ @@ -69,6 +85,9 @@ public class AlignedCodonFrameTest */ 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)); @@ -81,22 +100,83 @@ public class AlignedCodonFrameTest public void testGetMappedRegion() { // 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(); + + assertNull(acf.getMappedRegion(dna1, pep1, 3)); + + /* + * 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, 9 }, + 3, 1); + acf.addMap(dna2.getDatasetSequence(), pep2.getDatasetSequence(), map2); + + /* + * 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 dna2 to Q + */ + assertNull(acf.getMappedRegion(dna2, pep2, 9)); + + /* + * No mapping from dna1 to pep2 + */ + 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" }) + public void testGetMappedCodons() + { 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 aseq1 = new Sequence("Seq1", "-P-R"); + final Sequence aseq1 = new Sequence("Seq1", "-V-L"); aseq1.createDatasetSequence(); - final Sequence aseq2 = new Sequence("Seq2", "-LY-"); - aseq2.createDatasetSequence(); /* * First with no mappings */ AlignedCodonFrame acf = new AlignedCodonFrame(); - assertNull(acf.getMappedRegion(seq1, aseq1, 1)); + assertNull(acf.getMappedCodons(seq1.getDatasetSequence(), 0)); /* * Set up the mappings for the exons (upper-case bases) @@ -104,50 +184,468 @@ public class AlignedCodonFrameTest 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); - assertEquals("[2, 4]", - Arrays.toString(acf.getMappedRegion(seq1, aseq1, 1))); - assertEquals("[6, 6, 8, 9]", - Arrays.toString(acf.getMappedRegion(seq1, aseq1, 2))); - assertEquals("[1, 2, 4, 4]", - Arrays.toString(acf.getMappedRegion(seq2, aseq2, 1))); - assertEquals("[5, 5, 7, 8]", - Arrays.toString(acf.getMappedRegion(seq2, aseq2, 2))); + 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))); + } + + /** + * Test for the case where there is more than one variant of the DNA mapping + * to a protein sequence + */ + @Test(groups = { "Functional" }) + public void testGetMappedCodons_dnaVariants() + { + final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); + seq1.createDatasetSequence(); + final Sequence seq2 = new Sequence("Seq2", "c-G-TT-gT-gT-A"); + seq2.createDatasetSequence(); + final Sequence aseq1 = new Sequence("Seq1", "-V-L"); + aseq1.createDatasetSequence(); + + AlignedCodonFrame acf = new AlignedCodonFrame(); /* - * No mapping from sequence 1 to sequence 2 + * Set up the mappings for the exons (upper-case bases) */ - assertNull(acf.getMappedRegion(seq1, aseq2, 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("[G, T, A]", Arrays.toString(codonsForV.get(0))); + assertEquals("[G, T, T]", Arrays.toString(codonsForV.get(1))); + 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))); } + /** + * Test for the case where sequences have start > 1 + */ @Test(groups = { "Functional" }) - public void testGetMappedCodon() + public void testGetMappedCodons_forSubSequences() { - final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T"); + final Sequence seq1 = new Sequence("Seq1", "c-G-TA-gC-gT-T", 27, 35); seq1.createDatasetSequence(); - final Sequence aseq1 = new Sequence("Seq1", "-P-R"); + + final Sequence aseq1 = new Sequence("Seq1", "-V-L", 12, 13); aseq1.createDatasetSequence(); /* - * First with no mappings + * Set up the mappings for the exons (upper-case bases) */ AlignedCodonFrame acf = new AlignedCodonFrame(); + MapList map = new MapList(new int[] { 28, 30, 32, 32, 34, 35 }, + new int[] { 12, 13 }, 3, 1); + acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); - assertNull(acf.getMappedCodon(seq1.getDatasetSequence(), 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" }) + public void testCouldReplaceSequence() + { + SequenceI seq1 = new Sequence("Seq1/10-21", "aaacccgggttt"); + SequenceI seq1proxy = new SequenceDummy("Seq1"); + + // map to region within sequence is ok + 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, 21, + 26)); + // map to region before sequence is not ok + assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 4, + 9)); + // map to region after sequence is not ok + assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 22, + 27)); /* - * Set up the mappings for the exons (upper-case bases) + * test should fail if name doesn't match + */ + seq1proxy.setName("Seq1a"); + assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 12, + 17)); + seq1proxy.setName("Seq1"); + seq1.setName("Seq1a"); + assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, seq1, 12, + 17)); + + /* + * a dummy sequence can't replace a real one + */ + assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1, seq1proxy, 12, + 17)); + + /* + * a dummy sequence can't replace a dummy sequence */ + SequenceI seq1proxy2 = new SequenceDummy("Seq1"); + assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1proxy, + seq1proxy2, 12, 17)); + + /* + * a real sequence can't replace a real one + */ + SequenceI seq1a = new Sequence("Seq1/10-21", "aaacccgggttt"); + assertFalse(AlignedCodonFrame.couldRealiseSequence(seq1, seq1a, 12, 17)); + } + + /** + * Tests for the method that tests whether any mapping to a dummy sequence can + * be 'realised' to a given real sequence + */ + @Test(groups = { "Functional" }) + public void testIsRealisableWith() + { + SequenceI seq1 = new Sequence("Seq1", "tttaaaCCCGGGtttaaa"); + SequenceI seq2 = new Sequence("Seq2", "PG"); + SequenceI seq1proxy = new SequenceDummy("Seq1"); + seq1.createDatasetSequence(); + seq2.createDatasetSequence(); + MapList mapList = new MapList(new int[] { 7, 12 }, new int[] { 2, 3 }, + 3, 1); + AlignedCodonFrame acf = new AlignedCodonFrame(); + acf.addMap(seq1proxy, seq2, mapList); + + /* + * Seq2 is mapped to SequenceDummy seq1proxy bases 4-9 + * This is 'realisable' from real sequence Seq1 + */ + assertTrue(acf.isRealisableWith(seq1)); + + /* + * test should fail if name doesn't match + */ + seq1proxy.setName("Seq1a"); + assertFalse(acf.isRealisableWith(seq1)); + seq1proxy.setName("Seq1"); + + SequenceI seq1ds = seq1.getDatasetSequence(); + seq1ds.setName("Seq1a"); + assertFalse(acf.isRealisableWith(seq1)); + seq1ds.setName("Seq1"); + + /* + * test should fail if no sequence overlap with mapping of bases 7-12 + * use artificial start/end values to test this + */ + seq1ds.setStart(1); + seq1ds.setEnd(6); + // seq1 precedes mapped region: + assertFalse(acf.isRealisableWith(seq1)); + seq1ds.setEnd(7); + // seq1 includes first mapped base: + assertTrue(acf.isRealisableWith(seq1)); + seq1ds.setStart(13); + seq1ds.setEnd(18); + // seq1 follows mapped region: + assertFalse(acf.isRealisableWith(seq1)); + seq1ds.setStart(12); + // seq1 includes last mapped base: + assertTrue(acf.isRealisableWith(seq1)); + } + + /** + * Tests for the method that converts mappings to a dummy sequence to mappings + * to a compatible real sequence + */ + @Test(groups = { "Functional" }) + public void testRealiseWith() + { + SequenceI seq1 = new Sequence("Seq1", "tttCAACCCGGGtttaaa"); + SequenceI seq2 = new Sequence("Seq2", "QPG"); + SequenceI seq2a = new Sequence("Seq2a", "QPG"); + SequenceI seq1proxy = new SequenceDummy("Seq1"); + seq1.createDatasetSequence(); + seq2.createDatasetSequence(); + seq2a.createDatasetSequence(); + + /* + * Make mappings from Seq2 and Seq2a peptides to dummy sequence Seq1 + */ + AlignedCodonFrame acf = new AlignedCodonFrame(); + + // map PG to codons 7-12 (CCCGGG) + MapList mapping1 = new MapList(new int[] { 7, 12 }, new int[] { 2, 3 }, + 3, 1); + acf.addMap(seq1proxy, seq2, mapping1); + acf.addMap(seq1proxy, seq2a, mapping1); + + // map QP to codons 4-9 (CAACCC) + MapList mapping2 = new MapList(new int[] { 4, 9 }, new int[] { 1, 2 }, + 3, 1); + acf.addMap(seq1proxy, seq2, mapping2); + acf.addMap(seq1proxy, seq2a, mapping2); + + /* + * acf now has two mappings one from Seq1 to Seq2, one from Seq1 to Seq2a + */ + assertEquals(2, acf.getdnaSeqs().length); + assertSame(seq1proxy, acf.getdnaSeqs()[0]); + assertSame(seq1proxy, acf.getdnaSeqs()[1]); + assertEquals(2, acf.getProtMappings().length); + + // 'realise' these mappings with the compatible sequence seq1 + // two mappings should be updated: + assertEquals(2, acf.realiseWith(seq1)); + assertSame(seq1.getDatasetSequence(), acf.getdnaSeqs()[0]); + assertSame(seq1.getDatasetSequence(), acf.getdnaSeqs()[1]); + } + + /** + * Test the method that locates the mapped codon for a protein position. + */ + @Test(groups = { "Functional" }) + public void testGetMappedRegion_eitherWay() + { + final Sequence seq1 = new Sequence("Seq1", "AAACCCGGGTTT"); + seq1.createDatasetSequence(); + final Sequence seq2 = new Sequence("Seq2", "KPGF"); + seq2.createDatasetSequence(); + final Sequence seq3 = new Sequence("Seq3", "QYKPGFSW"); + seq3.createDatasetSequence(); + + /* + * 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); + 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); + + /* + * map part of Seq3 to Seq2 + */ + map = new MapList(new int[] { 3, 6 }, new int[] { 1, 4 }, 1, 1); + acf.addMap(seq3.getDatasetSequence(), seq2.getDatasetSequence(), map); + + /* + * original case - locate mapped codon for protein position + */ + assertArrayEquals(new int[] { 4, 6 }, + acf.getMappedRegion(seq1, seq2, 2)); + assertArrayEquals(new int[] { 7, 9 }, + acf.getMappedRegion(seq1, seq3, 5)); + assertNull(acf.getMappedRegion(seq1, seq3, 1)); + + /* + * locate mapped protein for protein position + */ + assertArrayEquals(new int[] { 4, 4 }, + acf.getMappedRegion(seq3, seq2, 2)); + + /* + * reverse location protein-to-protein + */ + assertArrayEquals(new int[] { 2, 2 }, + acf.getMappedRegion(seq2, seq3, 4)); + + /* + * reverse location protein-from-nucleotide + * any of codon [4, 5, 6] positions map to seq2/2 + */ + assertArrayEquals(new int[] { 2, 2 }, + acf.getMappedRegion(seq2, seq1, 4)); + assertArrayEquals(new int[] { 2, 2 }, + acf.getMappedRegion(seq2, seq1, 5)); + 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)); - assertEquals("[G, T, A]", Arrays.toString(acf.getMappedCodon( - aseq1.getDatasetSequence(), 1))); - assertEquals("[C, T, T]", Arrays.toString(acf.getMappedCodon( - aseq1.getDatasetSequence(), 2))); + /* + * 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); } }