import jalview.datamodel.SearchResults;
import jalview.datamodel.SearchResults.Match;
import jalview.datamodel.Sequence;
+import jalview.datamodel.SequenceFeature;
import jalview.datamodel.SequenceI;
import jalview.io.AppletFormatAdapter;
import jalview.io.FormatAdapter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
-import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
* region). The leading gap, and the gaps between codons, are subsumed by
* the protein alignment gap.
*/
- checkAlignSequenceAs("-G-GG--AA-A-", "-A-L-", true, true, map,
- "---G-GG---AA-A-");
+ checkAlignSequenceAs("-G-GG--AA-A---", "-A-L-", true, true, map,
+ "---G-GG---AA-A---");
/*
* Include only unmapped gaps in dna when realigning (outside the exon
* the protein alignment gap.
*/
checkAlignSequenceAs("-G-GG--AA-A-", "-A-L-", false, true, map,
- "---GGG---AAA-");
+ "---GGG---AAA---");
}
/**
@Test(groups = { "Functional" })
public void testAlignSequenceAs_withMapping_withUnmappedProtein()
{
-
/*
* Exons at codon 2 (AAA) and 4 (TTT) mapped to A and P
*/
1, 1, 3, 3 }, 3, 1);
/*
- * Expect alignment does nothing (aborts realignment). Change this test
- * first if different behaviour wanted.
+ * -L- 'aligns' ccc------
*/
- checkAlignSequenceAs("GGGAAACCCTTTGGG", "-A-L-P-", false, false, map,
- "GGGAAACCCTTTGGG");
+ checkAlignSequenceAs("gggAAAcccTTTggg", "-A-L-P-", false, false, map,
+ "gggAAAccc------TTTggg");
}
/**
* Helper method that performs and verifies the method under test.
*
- * @param dnaSeq
- * @param proteinSeq
+ * @param alignee
+ * the sequence to be realigned
+ * @param alignModel
+ * the sequence whose alignment is to be copied
* @param preserveMappedGaps
* @param preserveUnmappedGaps
* @param map
* @param expected
*/
- protected void checkAlignSequenceAs(final String dnaSeq,
- final String proteinSeq, final boolean preserveMappedGaps,
+ protected void checkAlignSequenceAs(final String alignee,
+ final String alignModel, final boolean preserveMappedGaps,
final boolean preserveUnmappedGaps, MapList map,
final String expected)
{
- SequenceI dna = new Sequence("Seq1", dnaSeq);
- dna.createDatasetSequence();
- SequenceI protein = new Sequence("Seq1", proteinSeq);
- protein.createDatasetSequence();
+ SequenceI alignMe = new Sequence("Seq1", alignee);
+ alignMe.createDatasetSequence();
+ SequenceI alignFrom = new Sequence("Seq2", alignModel);
+ alignFrom.createDatasetSequence();
AlignedCodonFrame acf = new AlignedCodonFrame();
- acf.addMap(dna.getDatasetSequence(), protein.getDatasetSequence(), map);
+ acf.addMap(alignMe.getDatasetSequence(), alignFrom.getDatasetSequence(), map);
- AlignmentUtils.alignSequenceAs(dna, protein, acf, "---", '-',
+ AlignmentUtils.alignSequenceAs(alignMe, alignFrom, acf, "---", '-',
preserveMappedGaps, preserveUnmappedGaps);
- assertEquals(expected, dna.getSequenceAsString());
+ assertEquals(expected, alignMe.getSequenceAsString());
}
/**
acf.addMap(dna1.getDatasetSequence(), prot1.getDatasetSequence(), map);
acf.addMap(dna2.getDatasetSequence(), prot2.getDatasetSequence(), map);
acf.addMap(dna3.getDatasetSequence(), prot3.getDatasetSequence(), map);
- protein.setCodonFrames(Collections.singleton(acf));
+ ArrayList<AlignedCodonFrame> acfs = new ArrayList<AlignedCodonFrame>();
+ acfs.add(acf);
+ protein.setCodonFrames(acfs);
/*
* Translated codon order is [1,2,3] [1,3,4] [4,5,6] [4,5,7] [5,6,7] [7,8,9]
assertTrue(AlignmentUtils.haveCrossRef(seq2, seq1));
// now the other way round
- seq1.setDBRef(null);
+ seq1.setDBRefs(null);
seq2.addDBRef(new DBRefEntry("EMBL", "1", "A12345"));
assertTrue(AlignmentUtils.haveCrossRef(seq1, seq2));
assertTrue(AlignmentUtils.haveCrossRef(seq2, seq1));
}
/**
- * Test the method that extracts the exon-only part of a dna alignment.
+ * Test the method that extracts the cds-only part of a dna alignment.
*/
@Test(groups = { "Functional" })
- public void testMakeExonAlignment()
+ public void testMakeCdsAlignment()
{
SequenceI dna1 = new Sequence("dna1", "aaaGGGcccTTTaaa");
SequenceI dna2 = new Sequence("dna2", "GGGcccTTTaaaCCC");
dna2.createDatasetSequence();
pep1.createDatasetSequence();
pep2.createDatasetSequence();
-
- Set<AlignedCodonFrame> mappings = new HashSet<AlignedCodonFrame>();
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds1", 4, 6, 0f,
+ null));
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds2", 10, 12, 0f,
+ null));
+ dna2.addSequenceFeature(new SequenceFeature("CDS", "cds3", 1, 3, 0f,
+ null));
+ dna2.addSequenceFeature(new SequenceFeature("CDS", "cds4", 7, 9, 0f,
+ null));
+ dna2.addSequenceFeature(new SequenceFeature("CDS", "cds5", 13, 15, 0f,
+ null));
+
+ List<AlignedCodonFrame> mappings = new ArrayList<AlignedCodonFrame>();
MapList map = new MapList(new int[] { 4, 6, 10, 12 },
new int[] { 1, 2 }, 3, 1);
AlignedCodonFrame acf = new AlignedCodonFrame();
acf.addMap(dna2.getDatasetSequence(), pep2.getDatasetSequence(), map);
mappings.add(acf);
- AlignmentI exons = AlignmentUtils.makeExonAlignment(new SequenceI[] {
- dna1, dna2 }, mappings);
- assertEquals(2, exons.getSequences().size());
- assertEquals("GGGTTT", exons.getSequenceAt(0).getSequenceAsString());
- assertEquals("GGGTTTCCC", exons.getSequenceAt(1).getSequenceAsString());
+ AlignmentI cds = AlignmentUtils.makeCdsAlignment(new SequenceI[] {
+ dna1, dna2 }, mappings, '-');
+ assertEquals(2, cds.getSequences().size());
+ assertEquals("---GGG---TTT---", cds.getSequenceAt(0)
+ .getSequenceAsString());
+ assertEquals("GGG---TTT---CCC", cds.getSequenceAt(1)
+ .getSequenceAsString());
/*
* Verify updated mappings
SearchResults sr = MappingUtils.buildSearchResults(pep1, 1, mappings);
assertEquals(1, sr.getResults().size());
Match m = sr.getResults().get(0);
- assertEquals(exons.getSequenceAt(0).getDatasetSequence(),
+ assertSame(cds.getSequenceAt(0).getDatasetSequence(),
m.getSequence());
assertEquals(1, m.getStart());
assertEquals(3, m.getEnd());
// map F to TTT
sr = MappingUtils.buildSearchResults(pep1, 2, mappings);
m = sr.getResults().get(0);
- assertEquals(exons.getSequenceAt(0).getDatasetSequence(),
+ assertSame(cds.getSequenceAt(0).getDatasetSequence(),
m.getSequence());
assertEquals(4, m.getStart());
assertEquals(6, m.getEnd());
sr = MappingUtils.buildSearchResults(pep2, 1, mappings);
assertEquals(1, sr.getResults().size());
m = sr.getResults().get(0);
- assertEquals(exons.getSequenceAt(1).getDatasetSequence(),
+ assertSame(cds.getSequenceAt(1).getDatasetSequence(),
m.getSequence());
assertEquals(1, m.getStart());
assertEquals(3, m.getEnd());
// map F to TTT
sr = MappingUtils.buildSearchResults(pep2, 2, mappings);
m = sr.getResults().get(0);
- assertEquals(exons.getSequenceAt(1).getDatasetSequence(),
+ assertSame(cds.getSequenceAt(1).getDatasetSequence(),
m.getSequence());
assertEquals(4, m.getStart());
assertEquals(6, m.getEnd());
// map P to CCC
sr = MappingUtils.buildSearchResults(pep2, 3, mappings);
m = sr.getResults().get(0);
- assertEquals(exons.getSequenceAt(1).getDatasetSequence(),
+ assertSame(cds.getSequenceAt(1).getDatasetSequence(),
m.getSequence());
assertEquals(7, m.getStart());
assertEquals(9, m.getEnd());
}
/**
- * Test the method that makes an exon-only sequence from a DNA sequence and
- * its product mapping. Test includes the expected case that the DNA sequence
+ * Test the method that makes a cds-only sequence from a DNA sequence and its
+ * product mapping. Test includes the expected case that the DNA sequence
* already has a protein product (Uniprot translation) which in turn has an
* x-ref to the EMBLCDS record.
*/
@Test(groups = { "Functional" })
- public void testMakeExonSequences()
+ public void testMakeCdsSequences()
{
SequenceI dna1 = new Sequence("dna1", "aaaGGGcccTTTaaa");
SequenceI pep1 = new Sequence("pep1", "GF");
mappings.add(acf);
AlignedCodonFrame newMapping = new AlignedCodonFrame();
- List<SequenceI> exons = AlignmentUtils.makeExonSequences(dna1, acf,
- newMapping);
- assertEquals(1, exons.size());
- SequenceI exon = exons.get(0);
-
- assertEquals("GGGTTT", exon.getSequenceAsString());
- assertEquals("dna1|A12345", exon.getName());
- assertEquals(1, exon.getDBRefs().length);
- DBRefEntry cdsRef = exon.getDBRefs()[0];
+ List<int[]> ungappedColumns = new ArrayList<int[]>();
+ ungappedColumns.add(new int[] { 4, 6 });
+ ungappedColumns.add(new int[] { 10, 12 });
+ List<SequenceI> cdsSeqs = AlignmentUtils.makeCdsSequences(dna1, acf,
+ ungappedColumns,
+ newMapping, '-');
+ assertEquals(1, cdsSeqs.size());
+ SequenceI cdsSeq = cdsSeqs.get(0);
+
+ assertEquals("GGGTTT", cdsSeq.getSequenceAsString());
+ assertEquals("dna1|A12345", cdsSeq.getName());
+ assertEquals(1, cdsSeq.getDBRefs().length);
+ DBRefEntry cdsRef = cdsSeq.getDBRefs()[0];
assertEquals("EMBLCDS", cdsRef.getSource());
assertEquals("2", cdsRef.getVersion());
assertEquals("A12345", cdsRef.getAccessionId());
}
/**
- * Test the method that makes an exon-only alignment from a DNA sequence and
- * its product mappings, for the case where there are multiple exon mappings
- * to different protein products.
+ * Test the method that makes a cds-only alignment from a DNA sequence and its
+ * product mappings, for the case where there are multiple exon mappings to
+ * different protein products.
*/
@Test(groups = { "Functional" })
- public void testMakeExonAlignment_multipleProteins()
+ public void testMakeCdsAlignment_multipleProteins()
{
SequenceI dna1 = new Sequence("dna1", "aaaGGGcccTTTaaa");
SequenceI pep1 = new Sequence("pep1", "GF"); // GGGTTT
pep1.createDatasetSequence();
pep2.createDatasetSequence();
pep3.createDatasetSequence();
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds1", 4, 6, 0f,
+ null));
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds2", 10, 12, 0f,
+ null));
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds3", 1, 3, 0f,
+ null));
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds4", 7, 9, 0f,
+ null));
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds5", 1, 3, 0f,
+ null));
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds6", 10, 12, 0f,
+ null));
pep1.getDatasetSequence().addDBRef(
new DBRefEntry("EMBLCDS", "2", "A12345"));
pep2.getDatasetSequence().addDBRef(
new DBRefEntry("EMBLCDS", "4", "A12347"));
/*
- * Make the mappings from dna to protein. Using LinkedHashset is a
- * convenience so results are in the input order. There is no assertion that
- * the generated exon sequences are in any particular order.
+ * Make the mappings from dna to protein
*/
- Set<AlignedCodonFrame> mappings = new LinkedHashSet<AlignedCodonFrame>();
+ List<AlignedCodonFrame> mappings = new ArrayList<AlignedCodonFrame>();
// map ...GGG...TTT to GF
MapList map = new MapList(new int[] { 4, 6, 10, 12 },
new int[] { 1, 2 }, 3, 1);
* Create the Exon alignment; also replaces the dna-to-protein mappings with
* exon-to-protein and exon-to-dna mappings
*/
- AlignmentI exal = AlignmentUtils.makeExonAlignment(
- new SequenceI[] { dna1 }, mappings);
+ AlignmentI exal = AlignmentUtils.makeCdsAlignment(
+ new SequenceI[] { dna1 }, mappings, '-');
/*
- * Verify we have 3 exon sequences, mapped to pep1/2/3 respectively
+ * Verify we have 3 cds sequences, mapped to pep1/2/3 respectively
*/
- List<SequenceI> exons = exal.getSequences();
- assertEquals(3, exons.size());
-
- SequenceI exon = exons.get(0);
- assertEquals("GGGTTT", exon.getSequenceAsString());
- assertEquals("dna1|A12345", exon.getName());
- assertEquals(1, exon.getDBRefs().length);
- DBRefEntry cdsRef = exon.getDBRefs()[0];
+ List<SequenceI> cds = exal.getSequences();
+ assertEquals(3, cds.size());
+
+ SequenceI cdsSeq = cds.get(0);
+ assertEquals("---GGG---TTT", cdsSeq.getSequenceAsString());
+ assertEquals("dna1|A12345", cdsSeq.getName());
+ assertEquals(1, cdsSeq.getDBRefs().length);
+ DBRefEntry cdsRef = cdsSeq.getDBRefs()[0];
assertEquals("EMBLCDS", cdsRef.getSource());
assertEquals("2", cdsRef.getVersion());
assertEquals("A12345", cdsRef.getAccessionId());
- exon = exons.get(1);
- assertEquals("aaaccc", exon.getSequenceAsString());
- assertEquals("dna1|A12346", exon.getName());
- assertEquals(1, exon.getDBRefs().length);
- cdsRef = exon.getDBRefs()[0];
+ cdsSeq = cds.get(1);
+ assertEquals("aaa---ccc---", cdsSeq.getSequenceAsString());
+ assertEquals("dna1|A12346", cdsSeq.getName());
+ assertEquals(1, cdsSeq.getDBRefs().length);
+ cdsRef = cdsSeq.getDBRefs()[0];
assertEquals("EMBLCDS", cdsRef.getSource());
assertEquals("3", cdsRef.getVersion());
assertEquals("A12346", cdsRef.getAccessionId());
- exon = exons.get(2);
- assertEquals("aaaTTT", exon.getSequenceAsString());
- assertEquals("dna1|A12347", exon.getName());
- assertEquals(1, exon.getDBRefs().length);
- cdsRef = exon.getDBRefs()[0];
+ cdsSeq = cds.get(2);
+ assertEquals("aaa------TTT", cdsSeq.getSequenceAsString());
+ assertEquals("dna1|A12347", cdsSeq.getName());
+ assertEquals(1, cdsSeq.getDBRefs().length);
+ cdsRef = cdsSeq.getDBRefs()[0];
assertEquals("EMBLCDS", cdsRef.getSource());
assertEquals("4", cdsRef.getVersion());
assertEquals("A12347", cdsRef.getAccessionId());
/*
- * Verify there are mappings from each exon sequence to its protein product
+ * Verify there are mappings from each cds sequence to its protein product
* and also to its dna source
*/
Iterator<AlignedCodonFrame> newMappingsIterator = mappings.iterator();
// mappings for dna1 - exon1 - pep1
- AlignedCodonFrame exonMapping = newMappingsIterator.next();
- List<Mapping> dnaMappings = exonMapping.getMappingsForSequence(dna1);
+ AlignedCodonFrame cdsMapping = newMappingsIterator.next();
+ List<Mapping> dnaMappings = cdsMapping.getMappingsForSequence(dna1);
assertEquals(1, dnaMappings.size());
- assertSame(exons.get(0).getDatasetSequence(), dnaMappings.get(0)
+ assertSame(cds.get(0).getDatasetSequence(), dnaMappings.get(0)
.getTo());
assertEquals("G(1) in CDS should map to G(4) in DNA", 4, dnaMappings
.get(0).getMap().getToPosition(1));
- List<Mapping> peptideMappings = exonMapping
+ List<Mapping> peptideMappings = cdsMapping
.getMappingsForSequence(pep1);
assertEquals(1, peptideMappings.size());
assertSame(pep1.getDatasetSequence(), peptideMappings.get(0).getTo());
- // mappings for dna1 - exon2 - pep2
- exonMapping = newMappingsIterator.next();
- dnaMappings = exonMapping.getMappingsForSequence(dna1);
+ // mappings for dna1 - cds2 - pep2
+ cdsMapping = newMappingsIterator.next();
+ dnaMappings = cdsMapping.getMappingsForSequence(dna1);
assertEquals(1, dnaMappings.size());
- assertSame(exons.get(1).getDatasetSequence(), dnaMappings.get(0)
+ assertSame(cds.get(1).getDatasetSequence(), dnaMappings.get(0)
.getTo());
assertEquals("c(4) in CDS should map to c(7) in DNA", 7, dnaMappings
.get(0).getMap().getToPosition(4));
- peptideMappings = exonMapping.getMappingsForSequence(pep2);
+ peptideMappings = cdsMapping.getMappingsForSequence(pep2);
assertEquals(1, peptideMappings.size());
assertSame(pep2.getDatasetSequence(), peptideMappings.get(0).getTo());
- // mappings for dna1 - exon3 - pep3
- exonMapping = newMappingsIterator.next();
- dnaMappings = exonMapping.getMappingsForSequence(dna1);
+ // mappings for dna1 - cds3 - pep3
+ cdsMapping = newMappingsIterator.next();
+ dnaMappings = cdsMapping.getMappingsForSequence(dna1);
assertEquals(1, dnaMappings.size());
- assertSame(exons.get(2).getDatasetSequence(), dnaMappings.get(0)
+ assertSame(cds.get(2).getDatasetSequence(), dnaMappings.get(0)
.getTo());
assertEquals("T(4) in CDS should map to T(10) in DNA", 10, dnaMappings
.get(0).getMap().getToPosition(4));
- peptideMappings = exonMapping.getMappingsForSequence(pep3);
+ peptideMappings = cdsMapping.getMappingsForSequence(pep3);
assertEquals(1, peptideMappings.size());
assertSame(pep3.getDatasetSequence(), peptideMappings.get(0).getTo());
}
assertEquals(40, map.getFromLowest());
assertEquals(48, map.getFromHighest());
}
+
+ /**
+ * Test for the alignSequenceAs method where we have protein mapped to protein
+ */
+ @Test(groups = { "Functional" })
+ public void testAlignSequenceAs_mappedProteinProtein()
+ {
+
+ SequenceI alignMe = new Sequence("Match", "MGAASEV");
+ alignMe.createDatasetSequence();
+ SequenceI alignFrom = new Sequence("Query", "LQTGYMGAASEVMFSPTRR");
+ alignFrom.createDatasetSequence();
+
+ AlignedCodonFrame acf = new AlignedCodonFrame();
+ // this is like a domain or motif match of part of a peptide sequence
+ MapList map = new MapList(new int[] { 6, 12 }, new int[] { 1, 7 }, 1, 1);
+ acf.addMap(alignFrom.getDatasetSequence(),
+ alignMe.getDatasetSequence(), map);
+
+ AlignmentUtils.alignSequenceAs(alignMe, alignFrom, acf, "-", '-', true,
+ true);
+ assertEquals("-----MGAASEV-------", alignMe.getSequenceAsString());
+ }
+
+ /**
+ * Test for the alignSequenceAs method where there are trailing unmapped
+ * residues in the model sequence
+ */
+ @Test(groups = { "Functional" })
+ public void testAlignSequenceAs_withTrailingPeptide()
+ {
+ // map first 3 codons to KPF; G is a trailing unmapped residue
+ MapList map = new MapList(new int[] { 1, 9 }, new int[] { 1, 3 }, 3, 1);
+
+ checkAlignSequenceAs("AAACCCTTT", "K-PFG", true, true, map,
+ "AAA---CCCTTT---");
+ }
+
+ /**
+ * Tests for transferring features between mapped sequences
+ */
+ @Test(groups = { "Functional" })
+ public void testTransferFeatures()
+ {
+ SequenceI dna = new Sequence("dna/20-34", "acgTAGcaaGCCcgt");
+ SequenceI cds = new Sequence("cds/10-15", "TAGGCC");
+
+ // no overlap
+ dna.addSequenceFeature(new SequenceFeature("type1", "desc1", 1, 2, 1f,
+ null));
+ // partial overlap - to [1, 1]
+ dna.addSequenceFeature(new SequenceFeature("type2", "desc2", 3, 4, 2f,
+ null));
+ // exact overlap - to [1, 3]
+ dna.addSequenceFeature(new SequenceFeature("type3", "desc3", 4, 6, 3f,
+ null));
+ // spanning overlap - to [2, 5]
+ dna.addSequenceFeature(new SequenceFeature("type4", "desc4", 5, 11, 4f,
+ null));
+ // exactly overlaps whole mapped range [1, 6]
+ dna.addSequenceFeature(new SequenceFeature("type5", "desc5", 4, 12, 5f,
+ null));
+ // no overlap (internal)
+ dna.addSequenceFeature(new SequenceFeature("type6", "desc6", 7, 9, 6f,
+ null));
+ // no overlap (3' end)
+ dna.addSequenceFeature(new SequenceFeature("type7", "desc7", 13, 15,
+ 7f, null));
+ // overlap (3' end) - to [6, 6]
+ dna.addSequenceFeature(new SequenceFeature("type8", "desc8", 12, 12,
+ 8f, null));
+ // extended overlap - to [6, +]
+ dna.addSequenceFeature(new SequenceFeature("type9", "desc9", 12, 13,
+ 9f, null));
+
+ MapList map = new MapList(new int[] { 4, 6, 10, 12 },
+ new int[] { 1, 6 }, 1, 1);
+
+ /*
+ * transferFeatures() will build 'partial overlap' for regions
+ * that partially overlap 5' or 3' (start or end) of target sequence
+ */
+ AlignmentUtils.transferFeatures(dna, cds, map, null);
+ SequenceFeature[] sfs = cds.getSequenceFeatures();
+ assertEquals(6, sfs.length);
+
+ SequenceFeature sf = sfs[0];
+ assertEquals("type2", sf.getType());
+ assertEquals("desc2", sf.getDescription());
+ assertEquals(2f, sf.getScore());
+ assertEquals(1, sf.getBegin());
+ assertEquals(1, sf.getEnd());
+
+ sf = sfs[1];
+ assertEquals("type3", sf.getType());
+ assertEquals("desc3", sf.getDescription());
+ assertEquals(3f, sf.getScore());
+ assertEquals(1, sf.getBegin());
+ assertEquals(3, sf.getEnd());
+
+ sf = sfs[2];
+ assertEquals("type4", sf.getType());
+ assertEquals(2, sf.getBegin());
+ assertEquals(5, sf.getEnd());
+
+ sf = sfs[3];
+ assertEquals("type5", sf.getType());
+ assertEquals(1, sf.getBegin());
+ assertEquals(6, sf.getEnd());
+
+ sf = sfs[4];
+ assertEquals("type8", sf.getType());
+ assertEquals(6, sf.getBegin());
+ assertEquals(6, sf.getEnd());
+
+ sf = sfs[5];
+ assertEquals("type9", sf.getType());
+ assertEquals(6, sf.getBegin());
+ assertEquals(6, sf.getEnd());
+ }
+
+ /**
+ * Tests for transferring features between mapped sequences
+ */
+ @Test(groups = { "Functional" })
+ public void testTransferFeatures_withOmit()
+ {
+ SequenceI dna = new Sequence("dna/20-34", "acgTAGcaaGCCcgt");
+ SequenceI cds = new Sequence("cds/10-15", "TAGGCC");
+
+ MapList map = new MapList(new int[] { 4, 6, 10, 12 },
+ new int[] { 1, 6 }, 1, 1);
+
+ // [5, 11] maps to [2, 5]
+ dna.addSequenceFeature(new SequenceFeature("type4", "desc4", 5, 11, 4f,
+ null));
+ // [4, 12] maps to [1, 6]
+ dna.addSequenceFeature(new SequenceFeature("type5", "desc5", 4, 12, 5f,
+ null));
+ // [12, 12] maps to [6, 6]
+ dna.addSequenceFeature(new SequenceFeature("type8", "desc8", 12, 12,
+ 8f, null));
+
+ // desc4 and desc8 are the 'omit these' varargs
+ AlignmentUtils.transferFeatures(dna, cds, map, null, "type4", "type8");
+ SequenceFeature[] sfs = cds.getSequenceFeatures();
+ assertEquals(1, sfs.length);
+
+ SequenceFeature sf = sfs[0];
+ assertEquals("type5", sf.getType());
+ assertEquals(1, sf.getBegin());
+ assertEquals(6, sf.getEnd());
+ }
+
+ /**
+ * Tests for transferring features between mapped sequences
+ */
+ @Test(groups = { "Functional" })
+ public void testTransferFeatures_withSelect()
+ {
+ SequenceI dna = new Sequence("dna/20-34", "acgTAGcaaGCCcgt");
+ SequenceI cds = new Sequence("cds/10-15", "TAGGCC");
+
+ MapList map = new MapList(new int[] { 4, 6, 10, 12 },
+ new int[] { 1, 6 }, 1, 1);
+
+ // [5, 11] maps to [2, 5]
+ dna.addSequenceFeature(new SequenceFeature("type4", "desc4", 5, 11, 4f,
+ null));
+ // [4, 12] maps to [1, 6]
+ dna.addSequenceFeature(new SequenceFeature("type5", "desc5", 4, 12, 5f,
+ null));
+ // [12, 12] maps to [6, 6]
+ dna.addSequenceFeature(new SequenceFeature("type8", "desc8", 12, 12,
+ 8f, null));
+
+ // "type5" is the 'select this type' argument
+ AlignmentUtils.transferFeatures(dna, cds, map, "type5");
+ SequenceFeature[] sfs = cds.getSequenceFeatures();
+ assertEquals(1, sfs.length);
+
+ SequenceFeature sf = sfs[0];
+ assertEquals("type5", sf.getType());
+ assertEquals(1, sf.getBegin());
+ assertEquals(6, sf.getEnd());
+ }
+
+ /**
+ * Test the method that extracts the cds-only part of a dna alignment, for the
+ * case where the cds should be aligned to match its nucleotide sequence.
+ */
+ @Test(groups = { "Functional" })
+ public void testMakeCdsAlignment_alternativeTranscripts()
+ {
+ SequenceI dna1 = new Sequence("dna1", "aaaGGGCC-----CTTTaaaGGG");
+ // alternative transcript of same dna skips CCC codon
+ SequenceI dna2 = new Sequence("dna2", "aaaGGGCC-----cttTaaaGGG");
+ // dna3 has no mapping (protein product) so should be ignored here
+ SequenceI dna3 = new Sequence("dna3", "aaaGGGCCCCCGGGcttTaaaGGG");
+ SequenceI pep1 = new Sequence("pep1", "GPFG");
+ SequenceI pep2 = new Sequence("pep2", "GPG");
+ dna1.createDatasetSequence();
+ dna2.createDatasetSequence();
+ dna3.createDatasetSequence();
+ pep1.createDatasetSequence();
+ pep2.createDatasetSequence();
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds1", 4, 8, 0f,
+ null));
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds2", 9, 12, 0f,
+ null));
+ dna1.addSequenceFeature(new SequenceFeature("CDS", "cds3", 16, 18, 0f,
+ null));
+ dna2.addSequenceFeature(new SequenceFeature("CDS", "cds", 4, 8, 0f,
+ null));
+ dna2.addSequenceFeature(new SequenceFeature("CDS", "cds", 12, 12, 0f,
+ null));
+ dna2.addSequenceFeature(new SequenceFeature("CDS", "cds", 16, 18, 0f,
+ null));
+
+ List<AlignedCodonFrame> mappings = new ArrayList<AlignedCodonFrame>();
+ MapList map = new MapList(new int[] { 4, 12, 16, 18 },
+ new int[] { 1, 4 }, 3, 1);
+ AlignedCodonFrame acf = new AlignedCodonFrame();
+ acf.addMap(dna1.getDatasetSequence(), pep1.getDatasetSequence(), map);
+ mappings.add(acf);
+ map = new MapList(new int[] { 4, 8, 12, 12, 16, 18 },
+ new int[] { 1, 3 },
+ 3, 1);
+ acf = new AlignedCodonFrame();
+ acf.addMap(dna2.getDatasetSequence(), pep2.getDatasetSequence(), map);
+ mappings.add(acf);
+
+ AlignmentI cds = AlignmentUtils.makeCdsAlignment(new SequenceI[] {
+ dna1, dna2, dna3 }, mappings, '-');
+ assertEquals(2, cds.getSequences().size());
+ assertEquals("GGGCCCTTTGGG", cds.getSequenceAt(0).getSequenceAsString());
+ assertEquals("GGGCC---TGGG", cds.getSequenceAt(1).getSequenceAsString());
+
+ /*
+ * Verify updated mappings
+ */
+ assertEquals(2, mappings.size());
+
+ /*
+ * Mapping from pep1 to GGGTTT in first new CDS sequence
+ */
+ List<AlignedCodonFrame> pep1Mapping = MappingUtils
+ .findMappingsForSequence(pep1, mappings);
+ assertEquals(1, pep1Mapping.size());
+ /*
+ * maps GPFG to 1-3,4-6,7-9,10-12
+ */
+ SearchResults sr = MappingUtils.buildSearchResults(pep1, 1, mappings);
+ assertEquals(1, sr.getResults().size());
+ Match m = sr.getResults().get(0);
+ assertEquals(cds.getSequenceAt(0).getDatasetSequence(),
+ m.getSequence());
+ assertEquals(1, m.getStart());
+ assertEquals(3, m.getEnd());
+ sr = MappingUtils.buildSearchResults(pep1, 2, mappings);
+ m = sr.getResults().get(0);
+ assertEquals(4, m.getStart());
+ assertEquals(6, m.getEnd());
+ sr = MappingUtils.buildSearchResults(pep1, 3, mappings);
+ m = sr.getResults().get(0);
+ assertEquals(7, m.getStart());
+ assertEquals(9, m.getEnd());
+ sr = MappingUtils.buildSearchResults(pep1, 4, mappings);
+ m = sr.getResults().get(0);
+ assertEquals(10, m.getStart());
+ assertEquals(12, m.getEnd());
+
+ /*
+ * GPG in pep2 map to 1-3,4-6,7-9 in second CDS sequence
+ */
+ List<AlignedCodonFrame> pep2Mapping = MappingUtils
+ .findMappingsForSequence(pep2, mappings);
+ assertEquals(1, pep2Mapping.size());
+ sr = MappingUtils.buildSearchResults(pep2, 1, mappings);
+ assertEquals(1, sr.getResults().size());
+ m = sr.getResults().get(0);
+ assertEquals(cds.getSequenceAt(1).getDatasetSequence(),
+ m.getSequence());
+ assertEquals(1, m.getStart());
+ assertEquals(3, m.getEnd());
+ sr = MappingUtils.buildSearchResults(pep2, 2, mappings);
+ m = sr.getResults().get(0);
+ assertEquals(4, m.getStart());
+ assertEquals(6, m.getEnd());
+ sr = MappingUtils.buildSearchResults(pep2, 3, mappings);
+ m = sr.getResults().get(0);
+ assertEquals(7, m.getStart());
+ assertEquals(9, m.getEnd());
+ }
+
+ /**
+ * Tests for gapped column in sequences
+ */
+ @Test(groups = { "Functional" })
+ public void testIsGappedColumn()
+ {
+ SequenceI seq1 = new Sequence("Seq1", "a--c.tc-a-g");
+ SequenceI seq2 = new Sequence("Seq2", "aa---t--a-g");
+ SequenceI seq3 = new Sequence("Seq3", "ag-c t-g-");
+ List<SequenceI> seqs = Arrays
+ .asList(new SequenceI[] { seq1, seq2, seq3 });
+ // the column number is base 1
+ assertFalse(AlignmentUtils.isGappedColumn(seqs, 1));
+ assertFalse(AlignmentUtils.isGappedColumn(seqs, 2));
+ assertTrue(AlignmentUtils.isGappedColumn(seqs, 3));
+ assertFalse(AlignmentUtils.isGappedColumn(seqs, 4));
+ assertTrue(AlignmentUtils.isGappedColumn(seqs, 5));
+ assertFalse(AlignmentUtils.isGappedColumn(seqs, 6));
+ assertFalse(AlignmentUtils.isGappedColumn(seqs, 7));
+ assertFalse(AlignmentUtils.isGappedColumn(seqs, 8));
+ assertFalse(AlignmentUtils.isGappedColumn(seqs, 9));
+ assertTrue(AlignmentUtils.isGappedColumn(seqs, 10));
+ assertFalse(AlignmentUtils.isGappedColumn(seqs, 11));
+ // out of bounds:
+ assertTrue(AlignmentUtils.isGappedColumn(seqs, 0));
+ assertTrue(AlignmentUtils.isGappedColumn(seqs, 100));
+ assertTrue(AlignmentUtils.isGappedColumn(seqs, -100));
+ assertTrue(AlignmentUtils.isGappedColumn(null, 0));
+ }
+
+ @Test(groups = { "Functional" })
+ public void testFindCdsColumns()
+ {
+ // TODO target method belongs in a general-purpose alignment
+ // analysis method to find columns for feature
+
+ /*
+ * NB this method assumes CDS ranges are contiguous (no introns)
+ */
+ SequenceI gene = new Sequence("gene", "aaacccgggtttaaacccgggttt");
+ SequenceI seq1 = new Sequence("Seq1", "--ac-cgGG-GGaaACC--GGtt-");
+ SequenceI seq2 = new Sequence("Seq2", "AA--CCGG--g-AAA--cG-GTTt");
+ seq1.createDatasetSequence();
+ seq2.createDatasetSequence();
+ seq1.addSequenceFeature(new SequenceFeature("CDS", "cds", 5, 6, 0f,
+ null));
+ seq1.addSequenceFeature(new SequenceFeature("CDS", "cds", 7, 8, 0f,
+ null));
+ seq1.addSequenceFeature(new SequenceFeature("CDS", "cds", 11, 13, 0f,
+ null));
+ seq1.addSequenceFeature(new SequenceFeature("CDS", "cds", 14, 15, 0f,
+ null));
+ seq2.addSequenceFeature(new SequenceFeature("CDS", "cds", 1, 2, 0f,
+ null));
+ seq2.addSequenceFeature(new SequenceFeature("CDS", "cds", 3, 6, 0f,
+ null));
+ seq2.addSequenceFeature(new SequenceFeature("CDS", "cds", 8, 10, 0f,
+ null));
+ seq2.addSequenceFeature(new SequenceFeature("CDS", "cds", 12, 12, 0f,
+ null));
+ seq2.addSequenceFeature(new SequenceFeature("CDS", "cds", 13, 15, 0f,
+ null));
+
+ List<int[]> cdsColumns = AlignmentUtils.findCdsColumns(new SequenceI[] {
+ seq1, seq2 });
+ assertEquals(4, cdsColumns.size());
+ assertEquals("[1, 2]", Arrays.toString(cdsColumns.get(0)));
+ assertEquals("[5, 9]", Arrays.toString(cdsColumns.get(1)));
+ assertEquals("[11, 17]", Arrays.toString(cdsColumns.get(2)));
+ assertEquals("[19, 23]", Arrays.toString(cdsColumns.get(3)));
+ }
+
+ /**
+ * Test the method that realigns protein to match mapped codon alignment.
+ */
+ @Test(groups = { "Functional" })
+ public void testAlignProteinAsDna_incompleteStartCodon()
+ {
+ // seq1: incomplete start codon (not mapped), then [3, 11]
+ SequenceI dna1 = new Sequence("Seq1", "ccAAA-TTT-GGG-");
+ // seq2 codons are [4, 5], [8, 11]
+ SequenceI dna2 = new Sequence("Seq2", "ccaAA-ttT-GGG-");
+ // seq3 incomplete start codon at 'tt'
+ SequenceI dna3 = new Sequence("Seq3", "ccaaa-ttt-GGG-");
+ AlignmentI dna = new Alignment(new SequenceI[] { dna1, dna2, dna3 });
+ dna.setDataset(null);
+
+ // prot1 has 'X' for incomplete start codon (not mapped)
+ SequenceI prot1 = new Sequence("Seq1", "XKFG"); // X for incomplete start
+ SequenceI prot2 = new Sequence("Seq2", "NG");
+ SequenceI prot3 = new Sequence("Seq3", "XG"); // X for incomplete start
+ AlignmentI protein = new Alignment(new SequenceI[] { prot1, prot2,
+ prot3 });
+ protein.setDataset(null);
+
+ // map dna1 [3, 11] to prot1 [2, 4] KFG
+ MapList map = new MapList(new int[] { 3, 11 }, new int[] { 2, 4 }, 3, 1);
+ AlignedCodonFrame acf = new AlignedCodonFrame();
+ acf.addMap(dna1.getDatasetSequence(), prot1.getDatasetSequence(), map);
+
+ // map dna2 [4, 5] [8, 11] to prot2 [1, 2] NG
+ map = new MapList(new int[] { 4, 5, 8, 11 }, new int[] { 1, 2 }, 3, 1);
+ acf.addMap(dna2.getDatasetSequence(), prot2.getDatasetSequence(), map);
+
+ // map dna3 [9, 11] to prot3 [2, 2] G
+ map = new MapList(new int[] { 9, 11 }, new int[] { 2, 2 }, 3, 1);
+ acf.addMap(dna3.getDatasetSequence(), prot3.getDatasetSequence(), map);
+
+ ArrayList<AlignedCodonFrame> acfs = new ArrayList<AlignedCodonFrame>();
+ acfs.add(acf);
+ protein.setCodonFrames(acfs);
+
+ /*
+ * verify X is included in the aligned proteins, and placed just
+ * before the first mapped residue
+ * CCT is between CCC and TTT
+ */
+ AlignmentUtils.alignProteinAsDna(protein, dna);
+ assertEquals("XK-FG", prot1.getSequenceAsString());
+ assertEquals("--N-G", prot2.getSequenceAsString());
+ assertEquals("---XG", prot3.getSequenceAsString());
+ }
}
git://source.jalview.org / jalview.git / blobdiff