X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fanalysis%2FAlignmentUtilsTests.java;h=4aed7e71d2a62018ce35196175f4255612204d00;hb=37de9310bec3501cbc6381e0c3dcb282fcaad812;hp=5039deb58517843c09ebfefc7bb249ef5510ca0c;hpb=135d3c8e51d19e221e68134a3cd7290fa9c783a8;p=jalview.git diff --git a/test/jalview/analysis/AlignmentUtilsTests.java b/test/jalview/analysis/AlignmentUtilsTests.java index 5039deb..4aed7e7 100644 --- a/test/jalview/analysis/AlignmentUtilsTests.java +++ b/test/jalview/analysis/AlignmentUtilsTests.java @@ -1,30 +1,2515 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors + * + * This file is part of Jalview. + * + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ package jalview.analysis; -import org.junit.Test; +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 jalview.analysis.AlignmentUtils.DnaVariant; +import jalview.datamodel.AlignedCodonFrame; import jalview.datamodel.Alignment; +import jalview.datamodel.AlignmentAnnotation; import jalview.datamodel.AlignmentI; +import jalview.datamodel.Annotation; +import jalview.datamodel.DBRefEntry; +import jalview.datamodel.Mapping; +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 jalview.util.MapList; +import jalview.util.MappingUtils; -public class AlignmentUtilsTests +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; + +import org.testng.annotations.Test; + +public class AlignmentUtilsTests { - public static Sequence ts=new Sequence("short","ASDASDASDASDASDASDASDASDASDASDASDASDASD"); - @Test - public void testExpandFlanks() + public static Sequence ts = new Sequence("short", + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm"); + + @Test(groups = { "Functional" }) + public void testExpandContext() { AlignmentI al = new Alignment(new Sequence[] {}); - for (int i=4;i<14;i+=3) + for (int i = 4; i < 14; i += 2) { - SequenceI s1=ts.deriveSequence().getSubSequence(i, i+7); + SequenceI s1 = ts.deriveSequence().getSubSequence(i, i + 7); al.addSequence(s1); } - System.out.println(new AppletFormatAdapter().formatSequences("Clustal", al, true)); - for (int flnk=-1;flnk<25; flnk++) + System.out.println(new AppletFormatAdapter().formatSequences("Clustal", + al, true)); + for (int flnk = -1; flnk < 25; flnk++) { - System.out.println("\nFlank size: "+flnk); - System.out.println(new AppletFormatAdapter().formatSequences("Clustal", AlignmentUtils.expandContext(al, flnk), true)); - } + AlignmentI exp = AlignmentUtils.expandContext(al, flnk); + System.out.println("\nFlank size: " + flnk); + System.out.println(new AppletFormatAdapter().formatSequences( + "Clustal", exp, true)); + if (flnk == -1) + { + /* + * Full expansion to complete sequences + */ + for (SequenceI sq : exp.getSequences()) + { + String ung = sq.getSequenceAsString().replaceAll("-+", ""); + final String errorMsg = "Flanking sequence not the same as original dataset sequence.\n" + + ung + + "\n" + + sq.getDatasetSequence().getSequenceAsString(); + assertTrue(errorMsg, ung.equalsIgnoreCase(sq.getDatasetSequence() + .getSequenceAsString())); + } + } + else if (flnk == 24) + { + /* + * Last sequence is fully expanded, others have leading gaps to match + */ + assertTrue(exp.getSequenceAt(4).getSequenceAsString() + .startsWith("abc")); + assertTrue(exp.getSequenceAt(3).getSequenceAsString() + .startsWith("--abc")); + assertTrue(exp.getSequenceAt(2).getSequenceAsString() + .startsWith("----abc")); + assertTrue(exp.getSequenceAt(1).getSequenceAsString() + .startsWith("------abc")); + assertTrue(exp.getSequenceAt(0).getSequenceAsString() + .startsWith("--------abc")); + } + } + } + + /** + * Test that annotations are correctly adjusted by expandContext + */ + @Test(groups = { "Functional" }) + public void testExpandContext_annotation() + { + AlignmentI al = new Alignment(new Sequence[] {}); + SequenceI ds = new Sequence("Seq1", "ABCDEFGHI"); + // subsequence DEF: + SequenceI seq1 = ds.deriveSequence().getSubSequence(3, 6); + al.addSequence(seq1); + + /* + * Annotate DEF with 4/5/6 respectively + */ + Annotation[] anns = new Annotation[] { new Annotation(4), + new Annotation(5), new Annotation(6) }; + AlignmentAnnotation ann = new AlignmentAnnotation("SS", + "secondary structure", anns); + seq1.addAlignmentAnnotation(ann); + + /* + * The annotations array should match aligned positions + */ + assertEquals(3, ann.annotations.length); + assertEquals(4, ann.annotations[0].value, 0.001); + assertEquals(5, ann.annotations[1].value, 0.001); + assertEquals(6, ann.annotations[2].value, 0.001); + + /* + * Check annotation to sequence position mappings before expanding the + * sequence; these are set up in Sequence.addAlignmentAnnotation -> + * Annotation.setSequenceRef -> createSequenceMappings + */ + assertNull(ann.getAnnotationForPosition(1)); + assertNull(ann.getAnnotationForPosition(2)); + assertNull(ann.getAnnotationForPosition(3)); + assertEquals(4, ann.getAnnotationForPosition(4).value, 0.001); + assertEquals(5, ann.getAnnotationForPosition(5).value, 0.001); + assertEquals(6, ann.getAnnotationForPosition(6).value, 0.001); + assertNull(ann.getAnnotationForPosition(7)); + assertNull(ann.getAnnotationForPosition(8)); + assertNull(ann.getAnnotationForPosition(9)); + + /* + * Expand the subsequence to the full sequence abcDEFghi + */ + AlignmentI expanded = AlignmentUtils.expandContext(al, -1); + assertEquals("abcDEFghi", expanded.getSequenceAt(0) + .getSequenceAsString()); + + /* + * Confirm the alignment and sequence have the same SS annotation, + * referencing the expanded sequence + */ + ann = expanded.getSequenceAt(0).getAnnotation()[0]; + assertSame(ann, expanded.getAlignmentAnnotation()[0]); + assertSame(expanded.getSequenceAt(0), ann.sequenceRef); + + /* + * The annotations array should have null values except for annotated + * positions + */ + assertNull(ann.annotations[0]); + assertNull(ann.annotations[1]); + assertNull(ann.annotations[2]); + assertEquals(4, ann.annotations[3].value, 0.001); + assertEquals(5, ann.annotations[4].value, 0.001); + assertEquals(6, ann.annotations[5].value, 0.001); + assertNull(ann.annotations[6]); + assertNull(ann.annotations[7]); + assertNull(ann.annotations[8]); + + /* + * sequence position mappings should be unchanged + */ + assertNull(ann.getAnnotationForPosition(1)); + assertNull(ann.getAnnotationForPosition(2)); + assertNull(ann.getAnnotationForPosition(3)); + assertEquals(4, ann.getAnnotationForPosition(4).value, 0.001); + assertEquals(5, ann.getAnnotationForPosition(5).value, 0.001); + assertEquals(6, ann.getAnnotationForPosition(6).value, 0.001); + assertNull(ann.getAnnotationForPosition(7)); + assertNull(ann.getAnnotationForPosition(8)); + assertNull(ann.getAnnotationForPosition(9)); + } + + /** + * Test method that returns a map of lists of sequences by sequence name. + * + * @throws IOException + */ + @Test(groups = { "Functional" }) + public void testGetSequencesByName() throws IOException + { + final String data = ">Seq1Name\nKQYL\n" + ">Seq2Name\nRFPW\n" + + ">Seq1Name\nABCD\n"; + AlignmentI al = loadAlignment(data, "FASTA"); + Map> map = AlignmentUtils + .getSequencesByName(al); + assertEquals(2, map.keySet().size()); + assertEquals(2, map.get("Seq1Name").size()); + assertEquals("KQYL", map.get("Seq1Name").get(0).getSequenceAsString()); + assertEquals("ABCD", map.get("Seq1Name").get(1).getSequenceAsString()); + assertEquals(1, map.get("Seq2Name").size()); + assertEquals("RFPW", map.get("Seq2Name").get(0).getSequenceAsString()); + } + + /** + * Helper method to load an alignment and ensure dataset sequences are set up. + * + * @param data + * @param format + * TODO + * @return + * @throws IOException + */ + protected AlignmentI loadAlignment(final String data, String format) + throws IOException + { + AlignmentI a = new FormatAdapter().readFile(data, + AppletFormatAdapter.PASTE, format); + a.setDataset(null); + return a; + } + + /** + * Test mapping of protein to cDNA, for the case where we have no sequence + * cross-references, so mappings are made first-served 1-1 where sequences + * translate. + * + * @throws IOException + */ + @Test(groups = { "Functional" }) + public void testMapProteinAlignmentToCdna_noXrefs() throws IOException + { + List protseqs = new ArrayList(); + protseqs.add(new Sequence("UNIPROT|V12345", "EIQ")); + protseqs.add(new Sequence("UNIPROT|V12346", "EIQ")); + protseqs.add(new Sequence("UNIPROT|V12347", "SAR")); + AlignmentI protein = new Alignment(protseqs.toArray(new SequenceI[3])); + protein.setDataset(null); + + List dnaseqs = new ArrayList(); + dnaseqs.add(new Sequence("EMBL|A11111", "TCAGCACGC")); // = SAR + dnaseqs.add(new Sequence("EMBL|A22222", "GAGATACAA")); // = EIQ + dnaseqs.add(new Sequence("EMBL|A33333", "GAAATCCAG")); // = EIQ + dnaseqs.add(new Sequence("EMBL|A44444", "GAAATTCAG")); // = EIQ + AlignmentI cdna = new Alignment(dnaseqs.toArray(new SequenceI[4])); + cdna.setDataset(null); + + assertTrue(AlignmentUtils.mapProteinAlignmentToCdna(protein, cdna)); + + // 3 mappings made, each from 1 to 1 sequence + assertEquals(3, protein.getCodonFrames().size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(0)).size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(1)).size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(2)).size()); + + // V12345 mapped to A22222 + AlignedCodonFrame acf = protein.getCodonFrame(protein.getSequenceAt(0)) + .get(0); + assertEquals(1, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(1).getDatasetSequence(), + acf.getdnaSeqs()[0]); + Mapping[] protMappings = acf.getProtMappings(); + assertEquals(1, protMappings.length); + MapList mapList = protMappings[0].getMap(); + assertEquals(3, mapList.getFromRatio()); + assertEquals(1, mapList.getToRatio()); + assertTrue(Arrays.equals(new int[] { 1, 9 }, mapList.getFromRanges() + .get(0))); + assertEquals(1, mapList.getFromRanges().size()); + assertTrue(Arrays.equals(new int[] { 1, 3 }, + mapList.getToRanges().get(0))); + assertEquals(1, mapList.getToRanges().size()); + + // V12346 mapped to A33333 + acf = protein.getCodonFrame(protein.getSequenceAt(1)).get(0); + assertEquals(1, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(2).getDatasetSequence(), + acf.getdnaSeqs()[0]); + + // V12347 mapped to A11111 + acf = protein.getCodonFrame(protein.getSequenceAt(2)).get(0); + assertEquals(1, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(0).getDatasetSequence(), + acf.getdnaSeqs()[0]); + + // no mapping involving the 'extra' A44444 + assertTrue(protein.getCodonFrame(cdna.getSequenceAt(3)).isEmpty()); + } + + /** + * Test for the alignSequenceAs method that takes two sequences and a mapping. + */ + @Test(groups = { "Functional" }) + public void testAlignSequenceAs_withMapping_noIntrons() + { + MapList map = new MapList(new int[] { 1, 6 }, new int[] { 1, 2 }, 3, 1); + + /* + * No existing gaps in dna: + */ + checkAlignSequenceAs("GGGAAA", "-A-L-", false, false, map, + "---GGG---AAA"); + + /* + * Now introduce gaps in dna but ignore them when realigning. + */ + checkAlignSequenceAs("-G-G-G-A-A-A-", "-A-L-", false, false, map, + "---GGG---AAA"); + + /* + * Now include gaps in dna when realigning. First retaining 'mapped' gaps + * only, i.e. those within the exon region. + */ + checkAlignSequenceAs("-G-G--G-A--A-A-", "-A-L-", true, false, map, + "---G-G--G---A--A-A"); + + /* + * Include all gaps in dna when realigning (within and without the exon + * 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---"); + + /* + * Include only unmapped gaps in dna when realigning (outside the exon + * region). The leading gap, and the gaps between codons, are subsumed by + * the protein alignment gap. + */ + checkAlignSequenceAs("-G-GG--AA-A-", "-A-L-", false, true, map, + "---GGG---AAA---"); + } + + /** + * Test for the alignSequenceAs method that takes two sequences and a mapping. + */ + @Test(groups = { "Functional" }) + public void testAlignSequenceAs_withMapping_withIntrons() + { + /* + * Exons at codon 2 (AAA) and 4 (TTT) + */ + MapList map = new MapList(new int[] { 4, 6, 10, 12 }, + new int[] { 1, 2 }, 3, 1); + + /* + * Simple case: no gaps in dna + */ + checkAlignSequenceAs("GGGAAACCCTTTGGG", "--A-L-", false, false, map, + "GGG---AAACCCTTTGGG"); + + /* + * Add gaps to dna - but ignore when realigning. + */ + checkAlignSequenceAs("-G-G-G--A--A---AC-CC-T-TT-GG-G-", "--A-L-", + false, false, map, "GGG---AAACCCTTTGGG"); + + /* + * Add gaps to dna - include within exons only when realigning. + */ + checkAlignSequenceAs("-G-G-G--A--A---A-C-CC-T-TT-GG-G-", "--A-L-", + true, false, map, "GGG---A--A---ACCCT-TTGGG"); + + /* + * Include gaps outside exons only when realigning. + */ + checkAlignSequenceAs("-G-G-G--A--A---A-C-CC-T-TT-GG-G-", "--A-L-", + false, true, map, "-G-G-GAAAC-CCTTT-GG-G-"); + + /* + * Include gaps following first intron if we are 'preserving mapped gaps' + */ + checkAlignSequenceAs("-G-G-G--A--A---A-C-CC-T-TT-GG-G-", "--A-L-", + true, true, map, "-G-G-G--A--A---A-C-CC-T-TT-GG-G-"); + + /* + * Include all gaps in dna when realigning. + */ + checkAlignSequenceAs("-G-G-G--A--A---A-C-CC-T-TT-GG-G-", "--A-L-", + true, true, map, "-G-G-G--A--A---A-C-CC-T-TT-GG-G-"); + } + + /** + * Test for the case where not all of the protein sequence is mapped to cDNA. + */ + @Test(groups = { "Functional" }) + public void testAlignSequenceAs_withMapping_withUnmappedProtein() + { + /* + * Exons at codon 2 (AAA) and 4 (TTT) mapped to A and P + */ + final MapList map = new MapList(new int[] { 4, 6, 10, 12 }, new int[] { + 1, 1, 3, 3 }, 3, 1); + + /* + * -L- 'aligns' ccc------ + */ + checkAlignSequenceAs("gggAAAcccTTTggg", "-A-L-P-", false, false, map, + "gggAAAccc------TTTggg"); } + + /** + * Helper method that performs and verifies the method under test. + * + * @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 alignee, + final String alignModel, final boolean preserveMappedGaps, + final boolean preserveUnmappedGaps, MapList map, + final String expected) + { + SequenceI alignMe = new Sequence("Seq1", alignee); + alignMe.createDatasetSequence(); + SequenceI alignFrom = new Sequence("Seq2", alignModel); + alignFrom.createDatasetSequence(); + AlignedCodonFrame acf = new AlignedCodonFrame(); + acf.addMap(alignMe.getDatasetSequence(), + alignFrom.getDatasetSequence(), map); + + AlignmentUtils.alignSequenceAs(alignMe, alignFrom, acf, "---", '-', + preserveMappedGaps, preserveUnmappedGaps); + assertEquals(expected, alignMe.getSequenceAsString()); + } + + /** + * Test for the alignSequenceAs method where we preserve gaps in introns only. + */ + @Test(groups = { "Functional" }) + public void testAlignSequenceAs_keepIntronGapsOnly() + { + + /* + * Intron GGGAAA followed by exon CCCTTT + */ + MapList map = new MapList(new int[] { 7, 12 }, new int[] { 1, 2 }, 3, 1); + + checkAlignSequenceAs("GG-G-AA-A-C-CC-T-TT", "AL", false, true, map, + "GG-G-AA-ACCCTTT"); + } + + /** + * Test the method that realigns protein to match mapped codon alignment. + */ + @Test(groups = { "Functional" }) + public void testAlignProteinAsDna() + { + // seq1 codons are [1,2,3] [4,5,6] [7,8,9] [10,11,12] + SequenceI dna1 = new Sequence("Seq1", "TGCCATTACCAG-"); + // seq2 codons are [1,3,4] [5,6,7] [8,9,10] [11,12,13] + SequenceI dna2 = new Sequence("Seq2", "T-GCCATTACCAG"); + // seq3 codons are [1,2,3] [4,5,7] [8,9,10] [11,12,13] + SequenceI dna3 = new Sequence("Seq3", "TGCCA-TTACCAG"); + AlignmentI dna = new Alignment(new SequenceI[] { dna1, dna2, dna3 }); + dna.setDataset(null); + + // protein alignment will be realigned like dna + SequenceI prot1 = new Sequence("Seq1", "CHYQ"); + SequenceI prot2 = new Sequence("Seq2", "CHYQ"); + SequenceI prot3 = new Sequence("Seq3", "CHYQ"); + SequenceI prot4 = new Sequence("Seq4", "R-QSV"); // unmapped, unchanged + AlignmentI protein = new Alignment(new SequenceI[] { prot1, prot2, + prot3, prot4 }); + protein.setDataset(null); + + MapList map = new MapList(new int[] { 1, 12 }, new int[] { 1, 4 }, 3, 1); + AlignedCodonFrame acf = new AlignedCodonFrame(); + acf.addMap(dna1.getDatasetSequence(), prot1.getDatasetSequence(), map); + acf.addMap(dna2.getDatasetSequence(), prot2.getDatasetSequence(), map); + acf.addMap(dna3.getDatasetSequence(), prot3.getDatasetSequence(), map); + ArrayList acfs = new ArrayList(); + 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] + * [8,9,10] [10,11,12] [11,12,13] + */ + AlignmentUtils.alignProteinAsDna(protein, dna); + assertEquals("C-H--Y-Q-", prot1.getSequenceAsString()); + assertEquals("-C--H-Y-Q", prot2.getSequenceAsString()); + assertEquals("C--H--Y-Q", prot3.getSequenceAsString()); + assertEquals("R-QSV", prot4.getSequenceAsString()); + } + + /** + * Test the method that tests whether a CDNA sequence translates to a protein + * sequence + */ + @Test(groups = { "Functional" }) + public void testTranslatesAs() + { + // null arguments check + assertFalse(AlignmentUtils.translatesAs(null, 0, null)); + assertFalse(AlignmentUtils.translatesAs(new char[] { 't' }, 0, null)); + assertFalse(AlignmentUtils.translatesAs(null, 0, new char[] { 'a' })); + + // straight translation + assertTrue(AlignmentUtils.translatesAs("tttcccaaaggg".toCharArray(), 0, + "FPKG".toCharArray())); + // with extra start codon (not in protein) + assertTrue(AlignmentUtils.translatesAs("atgtttcccaaaggg".toCharArray(), + 3, "FPKG".toCharArray())); + // with stop codon1 (not in protein) + assertTrue(AlignmentUtils.translatesAs("tttcccaaagggtaa".toCharArray(), + 0, "FPKG".toCharArray())); + // with stop codon1 (in protein as *) + assertTrue(AlignmentUtils.translatesAs("tttcccaaagggtaa".toCharArray(), + 0, "FPKG*".toCharArray())); + // with stop codon2 (not in protein) + assertTrue(AlignmentUtils.translatesAs("tttcccaaagggtag".toCharArray(), + 0, "FPKG".toCharArray())); + // with stop codon3 (not in protein) + assertTrue(AlignmentUtils.translatesAs("tttcccaaagggtga".toCharArray(), + 0, "FPKG".toCharArray())); + // with start and stop codon1 + assertTrue(AlignmentUtils.translatesAs( + "atgtttcccaaagggtaa".toCharArray(), 3, "FPKG".toCharArray())); + // with start and stop codon1 (in protein as *) + assertTrue(AlignmentUtils.translatesAs( + "atgtttcccaaagggtaa".toCharArray(), 3, "FPKG*".toCharArray())); + // with start and stop codon2 + assertTrue(AlignmentUtils.translatesAs( + "atgtttcccaaagggtag".toCharArray(), 3, "FPKG".toCharArray())); + // with start and stop codon3 + assertTrue(AlignmentUtils.translatesAs( + "atgtttcccaaagggtga".toCharArray(), 3, "FPKG".toCharArray())); + + // with embedded stop codons + assertTrue(AlignmentUtils.translatesAs( + "atgtttTAGcccaaaTAAgggtga".toCharArray(), 3, + "F*PK*G".toCharArray())); + + // wrong protein + assertFalse(AlignmentUtils.translatesAs("tttcccaaaggg".toCharArray(), + 0, "FPMG".toCharArray())); + + // truncated dna + assertFalse(AlignmentUtils.translatesAs("tttcccaaagg".toCharArray(), 0, + "FPKG".toCharArray())); + + // truncated protein + assertFalse(AlignmentUtils.translatesAs("tttcccaaaggg".toCharArray(), + 0, "FPK".toCharArray())); + + // overlong dna (doesn't end in stop codon) + assertFalse(AlignmentUtils.translatesAs( + "tttcccaaagggttt".toCharArray(), 0, "FPKG".toCharArray())); + + // dna + stop codon + more + assertFalse(AlignmentUtils.translatesAs( + "tttcccaaagggttaga".toCharArray(), 0, "FPKG".toCharArray())); + + // overlong protein + assertFalse(AlignmentUtils.translatesAs("tttcccaaaggg".toCharArray(), + 0, "FPKGQ".toCharArray())); + } + + /** + * Test mapping of protein to cDNA, for cases where the cDNA has start and/or + * stop codons in addition to the protein coding sequence. + * + * @throws IOException + */ + @Test(groups = { "Functional" }) + public void testMapProteinAlignmentToCdna_withStartAndStopCodons() + throws IOException + { + List protseqs = new ArrayList(); + protseqs.add(new Sequence("UNIPROT|V12345", "EIQ")); + protseqs.add(new Sequence("UNIPROT|V12346", "EIQ")); + protseqs.add(new Sequence("UNIPROT|V12347", "SAR")); + AlignmentI protein = new Alignment(protseqs.toArray(new SequenceI[3])); + protein.setDataset(null); + + List dnaseqs = new ArrayList(); + // start + SAR: + dnaseqs.add(new Sequence("EMBL|A11111", "ATGTCAGCACGC")); + // = EIQ + stop + dnaseqs.add(new Sequence("EMBL|A22222", "GAGATACAATAA")); + // = start +EIQ + stop + dnaseqs.add(new Sequence("EMBL|A33333", "ATGGAAATCCAGTAG")); + dnaseqs.add(new Sequence("EMBL|A44444", "GAAATTCAG")); + AlignmentI cdna = new Alignment(dnaseqs.toArray(new SequenceI[4])); + cdna.setDataset(null); + + assertTrue(AlignmentUtils.mapProteinAlignmentToCdna(protein, cdna)); + + // 3 mappings made, each from 1 to 1 sequence + assertEquals(3, protein.getCodonFrames().size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(0)).size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(1)).size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(2)).size()); + + // V12345 mapped from A22222 + AlignedCodonFrame acf = protein.getCodonFrame(protein.getSequenceAt(0)) + .get(0); + assertEquals(1, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(1).getDatasetSequence(), + acf.getdnaSeqs()[0]); + Mapping[] protMappings = acf.getProtMappings(); + assertEquals(1, protMappings.length); + MapList mapList = protMappings[0].getMap(); + assertEquals(3, mapList.getFromRatio()); + assertEquals(1, mapList.getToRatio()); + assertTrue(Arrays.equals(new int[] { 1, 9 }, mapList.getFromRanges() + .get(0))); + assertEquals(1, mapList.getFromRanges().size()); + assertTrue(Arrays.equals(new int[] { 1, 3 }, + mapList.getToRanges().get(0))); + assertEquals(1, mapList.getToRanges().size()); + + // V12346 mapped from A33333 starting position 4 + acf = protein.getCodonFrame(protein.getSequenceAt(1)).get(0); + assertEquals(1, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(2).getDatasetSequence(), + acf.getdnaSeqs()[0]); + protMappings = acf.getProtMappings(); + assertEquals(1, protMappings.length); + mapList = protMappings[0].getMap(); + assertEquals(3, mapList.getFromRatio()); + assertEquals(1, mapList.getToRatio()); + assertTrue(Arrays.equals(new int[] { 4, 12 }, mapList.getFromRanges() + .get(0))); + assertEquals(1, mapList.getFromRanges().size()); + assertTrue(Arrays.equals(new int[] { 1, 3 }, + mapList.getToRanges().get(0))); + assertEquals(1, mapList.getToRanges().size()); + + // V12347 mapped to A11111 starting position 4 + acf = protein.getCodonFrame(protein.getSequenceAt(2)).get(0); + assertEquals(1, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(0).getDatasetSequence(), + acf.getdnaSeqs()[0]); + protMappings = acf.getProtMappings(); + assertEquals(1, protMappings.length); + mapList = protMappings[0].getMap(); + assertEquals(3, mapList.getFromRatio()); + assertEquals(1, mapList.getToRatio()); + assertTrue(Arrays.equals(new int[] { 4, 12 }, mapList.getFromRanges() + .get(0))); + assertEquals(1, mapList.getFromRanges().size()); + assertTrue(Arrays.equals(new int[] { 1, 3 }, + mapList.getToRanges().get(0))); + assertEquals(1, mapList.getToRanges().size()); + + // no mapping involving the 'extra' A44444 + assertTrue(protein.getCodonFrame(cdna.getSequenceAt(3)).isEmpty()); + } + + /** + * Test mapping of protein to cDNA, for the case where we have some sequence + * cross-references. Verify that 1-to-many mappings are made where + * cross-references exist and sequences are mappable. + * + * @throws IOException + */ + @Test(groups = { "Functional" }) + public void testMapProteinAlignmentToCdna_withXrefs() throws IOException + { + List protseqs = new ArrayList(); + protseqs.add(new Sequence("UNIPROT|V12345", "EIQ")); + protseqs.add(new Sequence("UNIPROT|V12346", "EIQ")); + protseqs.add(new Sequence("UNIPROT|V12347", "SAR")); + AlignmentI protein = new Alignment(protseqs.toArray(new SequenceI[3])); + protein.setDataset(null); + + List dnaseqs = new ArrayList(); + dnaseqs.add(new Sequence("EMBL|A11111", "TCAGCACGC")); // = SAR + dnaseqs.add(new Sequence("EMBL|A22222", "ATGGAGATACAA")); // = start + EIQ + dnaseqs.add(new Sequence("EMBL|A33333", "GAAATCCAG")); // = EIQ + dnaseqs.add(new Sequence("EMBL|A44444", "GAAATTCAG")); // = EIQ + dnaseqs.add(new Sequence("EMBL|A55555", "GAGATTCAG")); // = EIQ + AlignmentI cdna = new Alignment(dnaseqs.toArray(new SequenceI[5])); + cdna.setDataset(null); + + // Xref A22222 to V12345 (should get mapped) + dnaseqs.get(1).addDBRef(new DBRefEntry("UNIPROT", "1", "V12345")); + // Xref V12345 to A44444 (should get mapped) + protseqs.get(0).addDBRef(new DBRefEntry("EMBL", "1", "A44444")); + // Xref A33333 to V12347 (sequence mismatch - should not get mapped) + dnaseqs.get(2).addDBRef(new DBRefEntry("UNIPROT", "1", "V12347")); + // as V12345 is mapped to A22222 and A44444, this leaves V12346 unmapped. + // it should get paired up with the unmapped A33333 + // A11111 should be mapped to V12347 + // A55555 is spare and has no xref so is not mapped + + assertTrue(AlignmentUtils.mapProteinAlignmentToCdna(protein, cdna)); + + // 4 protein mappings made for 3 proteins, 2 to V12345, 1 each to V12346/7 + assertEquals(3, protein.getCodonFrames().size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(0)).size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(1)).size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(2)).size()); + + // one mapping for each of the first 4 cDNA sequences + assertEquals(1, protein.getCodonFrame(cdna.getSequenceAt(0)).size()); + assertEquals(1, protein.getCodonFrame(cdna.getSequenceAt(1)).size()); + assertEquals(1, protein.getCodonFrame(cdna.getSequenceAt(2)).size()); + assertEquals(1, protein.getCodonFrame(cdna.getSequenceAt(3)).size()); + + // V12345 mapped to A22222 and A44444 + AlignedCodonFrame acf = protein.getCodonFrame(protein.getSequenceAt(0)) + .get(0); + assertEquals(2, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(1).getDatasetSequence(), + acf.getdnaSeqs()[0]); + assertEquals(cdna.getSequenceAt(3).getDatasetSequence(), + acf.getdnaSeqs()[1]); + + // V12346 mapped to A33333 + acf = protein.getCodonFrame(protein.getSequenceAt(1)).get(0); + assertEquals(1, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(2).getDatasetSequence(), + acf.getdnaSeqs()[0]); + + // V12347 mapped to A11111 + acf = protein.getCodonFrame(protein.getSequenceAt(2)).get(0); + assertEquals(1, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(0).getDatasetSequence(), + acf.getdnaSeqs()[0]); + + // no mapping involving the 'extra' A55555 + assertTrue(protein.getCodonFrame(cdna.getSequenceAt(4)).isEmpty()); + } + + /** + * Test mapping of protein to cDNA, for the case where we have some sequence + * cross-references. Verify that once we have made an xref mapping we don't + * also map un-xrefd sequeces. + * + * @throws IOException + */ + @Test(groups = { "Functional" }) + public void testMapProteinAlignmentToCdna_prioritiseXrefs() + throws IOException + { + List protseqs = new ArrayList(); + protseqs.add(new Sequence("UNIPROT|V12345", "EIQ")); + protseqs.add(new Sequence("UNIPROT|V12346", "EIQ")); + AlignmentI protein = new Alignment( + protseqs.toArray(new SequenceI[protseqs.size()])); + protein.setDataset(null); + + List dnaseqs = new ArrayList(); + dnaseqs.add(new Sequence("EMBL|A11111", "GAAATCCAG")); // = EIQ + dnaseqs.add(new Sequence("EMBL|A22222", "GAAATTCAG")); // = EIQ + AlignmentI cdna = new Alignment(dnaseqs.toArray(new SequenceI[dnaseqs + .size()])); + cdna.setDataset(null); + + // Xref A22222 to V12345 (should get mapped) + // A11111 should then be mapped to the unmapped V12346 + dnaseqs.get(1).addDBRef(new DBRefEntry("UNIPROT", "1", "V12345")); + + assertTrue(AlignmentUtils.mapProteinAlignmentToCdna(protein, cdna)); + + // 2 protein mappings made + assertEquals(2, protein.getCodonFrames().size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(0)).size()); + assertEquals(1, protein.getCodonFrame(protein.getSequenceAt(1)).size()); + + // one mapping for each of the cDNA sequences + assertEquals(1, protein.getCodonFrame(cdna.getSequenceAt(0)).size()); + assertEquals(1, protein.getCodonFrame(cdna.getSequenceAt(1)).size()); + + // V12345 mapped to A22222 + AlignedCodonFrame acf = protein.getCodonFrame(protein.getSequenceAt(0)) + .get(0); + assertEquals(1, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(1).getDatasetSequence(), + acf.getdnaSeqs()[0]); + + // V12346 mapped to A11111 + acf = protein.getCodonFrame(protein.getSequenceAt(1)).get(0); + assertEquals(1, acf.getdnaSeqs().length); + assertEquals(cdna.getSequenceAt(0).getDatasetSequence(), + acf.getdnaSeqs()[0]); + } + + /** + * Test the method that shows or hides sequence annotations by type(s) and + * selection group. + */ + @Test(groups = { "Functional" }) + public void testShowOrHideSequenceAnnotations() + { + SequenceI seq1 = new Sequence("Seq1", "AAA"); + SequenceI seq2 = new Sequence("Seq2", "BBB"); + SequenceI seq3 = new Sequence("Seq3", "CCC"); + Annotation[] anns = new Annotation[] { new Annotation(2f) }; + AlignmentAnnotation ann1 = new AlignmentAnnotation("Structure", "ann1", + anns); + ann1.setSequenceRef(seq1); + AlignmentAnnotation ann2 = new AlignmentAnnotation("Structure", "ann2", + anns); + ann2.setSequenceRef(seq2); + AlignmentAnnotation ann3 = new AlignmentAnnotation("Structure", "ann3", + anns); + AlignmentAnnotation ann4 = new AlignmentAnnotation("Temp", "ann4", anns); + ann4.setSequenceRef(seq1); + AlignmentAnnotation ann5 = new AlignmentAnnotation("Temp", "ann5", anns); + ann5.setSequenceRef(seq2); + AlignmentAnnotation ann6 = new AlignmentAnnotation("Temp", "ann6", anns); + AlignmentI al = new Alignment(new SequenceI[] { seq1, seq2, seq3 }); + al.addAnnotation(ann1); // Structure for Seq1 + al.addAnnotation(ann2); // Structure for Seq2 + al.addAnnotation(ann3); // Structure for no sequence + al.addAnnotation(ann4); // Temp for seq1 + al.addAnnotation(ann5); // Temp for seq2 + al.addAnnotation(ann6); // Temp for no sequence + List types = new ArrayList(); + List scope = new ArrayList(); + + /* + * Set all sequence related Structure to hidden (ann1, ann2) + */ + types.add("Structure"); + AlignmentUtils.showOrHideSequenceAnnotations(al, types, null, false, + false); + assertFalse(ann1.visible); + assertFalse(ann2.visible); + assertTrue(ann3.visible); // not sequence-related, not affected + assertTrue(ann4.visible); // not Structure, not affected + assertTrue(ann5.visible); // " + assertTrue(ann6.visible); // not sequence-related, not affected + + /* + * Set Temp in {seq1, seq3} to hidden + */ + types.clear(); + types.add("Temp"); + scope.add(seq1); + scope.add(seq3); + AlignmentUtils.showOrHideSequenceAnnotations(al, types, scope, false, + false); + assertFalse(ann1.visible); // unchanged + assertFalse(ann2.visible); // unchanged + assertTrue(ann3.visible); // not sequence-related, not affected + assertFalse(ann4.visible); // Temp for seq1 hidden + assertTrue(ann5.visible); // not in scope, not affected + assertTrue(ann6.visible); // not sequence-related, not affected + + /* + * Set Temp in all sequences to hidden + */ + types.clear(); + types.add("Temp"); + scope.add(seq1); + scope.add(seq3); + AlignmentUtils.showOrHideSequenceAnnotations(al, types, null, false, + false); + assertFalse(ann1.visible); // unchanged + assertFalse(ann2.visible); // unchanged + assertTrue(ann3.visible); // not sequence-related, not affected + assertFalse(ann4.visible); // Temp for seq1 hidden + assertFalse(ann5.visible); // Temp for seq2 hidden + assertTrue(ann6.visible); // not sequence-related, not affected + + /* + * Set all types in {seq1, seq3} to visible + */ + types.clear(); + scope.clear(); + scope.add(seq1); + scope.add(seq3); + AlignmentUtils.showOrHideSequenceAnnotations(al, types, scope, true, + true); + assertTrue(ann1.visible); // Structure for seq1 set visible + assertFalse(ann2.visible); // not in scope, unchanged + assertTrue(ann3.visible); // not sequence-related, not affected + assertTrue(ann4.visible); // Temp for seq1 set visible + assertFalse(ann5.visible); // not in scope, unchanged + assertTrue(ann6.visible); // not sequence-related, not affected + + /* + * Set all types in all scope to hidden + */ + AlignmentUtils.showOrHideSequenceAnnotations(al, types, null, true, + false); + assertFalse(ann1.visible); + assertFalse(ann2.visible); + assertTrue(ann3.visible); // not sequence-related, not affected + assertFalse(ann4.visible); + assertFalse(ann5.visible); + assertTrue(ann6.visible); // not sequence-related, not affected + } + + /** + * Tests for the method that checks if one sequence cross-references another + */ + @Test(groups = { "Functional" }) + public void testHasCrossRef() + { + assertFalse(AlignmentUtils.hasCrossRef(null, null)); + SequenceI seq1 = new Sequence("EMBL|A12345", "ABCDEF"); + assertFalse(AlignmentUtils.hasCrossRef(seq1, null)); + assertFalse(AlignmentUtils.hasCrossRef(null, seq1)); + SequenceI seq2 = new Sequence("UNIPROT|V20192", "ABCDEF"); + assertFalse(AlignmentUtils.hasCrossRef(seq1, seq2)); + + // different ref + seq1.addDBRef(new DBRefEntry("UNIPROT", "1", "v20193")); + assertFalse(AlignmentUtils.hasCrossRef(seq1, seq2)); + + // case-insensitive; version number is ignored + seq1.addDBRef(new DBRefEntry("UNIPROT", "1", "v20192")); + assertTrue(AlignmentUtils.hasCrossRef(seq1, seq2)); + + // right case! + seq1.addDBRef(new DBRefEntry("UNIPROT", "1", "V20192")); + assertTrue(AlignmentUtils.hasCrossRef(seq1, seq2)); + // test is one-way only + assertFalse(AlignmentUtils.hasCrossRef(seq2, seq1)); + } + + /** + * Tests for the method that checks if either sequence cross-references the + * other + */ + @Test(groups = { "Functional" }) + public void testHaveCrossRef() + { + assertFalse(AlignmentUtils.hasCrossRef(null, null)); + SequenceI seq1 = new Sequence("EMBL|A12345", "ABCDEF"); + assertFalse(AlignmentUtils.haveCrossRef(seq1, null)); + assertFalse(AlignmentUtils.haveCrossRef(null, seq1)); + SequenceI seq2 = new Sequence("UNIPROT|V20192", "ABCDEF"); + assertFalse(AlignmentUtils.haveCrossRef(seq1, seq2)); + + seq1.addDBRef(new DBRefEntry("UNIPROT", "1", "V20192")); + assertTrue(AlignmentUtils.haveCrossRef(seq1, seq2)); + // next is true for haveCrossRef, false for hasCrossRef + assertTrue(AlignmentUtils.haveCrossRef(seq2, seq1)); + + // now the other way round + seq1.setDBRefs(null); + seq2.addDBRef(new DBRefEntry("EMBL", "1", "A12345")); + assertTrue(AlignmentUtils.haveCrossRef(seq1, seq2)); + assertTrue(AlignmentUtils.haveCrossRef(seq2, seq1)); + + // now both ways + seq1.addDBRef(new DBRefEntry("UNIPROT", "1", "V20192")); + assertTrue(AlignmentUtils.haveCrossRef(seq1, seq2)); + assertTrue(AlignmentUtils.haveCrossRef(seq2, seq1)); + } + + /** + * Test the method that extracts the cds-only part of a dna alignment. + */ + @Test(groups = { "Functional" }) + public void testMakeCdsAlignment() + { + /* + * scenario: + * dna1 --> [4, 6] [10,12] --> pep1 + * dna2 --> [1, 3] [7, 9] [13,15] --> pep2 + */ + SequenceI dna1 = new Sequence("dna1", "aaaGGGcccTTTaaa"); + SequenceI dna2 = new Sequence("dna2", "GGGcccTTTaaaCCC"); + SequenceI pep1 = new Sequence("pep1", "GF"); + SequenceI pep2 = new Sequence("pep2", "GFP"); + pep1.addDBRef(new DBRefEntry("UNIPROT", "0", "pep1")); + pep2.addDBRef(new DBRefEntry("UNIPROT", "0", "pep2")); + dna1.createDatasetSequence(); + dna2.createDatasetSequence(); + pep1.createDatasetSequence(); + pep2.createDatasetSequence(); + AlignmentI dna = new Alignment(new SequenceI[] { dna1, dna2 }); + dna.setDataset(null); + + /* + * put a variant feature on dna2 base 8 + * - should transfer to cds2 base 5 + */ + dna2.addSequenceFeature(new SequenceFeature("variant", "hgmd", 8, 8, + 0f, null)); + + /* + * need a sourceDbRef if we are to construct dbrefs to the CDS + * sequence from the dna contig sequences + */ + DBRefEntry dbref = new DBRefEntry("ENSEMBL", "0", "dna1"); + dna1.getDatasetSequence().addDBRef(dbref); + org.testng.Assert.assertEquals(dbref, dna1.getPrimaryDBRefs().get(0)); + dbref = new DBRefEntry("ENSEMBL", "0", "dna2"); + dna2.getDatasetSequence().addDBRef(dbref); + org.testng.Assert.assertEquals(dbref, dna2.getPrimaryDBRefs().get(0)); + + /* + * CDS sequences are 'discovered' from dna-to-protein mappings on the alignment + * dataset (e.g. added from dbrefs by CrossRef.findXrefSequences) + */ + MapList mapfordna1 = new MapList(new int[] { 4, 6, 10, 12 }, new int[] { + 1, 2 }, 3, 1); + AlignedCodonFrame acf = new AlignedCodonFrame(); + acf.addMap(dna1.getDatasetSequence(), pep1.getDatasetSequence(), + mapfordna1); + dna.addCodonFrame(acf); + MapList mapfordna2 = new MapList(new int[] { 1, 3, 7, 9, 13, 15 }, + new int[] { 1, 3 }, 3, 1); + acf = new AlignedCodonFrame(); + acf.addMap(dna2.getDatasetSequence(), pep2.getDatasetSequence(), + mapfordna2); + dna.addCodonFrame(acf); + + /* + * In this case, mappings originally came from matching Uniprot accessions - so need an xref on dna involving those regions. These are normally constructed from CDS annotation + */ + DBRefEntry dna1xref = new DBRefEntry("UNIPROT", "ENSEMBL", "pep1", + new Mapping(mapfordna1)); + dna1.getDatasetSequence().addDBRef(dna1xref); + DBRefEntry dna2xref = new DBRefEntry("UNIPROT", "ENSEMBL", "pep2", + new Mapping(mapfordna2)); + dna2.getDatasetSequence().addDBRef(dna2xref); + + /* + * execute method under test: + */ + AlignmentI cds = AlignmentUtils.makeCdsAlignment(new SequenceI[] { + dna1, dna2 }, dna.getDataset(), null); + + /* + * verify cds sequences + */ + assertEquals(2, cds.getSequences().size()); + assertEquals("GGGTTT", cds.getSequenceAt(0).getSequenceAsString()); + assertEquals("GGGTTTCCC", cds.getSequenceAt(1).getSequenceAsString()); + + /* + * verify shared, extended alignment dataset + */ + assertSame(dna.getDataset(), cds.getDataset()); + SequenceI cds1Dss = cds.getSequenceAt(0).getDatasetSequence(); + SequenceI cds2Dss = cds.getSequenceAt(1).getDatasetSequence(); + assertTrue(dna.getDataset().getSequences().contains(cds1Dss)); + assertTrue(dna.getDataset().getSequences().contains(cds2Dss)); + + /* + * verify CDS has a dbref with mapping to peptide + */ + assertNotNull(cds1Dss.getDBRefs()); + assertEquals(2, cds1Dss.getDBRefs().length); + dbref = cds1Dss.getDBRefs()[0]; + assertEquals(dna1xref.getSource(), dbref.getSource()); + // version is via ensembl's primary ref + assertEquals(dna1xref.getVersion(), dbref.getVersion()); + assertEquals(dna1xref.getAccessionId(), dbref.getAccessionId()); + assertNotNull(dbref.getMap()); + assertSame(pep1.getDatasetSequence(), dbref.getMap().getTo()); + MapList cdsMapping = new MapList(new int[] { 1, 6 }, + new int[] { 1, 2 }, 3, 1); + assertEquals(cdsMapping, dbref.getMap().getMap()); + + /* + * verify peptide has added a dbref with reverse mapping to CDS + */ + assertNotNull(pep1.getDBRefs()); + // FIXME pep1.getDBRefs() is 1 - is that the correct behaviour ? + assertEquals(2, pep1.getDBRefs().length); + dbref = pep1.getDBRefs()[1]; + assertEquals("ENSEMBL", dbref.getSource()); + assertEquals("0", dbref.getVersion()); + assertEquals("CDS|dna1", dbref.getAccessionId()); + assertNotNull(dbref.getMap()); + assertSame(cds1Dss, dbref.getMap().getTo()); + assertEquals(cdsMapping.getInverse(), dbref.getMap().getMap()); + + /* + * Verify mappings from CDS to peptide, cDNA to CDS, and cDNA to peptide + * the mappings are on the shared alignment dataset + * 6 mappings, 2*(DNA->CDS), 2*(DNA->Pep), 2*(CDS->Pep) + */ + List cdsMappings = cds.getDataset().getCodonFrames(); + assertEquals(6, cdsMappings.size()); + + /* + * verify that mapping sets for dna and cds alignments are different + * [not current behaviour - all mappings are on the alignment dataset] + */ + // select -> subselect type to test. + // Assert.assertNotSame(dna.getCodonFrames(), cds.getCodonFrames()); + // assertEquals(4, dna.getCodonFrames().size()); + // assertEquals(4, cds.getCodonFrames().size()); + + /* + * Two mappings involve pep1 (dna to pep1, cds to pep1) + * Mapping from pep1 to GGGTTT in first new exon sequence + */ + List pep1Mappings = MappingUtils + .findMappingsForSequence(pep1, cdsMappings); + assertEquals(2, pep1Mappings.size()); + List mappings = MappingUtils + .findMappingsForSequence(cds.getSequenceAt(0), pep1Mappings); + assertEquals(1, mappings.size()); + + // map G to GGG + SearchResults sr = MappingUtils.buildSearchResults(pep1, 1, mappings); + assertEquals(1, sr.getResults().size()); + Match m = sr.getResults().get(0); + assertSame(cds1Dss, 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); + assertSame(cds1Dss, m.getSequence()); + assertEquals(4, m.getStart()); + assertEquals(6, m.getEnd()); + + /* + * Two mappings involve pep2 (dna to pep2, cds to pep2) + * Verify mapping from pep2 to GGGTTTCCC in second new exon sequence + */ + List pep2Mappings = MappingUtils + .findMappingsForSequence(pep2, cdsMappings); + assertEquals(2, pep2Mappings.size()); + mappings = MappingUtils.findMappingsForSequence(cds.getSequenceAt(1), + pep2Mappings); + assertEquals(1, mappings.size()); + // map G to GGG + sr = MappingUtils.buildSearchResults(pep2, 1, mappings); + assertEquals(1, sr.getResults().size()); + m = sr.getResults().get(0); + assertSame(cds2Dss, 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); + assertSame(cds2Dss, 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); + assertSame(cds2Dss, m.getSequence()); + assertEquals(7, m.getStart()); + assertEquals(9, m.getEnd()); + + /* + * check cds2 acquired a variant feature in position 5 + */ + SequenceFeature[] sfs = cds2Dss.getSequenceFeatures(); + assertNotNull(sfs); + assertEquals(1, sfs.length); + assertEquals("variant", sfs[0].type); + assertEquals(5, sfs[0].begin); + assertEquals(5, sfs[0].end); + } + + /** + * 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 testMakeCdsAlignment_multipleProteins() + { + SequenceI dna1 = new Sequence("dna1", "aaaGGGcccTTTaaa"); + SequenceI pep1 = new Sequence("pep1", "GF"); // GGGTTT + SequenceI pep2 = new Sequence("pep2", "KP"); // aaaccc + SequenceI pep3 = new Sequence("pep3", "KF"); // aaaTTT + dna1.createDatasetSequence(); + pep1.createDatasetSequence(); + pep2.createDatasetSequence(); + pep3.createDatasetSequence(); + pep1.getDatasetSequence().addDBRef( + new DBRefEntry("EMBLCDS", "2", "A12345")); + pep2.getDatasetSequence().addDBRef( + new DBRefEntry("EMBLCDS", "3", "A12346")); + pep3.getDatasetSequence().addDBRef( + new DBRefEntry("EMBLCDS", "4", "A12347")); + + /* + * Create the CDS alignment + */ + AlignmentI dna = new Alignment(new SequenceI[] { dna1 }); + dna.setDataset(null); + + /* + * Make the mappings from dna to protein + */ + // map ...GGG...TTT to GF + MapList map = new MapList(new int[] { 4, 6, 10, 12 }, + new int[] { 1, 2 }, 3, 1); + AlignedCodonFrame acf = new AlignedCodonFrame(); + acf.addMap(dna1.getDatasetSequence(), pep1.getDatasetSequence(), map); + dna.addCodonFrame(acf); + + // map aaa...ccc to KP + map = new MapList(new int[] { 1, 3, 7, 9 }, new int[] { 1, 2 }, 3, 1); + acf = new AlignedCodonFrame(); + acf.addMap(dna1.getDatasetSequence(), pep2.getDatasetSequence(), map); + dna.addCodonFrame(acf); + + // map aaa......TTT to KF + map = new MapList(new int[] { 1, 3, 10, 12 }, new int[] { 1, 2 }, 3, 1); + acf = new AlignedCodonFrame(); + acf.addMap(dna1.getDatasetSequence(), pep3.getDatasetSequence(), map); + dna.addCodonFrame(acf); + + /* + * execute method under test + */ + AlignmentI cdsal = AlignmentUtils.makeCdsAlignment( + new SequenceI[] { dna1 }, dna.getDataset(), null); + + /* + * Verify we have 3 cds sequences, mapped to pep1/2/3 respectively + */ + List cds = cdsal.getSequences(); + assertEquals(3, cds.size()); + + /* + * verify shared, extended alignment dataset + */ + assertSame(cdsal.getDataset(), dna.getDataset()); + assertTrue(dna.getDataset().getSequences() + .contains(cds.get(0).getDatasetSequence())); + assertTrue(dna.getDataset().getSequences() + .contains(cds.get(1).getDatasetSequence())); + assertTrue(dna.getDataset().getSequences() + .contains(cds.get(2).getDatasetSequence())); + + /* + * verify aligned cds sequences and their xrefs + */ + SequenceI cdsSeq = cds.get(0); + assertEquals("GGGTTT", cdsSeq.getSequenceAsString()); + // assertEquals("dna1|A12345", cdsSeq.getName()); + assertEquals("CDS|dna1", cdsSeq.getName()); + // assertEquals(1, cdsSeq.getDBRefs().length); + // DBRefEntry cdsRef = cdsSeq.getDBRefs()[0]; + // assertEquals("EMBLCDS", cdsRef.getSource()); + // assertEquals("2", cdsRef.getVersion()); + // assertEquals("A12345", cdsRef.getAccessionId()); + + cdsSeq = cds.get(1); + assertEquals("aaaccc", cdsSeq.getSequenceAsString()); + // assertEquals("dna1|A12346", cdsSeq.getName()); + assertEquals("CDS|dna1", cdsSeq.getName()); + // assertEquals(1, cdsSeq.getDBRefs().length); + // cdsRef = cdsSeq.getDBRefs()[0]; + // assertEquals("EMBLCDS", cdsRef.getSource()); + // assertEquals("3", cdsRef.getVersion()); + // assertEquals("A12346", cdsRef.getAccessionId()); + + cdsSeq = cds.get(2); + assertEquals("aaaTTT", cdsSeq.getSequenceAsString()); + // assertEquals("dna1|A12347", cdsSeq.getName()); + assertEquals("CDS|dna1", 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 cds sequence to its protein product + * and also to its dna source + */ + List newMappings = cdsal.getCodonFrames(); + + /* + * 6 mappings involve dna1 (to pep1/2/3, cds1/2/3) + */ + List dnaMappings = MappingUtils + .findMappingsForSequence(dna1, newMappings); + assertEquals(6, dnaMappings.size()); + + /* + * dna1 to pep1 + */ + List mappings = MappingUtils + .findMappingsForSequence(pep1, dnaMappings); + assertEquals(1, mappings.size()); + assertEquals(1, mappings.get(0).getMappings().size()); + assertSame(pep1.getDatasetSequence(), mappings.get(0).getMappings() + .get(0).getMapping().getTo()); + + /* + * dna1 to cds1 + */ + List dnaToCds1Mappings = MappingUtils + .findMappingsForSequence(cds.get(0), dnaMappings); + Mapping mapping = dnaToCds1Mappings.get(0).getMappings().get(0) + .getMapping(); + assertSame(cds.get(0).getDatasetSequence(), mapping.getTo()); + assertEquals("G(1) in CDS should map to G(4) in DNA", 4, mapping + .getMap().getToPosition(1)); + + /* + * dna1 to pep2 + */ + mappings = MappingUtils.findMappingsForSequence(pep2, dnaMappings); + assertEquals(1, mappings.size()); + assertEquals(1, mappings.get(0).getMappings().size()); + assertSame(pep2.getDatasetSequence(), mappings.get(0).getMappings() + .get(0).getMapping().getTo()); + + /* + * dna1 to cds2 + */ + List dnaToCds2Mappings = MappingUtils + .findMappingsForSequence(cds.get(1), dnaMappings); + mapping = dnaToCds2Mappings.get(0).getMappings().get(0).getMapping(); + assertSame(cds.get(1).getDatasetSequence(), mapping.getTo()); + assertEquals("c(4) in CDS should map to c(7) in DNA", 7, mapping + .getMap().getToPosition(4)); + + /* + * dna1 to pep3 + */ + mappings = MappingUtils.findMappingsForSequence(pep3, dnaMappings); + assertEquals(1, mappings.size()); + assertEquals(1, mappings.get(0).getMappings().size()); + assertSame(pep3.getDatasetSequence(), mappings.get(0).getMappings() + .get(0).getMapping().getTo()); + + /* + * dna1 to cds3 + */ + List dnaToCds3Mappings = MappingUtils + .findMappingsForSequence(cds.get(2), dnaMappings); + mapping = dnaToCds3Mappings.get(0).getMappings().get(0).getMapping(); + assertSame(cds.get(2).getDatasetSequence(), mapping.getTo()); + assertEquals("T(4) in CDS should map to T(10) in DNA", 10, mapping + .getMap().getToPosition(4)); + } + + @Test(groups = { "Functional" }) + public void testIsMappable() + { + SequenceI dna1 = new Sequence("dna1", "cgCAGtgGT"); + SequenceI aa1 = new Sequence("aa1", "RSG"); + AlignmentI al1 = new Alignment(new SequenceI[] { dna1 }); + AlignmentI al2 = new Alignment(new SequenceI[] { aa1 }); + + assertFalse(AlignmentUtils.isMappable(null, null)); + assertFalse(AlignmentUtils.isMappable(al1, null)); + assertFalse(AlignmentUtils.isMappable(null, al1)); + assertFalse(AlignmentUtils.isMappable(al1, al1)); + assertFalse(AlignmentUtils.isMappable(al2, al2)); + + assertTrue(AlignmentUtils.isMappable(al1, al2)); + assertTrue(AlignmentUtils.isMappable(al2, al1)); + } + + /** + * Test creating a mapping when the sequences involved do not start at residue + * 1 + * + * @throws IOException + */ + @Test(groups = { "Functional" }) + public void testMapCdnaToProtein_forSubsequence() throws IOException + { + SequenceI prot = new Sequence("UNIPROT|V12345", "E-I--Q", 10, 12); + prot.createDatasetSequence(); + + SequenceI dna = new Sequence("EMBL|A33333", "GAA--AT-C-CAG", 40, 48); + dna.createDatasetSequence(); + + MapList map = AlignmentUtils.mapCdnaToProtein(prot, dna); + assertEquals(10, map.getToLowest()); + assertEquals(12, map.getToHighest()); + 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(); + + AlignmentI dna = new Alignment(new SequenceI[] { dna1, dna2, dna3 }); + dna.setDataset(null); + + 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); + dna.addCodonFrame(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); + dna.addCodonFrame(acf); + + AlignmentI cds = AlignmentUtils.makeCdsAlignment(new SequenceI[] { + dna1, dna2, dna3 }, dna.getDataset(), null); + List cdsSeqs = cds.getSequences(); + assertEquals(2, cdsSeqs.size()); + assertEquals("GGGCCCTTTGGG", cdsSeqs.get(0).getSequenceAsString()); + assertEquals("GGGCCTGGG", cdsSeqs.get(1).getSequenceAsString()); + + /* + * verify shared, extended alignment dataset + */ + assertSame(dna.getDataset(), cds.getDataset()); + assertTrue(dna.getDataset().getSequences() + .contains(cdsSeqs.get(0).getDatasetSequence())); + assertTrue(dna.getDataset().getSequences() + .contains(cdsSeqs.get(1).getDatasetSequence())); + + /* + * Verify 6 mappings: dna1 to cds1, cds1 to pep1, dna1 to pep1 + * and the same for dna2/cds2/pep2 + */ + List mappings = cds.getCodonFrames(); + assertEquals(6, mappings.size()); + + /* + * 2 mappings involve pep1 + */ + List pep1Mappings = MappingUtils + .findMappingsForSequence(pep1, mappings); + assertEquals(2, pep1Mappings.size()); + + /* + * Get mapping of pep1 to cds1 and verify it + * maps GPFG to 1-3,4-6,7-9,10-12 + */ + List pep1CdsMappings = MappingUtils + .findMappingsForSequence(cds.getSequenceAt(0), pep1Mappings); + assertEquals(1, pep1CdsMappings.size()); + SearchResults sr = MappingUtils.buildSearchResults(pep1, 1, + pep1CdsMappings); + 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, pep1CdsMappings); + m = sr.getResults().get(0); + assertEquals(4, m.getStart()); + assertEquals(6, m.getEnd()); + sr = MappingUtils.buildSearchResults(pep1, 3, pep1CdsMappings); + m = sr.getResults().get(0); + assertEquals(7, m.getStart()); + assertEquals(9, m.getEnd()); + sr = MappingUtils.buildSearchResults(pep1, 4, pep1CdsMappings); + m = sr.getResults().get(0); + assertEquals(10, m.getStart()); + assertEquals(12, m.getEnd()); + + /* + * Get mapping of pep2 to cds2 and verify it + * maps GPG in pep2 to 1-3,4-6,7-9 in second CDS sequence + */ + List pep2Mappings = MappingUtils + .findMappingsForSequence(pep2, mappings); + assertEquals(2, pep2Mappings.size()); + List pep2CdsMappings = MappingUtils + .findMappingsForSequence(cds.getSequenceAt(1), pep2Mappings); + assertEquals(1, pep2CdsMappings.size()); + sr = MappingUtils.buildSearchResults(pep2, 1, pep2CdsMappings); + 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, pep2CdsMappings); + m = sr.getResults().get(0); + assertEquals(4, m.getStart()); + assertEquals(6, m.getEnd()); + sr = MappingUtils.buildSearchResults(pep2, 3, pep2CdsMappings); + m = sr.getResults().get(0); + assertEquals(7, m.getStart()); + assertEquals(9, m.getEnd()); + } + + /** + * 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 acfs = new ArrayList(); + 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()); + } + + /** + * Tests for the method that maps the subset of a dna sequence that has CDS + * (or subtype) feature - case where the start codon is incomplete. + */ + @Test(groups = "Functional") + public void testFindCdsPositions_fivePrimeIncomplete() + { + SequenceI dnaSeq = new Sequence("dna", "aaagGGCCCaaaTTTttt"); + dnaSeq.createDatasetSequence(); + SequenceI ds = dnaSeq.getDatasetSequence(); + + // CDS for dna 5-6 (incomplete codon), 7-9 + SequenceFeature sf = new SequenceFeature("CDS", "", 5, 9, 0f, null); + sf.setPhase("2"); // skip 2 bases to start of next codon + ds.addSequenceFeature(sf); + // CDS for dna 13-15 + sf = new SequenceFeature("CDS_predicted", "", 13, 15, 0f, null); + ds.addSequenceFeature(sf); + + List ranges = AlignmentUtils.findCdsPositions(dnaSeq); + + /* + * check the mapping starts with the first complete codon + */ + assertEquals(6, MappingUtils.getLength(ranges)); + assertEquals(2, ranges.size()); + assertEquals(7, ranges.get(0)[0]); + assertEquals(9, ranges.get(0)[1]); + assertEquals(13, ranges.get(1)[0]); + assertEquals(15, ranges.get(1)[1]); + } + + /** + * Tests for the method that maps the subset of a dna sequence that has CDS + * (or subtype) feature. + */ + @Test(groups = "Functional") + public void testFindCdsPositions() + { + SequenceI dnaSeq = new Sequence("dna", "aaaGGGcccAAATTTttt"); + dnaSeq.createDatasetSequence(); + SequenceI ds = dnaSeq.getDatasetSequence(); + + // CDS for dna 10-12 + SequenceFeature sf = new SequenceFeature("CDS_predicted", "", 10, 12, + 0f, null); + sf.setStrand("+"); + ds.addSequenceFeature(sf); + // CDS for dna 4-6 + sf = new SequenceFeature("CDS", "", 4, 6, 0f, null); + sf.setStrand("+"); + ds.addSequenceFeature(sf); + // exon feature should be ignored here + sf = new SequenceFeature("exon", "", 7, 9, 0f, null); + ds.addSequenceFeature(sf); + + List ranges = AlignmentUtils.findCdsPositions(dnaSeq); + /* + * verify ranges { [4-6], [12-10] } + * note CDS ranges are ordered ascending even if the CDS + * features are not + */ + assertEquals(6, MappingUtils.getLength(ranges)); + assertEquals(2, ranges.size()); + assertEquals(4, ranges.get(0)[0]); + assertEquals(6, ranges.get(0)[1]); + assertEquals(10, ranges.get(1)[0]); + assertEquals(12, ranges.get(1)[1]); + } + + /** + * Test the method that computes a map of codon variants for each protein + * position from "sequence_variant" features on dna + */ + @Test(groups = "Functional") + public void testBuildDnaVariantsMap() + { + SequenceI dna = new Sequence("dna", "atgAAATTTGGGCCCtag"); + MapList map = new MapList(new int[] { 1, 18 }, new int[] { 1, 5 }, 3, 1); + + /* + * first with no variants on dna + */ + LinkedHashMap[]> variantsMap = AlignmentUtils + .buildDnaVariantsMap(dna, map); + assertTrue(variantsMap.isEmpty()); + + /* + * single allele codon 1, on base 1 + */ + SequenceFeature sf1 = new SequenceFeature("sequence_variant", "", 1, 1, + 0f, null); + sf1.setValue("alleles", "T"); + sf1.setValue("ID", "sequence_variant:rs758803211"); + dna.addSequenceFeature(sf1); + + /* + * two alleles codon 2, on bases 2 and 3 (distinct variants) + */ + SequenceFeature sf2 = new SequenceFeature("sequence_variant", "", 5, 5, + 0f, null); + sf2.setValue("alleles", "T"); + sf2.setValue("ID", "sequence_variant:rs758803212"); + dna.addSequenceFeature(sf2); + SequenceFeature sf3 = new SequenceFeature("sequence_variant", "", 6, 6, + 0f, null); + sf3.setValue("alleles", "G"); + sf3.setValue("ID", "sequence_variant:rs758803213"); + dna.addSequenceFeature(sf3); + + /* + * two alleles codon 3, both on base 2 (one variant) + */ + SequenceFeature sf4 = new SequenceFeature("sequence_variant", "", 8, 8, + 0f, null); + sf4.setValue("alleles", "C, G"); + sf4.setValue("ID", "sequence_variant:rs758803214"); + dna.addSequenceFeature(sf4); + + // no alleles on codon 4 + + /* + * alleles on codon 5 on all 3 bases (distinct variants) + */ + SequenceFeature sf5 = new SequenceFeature("sequence_variant", "", 13, + 13, 0f, null); + sf5.setValue("alleles", "C, G"); // (C duplicates given base value) + sf5.setValue("ID", "sequence_variant:rs758803215"); + dna.addSequenceFeature(sf5); + SequenceFeature sf6 = new SequenceFeature("sequence_variant", "", 14, + 14, 0f, null); + sf6.setValue("alleles", "g, a"); // should force to upper-case + sf6.setValue("ID", "sequence_variant:rs758803216"); + dna.addSequenceFeature(sf6); + SequenceFeature sf7 = new SequenceFeature("sequence_variant", "", 15, + 15, 0f, null); + sf7.setValue("alleles", "A, T"); + sf7.setValue("ID", "sequence_variant:rs758803217"); + dna.addSequenceFeature(sf7); + + /* + * build map - expect variants on positions 1, 2, 3, 5 + */ + variantsMap = AlignmentUtils.buildDnaVariantsMap(dna, map); + assertEquals(4, variantsMap.size()); + + /* + * protein residue 1: variant on codon (ATG) base 1, not on 2 or 3 + */ + List[] pep1Variants = variantsMap.get(1); + assertEquals(3, pep1Variants.length); + assertEquals(1, pep1Variants[0].size()); + assertEquals("A", pep1Variants[0].get(0).base); // codon[1] base + assertSame(sf1, pep1Variants[0].get(0).variant); // codon[1] variant + assertEquals(1, pep1Variants[1].size()); + assertEquals("T", pep1Variants[1].get(0).base); // codon[2] base + assertNull(pep1Variants[1].get(0).variant); // no variant here + assertEquals(1, pep1Variants[2].size()); + assertEquals("G", pep1Variants[2].get(0).base); // codon[3] base + assertNull(pep1Variants[2].get(0).variant); // no variant here + + /* + * protein residue 2: variants on codon (AAA) bases 2 and 3 + */ + List[] pep2Variants = variantsMap.get(2); + assertEquals(3, pep2Variants.length); + assertEquals(1, pep2Variants[0].size()); + // codon[1] base recorded while processing variant on codon[2] + assertEquals("A", pep2Variants[0].get(0).base); + assertNull(pep2Variants[0].get(0).variant); // no variant here + // codon[2] base and variant: + assertEquals(1, pep2Variants[1].size()); + assertEquals("A", pep2Variants[1].get(0).base); + assertSame(sf2, pep2Variants[1].get(0).variant); + // codon[3] base was recorded when processing codon[2] variant + // and then the variant for codon[3] added to it + assertEquals(1, pep2Variants[2].size()); + assertEquals("A", pep2Variants[2].get(0).base); + assertSame(sf3, pep2Variants[2].get(0).variant); + + /* + * protein residue 3: variants on codon (TTT) base 2 only + */ + List[] pep3Variants = variantsMap.get(3); + assertEquals(3, pep3Variants.length); + assertEquals(1, pep3Variants[0].size()); + assertEquals("T", pep3Variants[0].get(0).base); // codon[1] base + assertNull(pep3Variants[0].get(0).variant); // no variant here + assertEquals(1, pep3Variants[1].size()); + assertEquals("T", pep3Variants[1].get(0).base); // codon[2] base + assertSame(sf4, pep3Variants[1].get(0).variant); // codon[2] variant + assertEquals(1, pep3Variants[2].size()); + assertEquals("T", pep3Variants[2].get(0).base); // codon[3] base + assertNull(pep3Variants[2].get(0).variant); // no variant here + + /* + * three variants on protein position 5 + */ + List[] pep5Variants = variantsMap.get(5); + assertEquals(3, pep5Variants.length); + assertEquals(1, pep5Variants[0].size()); + assertEquals("C", pep5Variants[0].get(0).base); // codon[1] base + assertSame(sf5, pep5Variants[0].get(0).variant); // codon[1] variant + assertEquals(1, pep5Variants[1].size()); + assertEquals("C", pep5Variants[1].get(0).base); // codon[2] base + assertSame(sf6, pep5Variants[1].get(0).variant); // codon[2] variant + assertEquals(1, pep5Variants[2].size()); + assertEquals("C", pep5Variants[2].get(0).base); // codon[3] base + assertSame(sf7, pep5Variants[2].get(0).variant); // codon[3] variant + } + + /** + * Tests for the method that computes all peptide variants given codon + * variants + */ + @Test(groups = "Functional") + public void testComputePeptideVariants() + { + /* + * scenario: AAATTTCCC codes for KFP + * variants: + * GAA -> E source: Ensembl + * CAA -> Q source: dbSNP + * AAG synonymous source: COSMIC + * AAT -> N source: Ensembl + * ...TTC synonymous source: dbSNP + * ......CAC,CGC -> H,R source: COSMIC + * (one variant with two alleles) + */ + SequenceI peptide = new Sequence("pep/10-12", "KFP"); + + /* + * two distinct variants for codon 1 position 1 + * second one has clinical significance + */ + String ensembl = "Ensembl"; + String dbSnp = "dbSNP"; + String cosmic = "COSMIC"; + SequenceFeature sf1 = new SequenceFeature("sequence_variant", "", 1, 1, + 0f, ensembl); + sf1.setValue("alleles", "A,G"); // GAA -> E + sf1.setValue("ID", "var1.125A>G"); + SequenceFeature sf2 = new SequenceFeature("sequence_variant", "", 1, 1, + 0f, dbSnp); + sf2.setValue("alleles", "A,C"); // CAA -> Q + sf2.setValue("ID", "var2"); + sf2.setValue("clinical_significance", "Dodgy"); + SequenceFeature sf3 = new SequenceFeature("sequence_variant", "", 3, 3, + 0f, cosmic); + sf3.setValue("alleles", "A,G"); // synonymous + sf3.setValue("ID", "var3"); + sf3.setValue("clinical_significance", "None"); + SequenceFeature sf4 = new SequenceFeature("sequence_variant", "", 3, 3, + 0f, ensembl); + sf4.setValue("alleles", "A,T"); // AAT -> N + sf4.setValue("ID", "sequence_variant:var4"); // prefix gets stripped off + sf4.setValue("clinical_significance", "Benign"); + SequenceFeature sf5 = new SequenceFeature("sequence_variant", "", 6, 6, + 0f, dbSnp); + sf5.setValue("alleles", "T,C"); // synonymous + sf5.setValue("ID", "var5"); + sf5.setValue("clinical_significance", "Bad"); + SequenceFeature sf6 = new SequenceFeature("sequence_variant", "", 8, 8, + 0f, cosmic); + sf6.setValue("alleles", "C,A,G"); // CAC,CGC -> H,R + sf6.setValue("ID", "var6"); + sf6.setValue("clinical_significance", "Good"); + + List codon1Variants = new ArrayList(); + List codon2Variants = new ArrayList(); + List codon3Variants = new ArrayList(); + List codonVariants[] = new ArrayList[3]; + codonVariants[0] = codon1Variants; + codonVariants[1] = codon2Variants; + codonVariants[2] = codon3Variants; + + /* + * compute variants for protein position 1 + */ + codon1Variants.add(new DnaVariant("A", sf1)); + codon1Variants.add(new DnaVariant("A", sf2)); + codon2Variants.add(new DnaVariant("A")); + codon2Variants.add(new DnaVariant("A")); + codon3Variants.add(new DnaVariant("A", sf3)); + codon3Variants.add(new DnaVariant("A", sf4)); + AlignmentUtils.computePeptideVariants(peptide, 1, codonVariants); + + /* + * compute variants for protein position 2 + */ + codon1Variants.clear(); + codon2Variants.clear(); + codon3Variants.clear(); + codon1Variants.add(new DnaVariant("T")); + codon2Variants.add(new DnaVariant("T")); + codon3Variants.add(new DnaVariant("T", sf5)); + AlignmentUtils.computePeptideVariants(peptide, 2, codonVariants); + + /* + * compute variants for protein position 3 + */ + codon1Variants.clear(); + codon2Variants.clear(); + codon3Variants.clear(); + codon1Variants.add(new DnaVariant("C")); + codon2Variants.add(new DnaVariant("C", sf6)); + codon3Variants.add(new DnaVariant("C")); + AlignmentUtils.computePeptideVariants(peptide, 3, codonVariants); + + /* + * verify added sequence features for + * var1 K -> E Ensembl + * var2 K -> Q dbSNP + * var4 K -> N Ensembl + * var6 P -> H COSMIC + * var6 P -> R COSMIC + */ + SequenceFeature[] sfs = peptide.getSequenceFeatures(); + assertEquals(5, sfs.length); + + SequenceFeature sf = sfs[0]; + assertEquals(1, sf.getBegin()); + assertEquals(1, sf.getEnd()); + assertEquals("p.Lys1Glu", sf.getDescription()); + assertEquals("var1.125A>G", sf.getValue("ID")); + assertNull(sf.getValue("clinical_significance")); + assertEquals("ID=var1.125A>G", sf.getAttributes()); + assertEquals(1, sf.links.size()); + // link to variation is urlencoded + assertEquals( + "p.Lys1Glu var1.125A>G|http://www.ensembl.org/Homo_sapiens/Variation/Summary?v=var1.125A%3EG", + sf.links.get(0)); + assertEquals(ensembl, sf.getFeatureGroup()); + + sf = sfs[1]; + assertEquals(1, sf.getBegin()); + assertEquals(1, sf.getEnd()); + assertEquals("p.Lys1Gln", sf.getDescription()); + assertEquals("var2", sf.getValue("ID")); + assertEquals("Dodgy", sf.getValue("clinical_significance")); + assertEquals("ID=var2;clinical_significance=Dodgy", sf.getAttributes()); + assertEquals(1, sf.links.size()); + assertEquals( + "p.Lys1Gln var2|http://www.ensembl.org/Homo_sapiens/Variation/Summary?v=var2", + sf.links.get(0)); + assertEquals(dbSnp, sf.getFeatureGroup()); + + sf = sfs[2]; + assertEquals(1, sf.getBegin()); + assertEquals(1, sf.getEnd()); + assertEquals("p.Lys1Asn", sf.getDescription()); + assertEquals("var4", sf.getValue("ID")); + assertEquals("Benign", sf.getValue("clinical_significance")); + assertEquals("ID=var4;clinical_significance=Benign", sf.getAttributes()); + assertEquals(1, sf.links.size()); + assertEquals( + "p.Lys1Asn var4|http://www.ensembl.org/Homo_sapiens/Variation/Summary?v=var4", + sf.links.get(0)); + assertEquals(ensembl, sf.getFeatureGroup()); + + // var5 generates two distinct protein variant features + sf = sfs[3]; + assertEquals(3, sf.getBegin()); + assertEquals(3, sf.getEnd()); + assertEquals("p.Pro3His", sf.getDescription()); + assertEquals("var6", sf.getValue("ID")); + assertEquals("Good", sf.getValue("clinical_significance")); + assertEquals("ID=var6;clinical_significance=Good", sf.getAttributes()); + assertEquals(1, sf.links.size()); + assertEquals( + "p.Pro3His var6|http://www.ensembl.org/Homo_sapiens/Variation/Summary?v=var6", + sf.links.get(0)); + assertEquals(cosmic, sf.getFeatureGroup()); + + sf = sfs[4]; + assertEquals(3, sf.getBegin()); + assertEquals(3, sf.getEnd()); + assertEquals("p.Pro3Arg", sf.getDescription()); + assertEquals("var6", sf.getValue("ID")); + assertEquals("Good", sf.getValue("clinical_significance")); + assertEquals("ID=var6;clinical_significance=Good", sf.getAttributes()); + assertEquals(1, sf.links.size()); + assertEquals( + "p.Pro3Arg var6|http://www.ensembl.org/Homo_sapiens/Variation/Summary?v=var6", + sf.links.get(0)); + assertEquals(cosmic, sf.getFeatureGroup()); + } + + /** + * Tests for the method that maps the subset of a dna sequence that has CDS + * (or subtype) feature, with CDS strand = '-' (reverse) + */ + // test turned off as currently findCdsPositions is not strand-dependent + // left in case it comes around again... + @Test(groups = "Functional", enabled = false) + public void testFindCdsPositions_reverseStrand() + { + SequenceI dnaSeq = new Sequence("dna", "aaaGGGcccAAATTTttt"); + dnaSeq.createDatasetSequence(); + SequenceI ds = dnaSeq.getDatasetSequence(); + + // CDS for dna 4-6 + SequenceFeature sf = new SequenceFeature("CDS", "", 4, 6, 0f, null); + sf.setStrand("-"); + ds.addSequenceFeature(sf); + // exon feature should be ignored here + sf = new SequenceFeature("exon", "", 7, 9, 0f, null); + ds.addSequenceFeature(sf); + // CDS for dna 10-12 + sf = new SequenceFeature("CDS_predicted", "", 10, 12, 0f, null); + sf.setStrand("-"); + ds.addSequenceFeature(sf); + + List ranges = AlignmentUtils.findCdsPositions(dnaSeq); + /* + * verify ranges { [12-10], [6-4] } + */ + assertEquals(6, MappingUtils.getLength(ranges)); + assertEquals(2, ranges.size()); + assertEquals(12, ranges.get(0)[0]); + assertEquals(10, ranges.get(0)[1]); + assertEquals(6, ranges.get(1)[0]); + assertEquals(4, ranges.get(1)[1]); + } + + /** + * Tests for the method that maps the subset of a dna sequence that has CDS + * (or subtype) feature - reverse strand case where the start codon is + * incomplete. + */ + @Test(groups = "Functional", enabled = false) + // test turned off as currently findCdsPositions is not strand-dependent + // left in case it comes around again... + public void testFindCdsPositions_reverseStrandThreePrimeIncomplete() + { + SequenceI dnaSeq = new Sequence("dna", "aaagGGCCCaaaTTTttt"); + dnaSeq.createDatasetSequence(); + SequenceI ds = dnaSeq.getDatasetSequence(); + + // CDS for dna 5-9 + SequenceFeature sf = new SequenceFeature("CDS", "", 5, 9, 0f, null); + sf.setStrand("-"); + ds.addSequenceFeature(sf); + // CDS for dna 13-15 + sf = new SequenceFeature("CDS_predicted", "", 13, 15, 0f, null); + sf.setStrand("-"); + sf.setPhase("2"); // skip 2 bases to start of next codon + ds.addSequenceFeature(sf); + + List ranges = AlignmentUtils.findCdsPositions(dnaSeq); + + /* + * check the mapping starts with the first complete codon + * expect ranges [13, 13], [9, 5] + */ + assertEquals(6, MappingUtils.getLength(ranges)); + assertEquals(2, ranges.size()); + assertEquals(13, ranges.get(0)[0]); + assertEquals(13, ranges.get(0)[1]); + assertEquals(9, ranges.get(1)[0]); + assertEquals(5, ranges.get(1)[1]); + } + + @Test(groups = "Functional") + public void testAlignAs_alternateTranscriptsUngapped() + { + SequenceI dna1 = new Sequence("dna1", "cccGGGTTTaaa"); + SequenceI dna2 = new Sequence("dna2", "CCCgggtttAAA"); + AlignmentI dna = new Alignment(new SequenceI[] { dna1, dna2 }); + ((Alignment) dna).createDatasetAlignment(); + SequenceI cds1 = new Sequence("cds1", "GGGTTT"); + SequenceI cds2 = new Sequence("cds2", "CCCAAA"); + AlignmentI cds = new Alignment(new SequenceI[] { cds1, cds2 }); + ((Alignment) cds).createDatasetAlignment(); + + AlignedCodonFrame acf = new AlignedCodonFrame(); + MapList map = new MapList(new int[] { 4, 9 }, new int[] { 1, 6 }, 1, 1); + acf.addMap(dna1.getDatasetSequence(), cds1.getDatasetSequence(), map); + map = new MapList(new int[] { 1, 3, 10, 12 }, new int[] { 1, 6 }, 1, 1); + acf.addMap(dna2.getDatasetSequence(), cds2.getDatasetSequence(), map); + + /* + * verify CDS alignment is as: + * cccGGGTTTaaa (cdna) + * CCCgggtttAAA (cdna) + * + * ---GGGTTT--- (cds) + * CCC------AAA (cds) + */ + dna.addCodonFrame(acf); + AlignmentUtils.alignAs(cds, dna); + assertEquals("---GGGTTT", cds.getSequenceAt(0).getSequenceAsString()); + assertEquals("CCC------AAA", cds.getSequenceAt(1).getSequenceAsString()); + } + + @Test(groups = { "Functional" }) + public void testAddMappedPositions() + { + SequenceI from = new Sequence("dna", "ggAA-ATcc-TT-g"); + SequenceI seq1 = new Sequence("cds", "AAATTT"); + from.createDatasetSequence(); + seq1.createDatasetSequence(); + Mapping mapping = new Mapping(seq1, new MapList( + new int[] { 3, 6, 9, 10 }, new int[] { 1, 6 }, 1, 1)); + Map> map = new TreeMap>(); + AlignmentUtils.addMappedPositions(seq1, from, mapping, map); + + /* + * verify map has seq1 residues in columns 3,4,6,7,11,12 + */ + assertEquals(6, map.size()); + assertEquals('A', map.get(3).get(seq1).charValue()); + assertEquals('A', map.get(4).get(seq1).charValue()); + assertEquals('A', map.get(6).get(seq1).charValue()); + assertEquals('T', map.get(7).get(seq1).charValue()); + assertEquals('T', map.get(11).get(seq1).charValue()); + assertEquals('T', map.get(12).get(seq1).charValue()); + + /* + * + */ + } + + /** + * Test case where the mapping 'from' range includes a stop codon which is + * absent in the 'to' range + */ + @Test(groups = { "Functional" }) + public void testAddMappedPositions_withStopCodon() + { + SequenceI from = new Sequence("dna", "ggAA-ATcc-TT-g"); + SequenceI seq1 = new Sequence("cds", "AAATTT"); + from.createDatasetSequence(); + seq1.createDatasetSequence(); + Mapping mapping = new Mapping(seq1, new MapList( + new int[] { 3, 6, 9, 10 }, new int[] { 1, 6 }, 1, 1)); + Map> map = new TreeMap>(); + AlignmentUtils.addMappedPositions(seq1, from, mapping, map); + + /* + * verify map has seq1 residues in columns 3,4,6,7,11,12 + */ + assertEquals(6, map.size()); + assertEquals('A', map.get(3).get(seq1).charValue()); + assertEquals('A', map.get(4).get(seq1).charValue()); + assertEquals('A', map.get(6).get(seq1).charValue()); + assertEquals('T', map.get(7).get(seq1).charValue()); + assertEquals('T', map.get(11).get(seq1).charValue()); + assertEquals('T', map.get(12).get(seq1).charValue()); + } + + /** + * Test for the case where the products for which we want CDS are specified. + * This is to represent the case where EMBL has CDS mappings to both Uniprot + * and EMBLCDSPROTEIN. makeCdsAlignment() should only return the mappings for + * the protein sequences specified. + */ + @Test(groups = { "Functional" }) + public void testMakeCdsAlignment_filterProducts() + { + SequenceI dna1 = new Sequence("dna1", "aaaGGGcccTTTaaa"); + SequenceI dna2 = new Sequence("dna2", "GGGcccTTTaaaCCC"); + SequenceI pep1 = new Sequence("Uniprot|pep1", "GF"); + SequenceI pep2 = new Sequence("Uniprot|pep2", "GFP"); + SequenceI pep3 = new Sequence("EMBL|pep3", "GF"); + SequenceI pep4 = new Sequence("EMBL|pep4", "GFP"); + dna1.createDatasetSequence(); + dna2.createDatasetSequence(); + pep1.createDatasetSequence(); + pep2.createDatasetSequence(); + pep3.createDatasetSequence(); + pep4.createDatasetSequence(); + AlignmentI dna = new Alignment(new SequenceI[] { dna1, dna2 }); + dna.setDataset(null); + AlignmentI emblPeptides = new Alignment(new SequenceI[] { pep3, pep4 }); + emblPeptides.setDataset(null); + + AlignedCodonFrame acf = new AlignedCodonFrame(); + MapList map = new MapList(new int[] { 4, 6, 10, 12 }, + new int[] { 1, 2 }, 3, 1); + acf.addMap(dna1.getDatasetSequence(), pep1.getDatasetSequence(), map); + acf.addMap(dna1.getDatasetSequence(), pep3.getDatasetSequence(), map); + dna.addCodonFrame(acf); + + acf = new AlignedCodonFrame(); + map = new MapList(new int[] { 1, 3, 7, 9, 13, 15 }, new int[] { 1, 3 }, + 3, 1); + acf.addMap(dna2.getDatasetSequence(), pep2.getDatasetSequence(), map); + acf.addMap(dna2.getDatasetSequence(), pep4.getDatasetSequence(), map); + dna.addCodonFrame(acf); + + /* + * execute method under test to find CDS for EMBL peptides only + */ + AlignmentI cds = AlignmentUtils.makeCdsAlignment(new SequenceI[] { + dna1, dna2 }, dna.getDataset(), emblPeptides.getSequencesArray()); + + assertEquals(2, cds.getSequences().size()); + assertEquals("GGGTTT", cds.getSequenceAt(0).getSequenceAsString()); + assertEquals("GGGTTTCCC", cds.getSequenceAt(1).getSequenceAsString()); + + /* + * verify shared, extended alignment dataset + */ + assertSame(dna.getDataset(), cds.getDataset()); + assertTrue(dna.getDataset().getSequences() + .contains(cds.getSequenceAt(0).getDatasetSequence())); + assertTrue(dna.getDataset().getSequences() + .contains(cds.getSequenceAt(1).getDatasetSequence())); + + /* + * Verify mappings from CDS to peptide, cDNA to CDS, and cDNA to peptide + * the mappings are on the shared alignment dataset + */ + List cdsMappings = cds.getDataset().getCodonFrames(); + /* + * 6 mappings, 2*(DNA->CDS), 2*(DNA->Pep), 2*(CDS->Pep) + */ + assertEquals(6, cdsMappings.size()); + + /* + * verify that mapping sets for dna and cds alignments are different + * [not current behaviour - all mappings are on the alignment dataset] + */ + // select -> subselect type to test. + // Assert.assertNotSame(dna.getCodonFrames(), cds.getCodonFrames()); + // assertEquals(4, dna.getCodonFrames().size()); + // assertEquals(4, cds.getCodonFrames().size()); + + /* + * Two mappings involve pep3 (dna to pep3, cds to pep3) + * Mapping from pep3 to GGGTTT in first new exon sequence + */ + List pep3Mappings = MappingUtils + .findMappingsForSequence(pep3, cdsMappings); + assertEquals(2, pep3Mappings.size()); + List mappings = MappingUtils + .findMappingsForSequence(cds.getSequenceAt(0), pep3Mappings); + assertEquals(1, mappings.size()); + + // map G to GGG + SearchResults sr = MappingUtils.buildSearchResults(pep3, 1, mappings); + assertEquals(1, sr.getResults().size()); + Match m = sr.getResults().get(0); + assertSame(cds.getSequenceAt(0).getDatasetSequence(), m.getSequence()); + assertEquals(1, m.getStart()); + assertEquals(3, m.getEnd()); + // map F to TTT + sr = MappingUtils.buildSearchResults(pep3, 2, mappings); + m = sr.getResults().get(0); + assertSame(cds.getSequenceAt(0).getDatasetSequence(), m.getSequence()); + assertEquals(4, m.getStart()); + assertEquals(6, m.getEnd()); + + /* + * Two mappings involve pep4 (dna to pep4, cds to pep4) + * Verify mapping from pep4 to GGGTTTCCC in second new exon sequence + */ + List pep4Mappings = MappingUtils + .findMappingsForSequence(pep4, cdsMappings); + assertEquals(2, pep4Mappings.size()); + mappings = MappingUtils.findMappingsForSequence(cds.getSequenceAt(1), + pep4Mappings); + assertEquals(1, mappings.size()); + // map G to GGG + sr = MappingUtils.buildSearchResults(pep4, 1, mappings); + assertEquals(1, sr.getResults().size()); + m = sr.getResults().get(0); + assertSame(cds.getSequenceAt(1).getDatasetSequence(), m.getSequence()); + assertEquals(1, m.getStart()); + assertEquals(3, m.getEnd()); + // map F to TTT + sr = MappingUtils.buildSearchResults(pep4, 2, mappings); + m = sr.getResults().get(0); + assertSame(cds.getSequenceAt(1).getDatasetSequence(), m.getSequence()); + assertEquals(4, m.getStart()); + assertEquals(6, m.getEnd()); + // map P to CCC + sr = MappingUtils.buildSearchResults(pep4, 3, mappings); + m = sr.getResults().get(0); + assertSame(cds.getSequenceAt(1).getDatasetSequence(), m.getSequence()); + assertEquals(7, m.getStart()); + assertEquals(9, m.getEnd()); + } + + /** + * Test the method that just copies aligned sequences, provided all sequences + * to be aligned share the aligned sequence's dataset + */ + @Test(groups = "Functional") + public void testAlignAsSameSequences() + { + SequenceI dna1 = new Sequence("dna1", "cccGGGTTTaaa"); + SequenceI dna2 = new Sequence("dna2", "CCCgggtttAAA"); + AlignmentI al1 = new Alignment(new SequenceI[] { dna1, dna2 }); + ((Alignment) al1).createDatasetAlignment(); + + SequenceI dna3 = new Sequence(dna1); + SequenceI dna4 = new Sequence(dna2); + assertSame(dna3.getDatasetSequence(), dna1.getDatasetSequence()); + assertSame(dna4.getDatasetSequence(), dna2.getDatasetSequence()); + String seq1 = "-cc-GG-GT-TT--aaa"; + dna3.setSequence(seq1); + String seq2 = "C--C-Cgg--gtt-tAA-A-"; + dna4.setSequence(seq2); + AlignmentI al2 = new Alignment(new SequenceI[] { dna3, dna4 }); + ((Alignment) al2).createDatasetAlignment(); + + assertTrue(AlignmentUtils.alignAsSameSequences(al1, al2)); + assertEquals(seq1, al1.getSequenceAt(0).getSequenceAsString()); + assertEquals(seq2, al1.getSequenceAt(1).getSequenceAsString()); + + /* + * add another sequence to 'aligned' - should still succeed, since + * unaligned sequences still share a dataset with aligned sequences + */ + SequenceI dna5 = new Sequence("dna5", "CCCgggtttAAA"); + dna5.createDatasetSequence(); + al2.addSequence(dna5); + assertTrue(AlignmentUtils.alignAsSameSequences(al1, al2)); + assertEquals(seq1, al1.getSequenceAt(0).getSequenceAsString()); + assertEquals(seq2, al1.getSequenceAt(1).getSequenceAsString()); + + /* + * add another sequence to 'unaligned' - should fail, since now not + * all unaligned sequences share a dataset with aligned sequences + */ + SequenceI dna6 = new Sequence("dna6", "CCCgggtttAAA"); + dna6.createDatasetSequence(); + al1.addSequence(dna6); + // JAL-2110 JBP Comment: what's the use case for this behaviour ? + assertFalse(AlignmentUtils.alignAsSameSequences(al1, al2)); + } + + @Test(groups = "Functional") + public void testAlignAsSameSequencesMultipleSubSeq() + { + SequenceI dna1 = new Sequence("dna1", "cccGGGTTTaaa"); + SequenceI dna2 = new Sequence("dna2", "CCCgggtttAAA"); + SequenceI as1 = dna1.deriveSequence(); + SequenceI as2 = dna1.deriveSequence().getSubSequence(3, 7); + SequenceI as3 = dna2.deriveSequence(); + as1.insertCharAt(6, 5, '-'); + String s_as1 = as1.getSequenceAsString(); + as2.insertCharAt(6, 5, '-'); + String s_as2 = as2.getSequenceAsString(); + as3.insertCharAt(6, 5, '-'); + String s_as3 = as3.getSequenceAsString(); + AlignmentI aligned = new Alignment(new SequenceI[] { as1, as2, as3 }); + + // why do we need to cast this still ? + ((Alignment) aligned).createDatasetAlignment(); + SequenceI uas1 = dna1.deriveSequence(); + SequenceI uas2 = dna1.deriveSequence().getSubSequence(3, 7); + SequenceI uas3 = dna2.deriveSequence(); + AlignmentI tobealigned = new Alignment(new SequenceI[] { uas1, uas2, + uas3 }); + ((Alignment) tobealigned).createDatasetAlignment(); + + assertTrue(AlignmentUtils.alignAsSameSequences(tobealigned, aligned)); + assertEquals(s_as1, uas1.getSequenceAsString()); + assertEquals(s_as2, uas2.getSequenceAsString()); + assertEquals(s_as3, uas3.getSequenceAsString()); + } + }