X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fanalysis%2FAlignmentUtilsTests.java;h=75cc18b40c086c314e902eb93323358124b4122e;hb=17e77c3f2949a0729322b4a8d907f3f34b6a9914;hp=bba21c3e7487a9631f48ea517722fea4d3b85ba1;hpb=ad15cff29620f960119f80176f1fd443da9f6763;p=jalview.git diff --git a/test/jalview/analysis/AlignmentUtilsTests.java b/test/jalview/analysis/AlignmentUtilsTests.java index bba21c3..75cc18b 100644 --- a/test/jalview/analysis/AlignmentUtilsTests.java +++ b/test/jalview/analysis/AlignmentUtilsTests.java @@ -1,6 +1,6 @@ /* - * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) - * Copyright (C) $$Year-Rel$$ The Jalview Authors + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9) + * Copyright (C) 2015 The Jalview Authors * * This file is part of Jalview. * @@ -20,41 +20,1263 @@ */ package jalview.analysis; -import static org.junit.Assert.assertTrue; - -import org.junit.Test; +import static org.testng.AssertJUnit.assertEquals; +import static org.testng.AssertJUnit.assertFalse; +import static org.testng.AssertJUnit.assertNull; +import static org.testng.AssertJUnit.assertSame; +import static org.testng.AssertJUnit.assertTrue; +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.SequenceI; import jalview.io.AppletFormatAdapter; +import jalview.io.FormatAdapter; +import jalview.util.MapList; +import jalview.util.MappingUtils; + +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; + +import org.testng.annotations.Test; -public class AlignmentUtilsTests +public class AlignmentUtilsTests { - public static Sequence ts=new Sequence("short","ASDASDASDASDASDASDASDASDASDASDASDASDASD"); - @Test - public void testExpandFlanks() + // @formatter:off + private static final String TEST_DATA = + "# STOCKHOLM 1.0\n" + + "#=GS D.melanogaster.1 AC AY119185.1/838-902\n" + + "#=GS D.melanogaster.2 AC AC092237.1/57223-57161\n" + + "#=GS D.melanogaster.3 AC AY060611.1/560-627\n" + + "D.melanogaster.1 G.AGCC.CU...AUGAUCGA\n" + + "#=GR D.melanogaster.1 SS ................((((\n" + + "D.melanogaster.2 C.AUUCAACU.UAUGAGGAU\n" + + "#=GR D.melanogaster.2 SS ................((((\n" + + "D.melanogaster.3 G.UGGCGCU..UAUGACGCA\n" + + "#=GR D.melanogaster.3 SS (.(((...(....(((((((\n" + + "//"; + + private static final String AA_SEQS_1 = + ">Seq1Name\n" + + "K-QY--L\n" + + ">Seq2Name\n" + + "-R-FP-W-\n"; + + private static final String CDNA_SEQS_1 = + ">Seq1Name\n" + + "AC-GG--CUC-CAA-CT\n" + + ">Seq2Name\n" + + "-CG-TTA--ACG---AAGT\n"; + + private static final String CDNA_SEQS_2 = + ">Seq1Name\n" + + "GCTCGUCGTACT\n" + + ">Seq2Name\n" + + "GGGTCAGGCAGT\n"; + // @formatter:on + + // public static Sequence ts=new + // Sequence("short","ASDASDASDASDASDASDASDASDASDASDASDASDASD"); + 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++) { - AlignmentI exp; - System.out.println("\nFlank size: "+flnk); - System.out.println(new AppletFormatAdapter().formatSequences("Clustal", exp=AlignmentUtils.expandContext(al, flnk), true)); - if (flnk==-1) { - for (SequenceI sq:exp.getSequences()) + 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("-+", ""); - assertTrue("Flanking sequence not the same as original dataset sequence.\n"+ung+"\n"+sq.getDatasetSequence().getSequenceAsString(),ung.equalsIgnoreCase(sq.getDatasetSequence().getSequenceAsString())); + 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 testMapProteinToCdna_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.mapProteinToCdna(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); + + /* + * Expect alignment does nothing (aborts realignment). Change this test + * first if different behaviour wanted. + */ + checkAlignSequenceAs("GGGAAACCCTTTGGG", "-A-L-P-", false, false, map, + "GGGAAACCCTTTGGG"); + } + + /** + * Helper method that performs and verifies the method under test. + * + * @param dnaSeq + * @param proteinSeq + * @param preserveMappedGaps + * @param preserveUnmappedGaps + * @param map + * @param expected + */ + protected void checkAlignSequenceAs(final String dnaSeq, + final String proteinSeq, 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(); + AlignedCodonFrame acf = new AlignedCodonFrame(); + acf.addMap(dna.getDatasetSequence(), protein.getDatasetSequence(), map); + + AlignmentUtils.alignSequenceAs(dna, protein, acf, "---", '-', + preserveMappedGaps, preserveUnmappedGaps); + assertEquals(expected, dna.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 for the method that generates an aligned translated sequence from one + * mapping. + */ + @Test(groups = { "Functional" }) + public void testGetAlignedTranslation_dnaLikeProtein() + { + // dna alignment will be replaced + SequenceI dna = new Sequence("Seq1", "T-G-CC-A--T-TAC-CAG-"); + dna.createDatasetSequence(); + // protein alignment will be 'applied' to dna + SequenceI protein = new Sequence("Seq1", "-CH-Y--Q-"); + protein.createDatasetSequence(); + MapList map = new MapList(new int[] { 1, 12 }, new int[] { 1, 4 }, 3, 1); + AlignedCodonFrame acf = new AlignedCodonFrame(); + acf.addMap(dna.getDatasetSequence(), protein.getDatasetSequence(), map); + + final SequenceI aligned = AlignmentUtils.getAlignedTranslation(protein, + '-', acf); + assertEquals("---TGCCAT---TAC------CAG---", + aligned.getSequenceAsString()); + assertSame(aligned.getDatasetSequence(), dna.getDatasetSequence()); + } + + /** + * 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); + protein.setCodonFrames(Collections.singleton(acf)); + + /* + * 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() + { + assertTrue(AlignmentUtils.translatesAs("tttcccaaaggg".toCharArray(), 0, + "FPKG".toCharArray())); + // with 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 codon + assertTrue(AlignmentUtils.translatesAs( + "atgtttTAGcccaaaTAAgggtga".toCharArray(), 3, + "F*PK*G".toCharArray())); + + // wrong protein + assertFalse(AlignmentUtils.translatesAs("tttcccaaaggg".toCharArray(), + 0, "FPMG".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 testMapProteinToCdna_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.mapProteinToCdna(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 testMapProteinToCdna_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.mapProteinToCdna(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 testMapProteinToCdna_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.mapProteinToCdna(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.setDBRef(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 exon-only part of a dna alignment. + */ + @Test(groups = { "Functional" }) + public void testMakeExonAlignment() + { + SequenceI dna1 = new Sequence("dna1", "aaaGGGcccTTTaaa"); + SequenceI dna2 = new Sequence("dna2", "GGGcccTTTaaaCCC"); + SequenceI pep1 = new Sequence("pep1", "GF"); + SequenceI pep2 = new Sequence("pep2", "GFP"); + dna1.createDatasetSequence(); + dna2.createDatasetSequence(); + pep1.createDatasetSequence(); + pep2.createDatasetSequence(); + + Set mappings = new HashSet(); + 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); + mappings.add(acf); + map = 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(), 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()); + + /* + * Verify updated mappings + */ + assertEquals(2, mappings.size()); + + /* + * Mapping from pep1 to GGGTTT in first new exon sequence + */ + List pep1Mapping = MappingUtils + .findMappingsForSequence(pep1, mappings); + assertEquals(1, pep1Mapping.size()); + // map G to GGG + SearchResults sr = MappingUtils.buildSearchResults(pep1, 1, mappings); + assertEquals(1, sr.getResults().size()); + Match m = sr.getResults().get(0); + assertEquals(exons.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(), + m.getSequence()); + assertEquals(4, m.getStart()); + assertEquals(6, m.getEnd()); + + /* + * Mapping from pep2 to GGGTTTCCC in second new exon sequence + */ + List pep2Mapping = MappingUtils + .findMappingsForSequence(pep2, mappings); + assertEquals(1, pep2Mapping.size()); + // map G to GGG + sr = MappingUtils.buildSearchResults(pep2, 1, mappings); + assertEquals(1, sr.getResults().size()); + m = sr.getResults().get(0); + assertEquals(exons.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(), + 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(), + 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 + * already has a protein product (Uniprot translation) which in turn has an + * x-ref to the EMBLCDS record. + */ + @Test(groups = { "Functional" }) + public void testMakeExonSequences() + { + SequenceI dna1 = new Sequence("dna1", "aaaGGGcccTTTaaa"); + SequenceI pep1 = new Sequence("pep1", "GF"); + dna1.createDatasetSequence(); + pep1.createDatasetSequence(); + pep1.getDatasetSequence().addDBRef( + new DBRefEntry("EMBLCDS", "2", "A12345")); + + /* + * Make the mapping from dna to protein. The protein sequence has a DBRef to + * EMBLCDS|A12345. + */ + Set mappings = new HashSet(); + 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); + mappings.add(acf); + + AlignedCodonFrame newMapping = new AlignedCodonFrame(); + List 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.getDBRef().length); + DBRefEntry cdsRef = exon.getDBRef()[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(groups = { "Functional" }) + public void testMakeExonAlignment_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")); + + /* + * 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. + */ + Set mappings = new LinkedHashSet(); + // 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); + mappings.add(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); + mappings.add(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); + mappings.add(acf); + + /* + * 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); + + /* + * Verify we have 3 exon sequences, mapped to pep1/2/3 respectively + */ + List exons = exal.getSequences(); + assertEquals(3, exons.size()); + + SequenceI exon = exons.get(0); + assertEquals("GGGTTT", exon.getSequenceAsString()); + assertEquals("dna1|A12345", exon.getName()); + assertEquals(1, exon.getDBRef().length); + DBRefEntry cdsRef = exon.getDBRef()[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.getDBRef().length); + cdsRef = exon.getDBRef()[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.getDBRef().length); + cdsRef = exon.getDBRef()[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 + * and also to its dna source + */ + Iterator newMappingsIterator = mappings.iterator(); + + // mappings for dna1 - exon1 - pep1 + AlignedCodonFrame exonMapping = newMappingsIterator.next(); + List dnaMappings = exonMapping.getMappingsForSequence(dna1); + assertEquals(1, dnaMappings.size()); + assertSame(exons.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 peptideMappings = exonMapping + .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); + assertEquals(1, dnaMappings.size()); + assertSame(exons.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); + assertEquals(1, peptideMappings.size()); + assertSame(pep2.getDatasetSequence(), peptideMappings.get(0).getTo()); + + // mappings for dna1 - exon3 - pep3 + exonMapping = newMappingsIterator.next(); + dnaMappings = exonMapping.getMappingsForSequence(dna1); + assertEquals(1, dnaMappings.size()); + assertSame(exons.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); + assertEquals(1, peptideMappings.size()); + assertSame(pep3.getDatasetSequence(), peptideMappings.get(0).getTo()); + } + + @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)); } }