+ 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));
+
+ /*
+ * 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));