/* * 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 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.SequenceFeature; 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.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Set; import org.testng.annotations.Test; public class AlignmentUtilsTests { // @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 += 2) { 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++) { 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 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); 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() { 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 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() { 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(); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds1", 4, 6, 0f, null)); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds2", 10, 12, 0f, null)); dna2.addSequenceFeature(new SequenceFeature("CDS", "cds3", 1, 3, 0f, null)); dna2.addSequenceFeature(new SequenceFeature("CDS", "cds4", 7, 9, 0f, null)); dna2.addSequenceFeature(new SequenceFeature("CDS", "cds5", 13, 15, 0f, null)); List mappings = new ArrayList(); 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 cds = AlignmentUtils.makeCdsAlignment(new SequenceI[] { dna1, dna2 }, mappings, '-'); assertEquals(2, cds.getSequences().size()); assertEquals("---GGG---TTT---", cds.getSequenceAt(0) .getSequenceAsString()); assertEquals("GGG---TTT---CCC", cds.getSequenceAt(1) .getSequenceAsString()); /* * Verify updated mappings */ 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); assertSame(cds.getSequenceAt(0).getDatasetSequence(), m.getSequence()); assertEquals(1, m.getStart()); assertEquals(3, m.getEnd()); // map F to TTT sr = MappingUtils.buildSearchResults(pep1, 2, mappings); m = sr.getResults().get(0); assertSame(cds.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); assertSame(cds.getSequenceAt(1).getDatasetSequence(), m.getSequence()); assertEquals(1, m.getStart()); assertEquals(3, m.getEnd()); // map F to TTT sr = MappingUtils.buildSearchResults(pep2, 2, mappings); m = sr.getResults().get(0); assertSame(cds.getSequenceAt(1).getDatasetSequence(), m.getSequence()); assertEquals(4, m.getStart()); assertEquals(6, m.getEnd()); // map P to CCC sr = MappingUtils.buildSearchResults(pep2, 3, mappings); m = sr.getResults().get(0); assertSame(cds.getSequenceAt(1).getDatasetSequence(), m.getSequence()); assertEquals(7, m.getStart()); assertEquals(9, m.getEnd()); } /** * Test the method that makes a cds-only sequence from a DNA sequence and its * product mapping. Test includes the expected case that the DNA sequence * already has a protein product (Uniprot translation) which in turn has an * x-ref to the EMBLCDS record. */ @Test(groups = { "Functional" }) public void testMakeCdsSequences() { 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 ungappedColumns = new ArrayList(); ungappedColumns.add(new int[] { 4, 6 }); ungappedColumns.add(new int[] { 10, 12 }); List cdsSeqs = AlignmentUtils.makeCdsSequences(dna1, acf, ungappedColumns, newMapping, '-'); assertEquals(1, cdsSeqs.size()); SequenceI cdsSeq = cdsSeqs.get(0); assertEquals("GGGTTT", cdsSeq.getSequenceAsString()); assertEquals("dna1|A12345", cdsSeq.getName()); assertEquals(1, cdsSeq.getDBRefs().length); DBRefEntry cdsRef = cdsSeq.getDBRefs()[0]; assertEquals("EMBLCDS", cdsRef.getSource()); assertEquals("2", cdsRef.getVersion()); assertEquals("A12345", cdsRef.getAccessionId()); } /** * Test the method that makes 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(); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds1", 4, 6, 0f, null)); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds2", 10, 12, 0f, null)); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds3", 1, 3, 0f, null)); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds4", 7, 9, 0f, null)); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds5", 1, 3, 0f, null)); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds6", 10, 12, 0f, null)); pep1.getDatasetSequence().addDBRef( new DBRefEntry("EMBLCDS", "2", "A12345")); pep2.getDatasetSequence().addDBRef( new DBRefEntry("EMBLCDS", "3", "A12346")); pep3.getDatasetSequence().addDBRef( new DBRefEntry("EMBLCDS", "4", "A12347")); /* * Make the mappings from dna to protein */ List mappings = new ArrayList(); // 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.makeCdsAlignment( new SequenceI[] { dna1 }, mappings, '-'); /* * Verify we have 3 cds sequences, mapped to pep1/2/3 respectively */ List cds = exal.getSequences(); assertEquals(3, cds.size()); SequenceI cdsSeq = cds.get(0); assertEquals("---GGG---TTT", cdsSeq.getSequenceAsString()); assertEquals("dna1|A12345", cdsSeq.getName()); assertEquals(1, cdsSeq.getDBRefs().length); DBRefEntry cdsRef = cdsSeq.getDBRefs()[0]; assertEquals("EMBLCDS", cdsRef.getSource()); assertEquals("2", cdsRef.getVersion()); assertEquals("A12345", cdsRef.getAccessionId()); cdsSeq = cds.get(1); assertEquals("aaa---ccc---", cdsSeq.getSequenceAsString()); assertEquals("dna1|A12346", cdsSeq.getName()); assertEquals(1, cdsSeq.getDBRefs().length); cdsRef = cdsSeq.getDBRefs()[0]; assertEquals("EMBLCDS", cdsRef.getSource()); assertEquals("3", cdsRef.getVersion()); assertEquals("A12346", cdsRef.getAccessionId()); cdsSeq = cds.get(2); assertEquals("aaa------TTT", cdsSeq.getSequenceAsString()); assertEquals("dna1|A12347", cdsSeq.getName()); assertEquals(1, cdsSeq.getDBRefs().length); cdsRef = cdsSeq.getDBRefs()[0]; assertEquals("EMBLCDS", cdsRef.getSource()); assertEquals("4", cdsRef.getVersion()); assertEquals("A12347", cdsRef.getAccessionId()); /* * Verify there are mappings from each cds sequence to its protein product * and also to its dna source */ Iterator newMappingsIterator = mappings.iterator(); // mappings for dna1 - exon1 - pep1 AlignedCodonFrame cdsMapping = newMappingsIterator.next(); List dnaMappings = cdsMapping.getMappingsForSequence(dna1); assertEquals(1, dnaMappings.size()); assertSame(cds.get(0).getDatasetSequence(), dnaMappings.get(0) .getTo()); assertEquals("G(1) in CDS should map to G(4) in DNA", 4, dnaMappings .get(0).getMap().getToPosition(1)); List peptideMappings = cdsMapping .getMappingsForSequence(pep1); assertEquals(1, peptideMappings.size()); assertSame(pep1.getDatasetSequence(), peptideMappings.get(0).getTo()); // mappings for dna1 - cds2 - pep2 cdsMapping = newMappingsIterator.next(); dnaMappings = cdsMapping.getMappingsForSequence(dna1); assertEquals(1, dnaMappings.size()); assertSame(cds.get(1).getDatasetSequence(), dnaMappings.get(0) .getTo()); assertEquals("c(4) in CDS should map to c(7) in DNA", 7, dnaMappings .get(0).getMap().getToPosition(4)); peptideMappings = cdsMapping.getMappingsForSequence(pep2); assertEquals(1, peptideMappings.size()); assertSame(pep2.getDatasetSequence(), peptideMappings.get(0).getTo()); // mappings for dna1 - cds3 - pep3 cdsMapping = newMappingsIterator.next(); dnaMappings = cdsMapping.getMappingsForSequence(dna1); assertEquals(1, dnaMappings.size()); assertSame(cds.get(2).getDatasetSequence(), dnaMappings.get(0) .getTo()); assertEquals("T(4) in CDS should map to T(10) in DNA", 10, dnaMappings .get(0).getMap().getToPosition(4)); peptideMappings = cdsMapping.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)); } /** * Test creating a mapping when the sequences involved do not start at residue * 1 * * @throws IOException */ @Test(groups = { "Functional" }) public void testMapProteinSequenceToCdna_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.mapProteinSequenceToCdna(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(); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds1", 4, 8, 0f, null)); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds2", 9, 12, 0f, null)); dna1.addSequenceFeature(new SequenceFeature("CDS", "cds3", 16, 18, 0f, null)); dna2.addSequenceFeature(new SequenceFeature("CDS", "cds", 4, 8, 0f, null)); dna2.addSequenceFeature(new SequenceFeature("CDS", "cds", 12, 12, 0f, null)); dna2.addSequenceFeature(new SequenceFeature("CDS", "cds", 16, 18, 0f, null)); List mappings = new ArrayList(); MapList map = new MapList(new int[] { 4, 12, 16, 18 }, new int[] { 1, 4 }, 3, 1); AlignedCodonFrame acf = new AlignedCodonFrame(); acf.addMap(dna1.getDatasetSequence(), pep1.getDatasetSequence(), map); mappings.add(acf); map = new MapList(new int[] { 4, 8, 12, 12, 16, 18 }, new int[] { 1, 3 }, 3, 1); acf = new AlignedCodonFrame(); acf.addMap(dna2.getDatasetSequence(), pep2.getDatasetSequence(), map); mappings.add(acf); AlignmentI cds = AlignmentUtils.makeCdsAlignment(new SequenceI[] { dna1, dna2, dna3 }, mappings, '-'); assertEquals(2, cds.getSequences().size()); assertEquals("GGGCCCTTTGGG", cds.getSequenceAt(0).getSequenceAsString()); assertEquals("GGGCC---TGGG", cds.getSequenceAt(1).getSequenceAsString()); /* * Verify updated mappings */ assertEquals(2, mappings.size()); /* * Mapping from pep1 to GGGTTT in first new CDS sequence */ List pep1Mapping = MappingUtils .findMappingsForSequence(pep1, mappings); assertEquals(1, pep1Mapping.size()); /* * maps GPFG to 1-3,4-6,7-9,10-12 */ SearchResults sr = MappingUtils.buildSearchResults(pep1, 1, mappings); assertEquals(1, sr.getResults().size()); Match m = sr.getResults().get(0); assertEquals(cds.getSequenceAt(0).getDatasetSequence(), m.getSequence()); assertEquals(1, m.getStart()); assertEquals(3, m.getEnd()); sr = MappingUtils.buildSearchResults(pep1, 2, mappings); m = sr.getResults().get(0); assertEquals(4, m.getStart()); assertEquals(6, m.getEnd()); sr = MappingUtils.buildSearchResults(pep1, 3, mappings); m = sr.getResults().get(0); assertEquals(7, m.getStart()); assertEquals(9, m.getEnd()); sr = MappingUtils.buildSearchResults(pep1, 4, mappings); m = sr.getResults().get(0); assertEquals(10, m.getStart()); assertEquals(12, m.getEnd()); /* * GPG in pep2 map to 1-3,4-6,7-9 in second CDS sequence */ List pep2Mapping = MappingUtils .findMappingsForSequence(pep2, mappings); assertEquals(1, pep2Mapping.size()); sr = MappingUtils.buildSearchResults(pep2, 1, mappings); assertEquals(1, sr.getResults().size()); m = sr.getResults().get(0); assertEquals(cds.getSequenceAt(1).getDatasetSequence(), m.getSequence()); assertEquals(1, m.getStart()); assertEquals(3, m.getEnd()); sr = MappingUtils.buildSearchResults(pep2, 2, mappings); m = sr.getResults().get(0); assertEquals(4, m.getStart()); assertEquals(6, m.getEnd()); sr = MappingUtils.buildSearchResults(pep2, 3, mappings); m = sr.getResults().get(0); assertEquals(7, m.getStart()); assertEquals(9, m.getEnd()); } /** * Tests for gapped column in sequences */ @Test(groups = { "Functional" }) public void testIsGappedColumn() { SequenceI seq1 = new Sequence("Seq1", "a--c.tc-a-g"); SequenceI seq2 = new Sequence("Seq2", "aa---t--a-g"); SequenceI seq3 = new Sequence("Seq3", "ag-c t-g-"); List seqs = Arrays .asList(new SequenceI[] { seq1, seq2, seq3 }); // the column number is base 1 assertFalse(AlignmentUtils.isGappedColumn(seqs, 1)); assertFalse(AlignmentUtils.isGappedColumn(seqs, 2)); assertTrue(AlignmentUtils.isGappedColumn(seqs, 3)); assertFalse(AlignmentUtils.isGappedColumn(seqs, 4)); assertTrue(AlignmentUtils.isGappedColumn(seqs, 5)); assertFalse(AlignmentUtils.isGappedColumn(seqs, 6)); assertFalse(AlignmentUtils.isGappedColumn(seqs, 7)); assertFalse(AlignmentUtils.isGappedColumn(seqs, 8)); assertFalse(AlignmentUtils.isGappedColumn(seqs, 9)); assertTrue(AlignmentUtils.isGappedColumn(seqs, 10)); assertFalse(AlignmentUtils.isGappedColumn(seqs, 11)); // out of bounds: assertTrue(AlignmentUtils.isGappedColumn(seqs, 0)); assertTrue(AlignmentUtils.isGappedColumn(seqs, 100)); assertTrue(AlignmentUtils.isGappedColumn(seqs, -100)); assertTrue(AlignmentUtils.isGappedColumn(null, 0)); } @Test(groups = { "Functional" }) public void testFindCdsColumns() { // TODO target method belongs in a general-purpose alignment // analysis method to find columns for feature /* * NB this method assumes CDS ranges are contiguous (no introns) */ SequenceI gene = new Sequence("gene", "aaacccgggtttaaacccgggttt"); SequenceI seq1 = new Sequence("Seq1", "--ac-cgGG-GGaaACC--GGtt-"); SequenceI seq2 = new Sequence("Seq2", "AA--CCGG--g-AAA--cG-GTTt"); seq1.createDatasetSequence(); seq2.createDatasetSequence(); seq1.addSequenceFeature(new SequenceFeature("CDS", "cds", 5, 6, 0f, null)); seq1.addSequenceFeature(new SequenceFeature("CDS", "cds", 7, 8, 0f, null)); seq1.addSequenceFeature(new SequenceFeature("CDS", "cds", 11, 13, 0f, null)); seq1.addSequenceFeature(new SequenceFeature("CDS", "cds", 14, 15, 0f, null)); seq2.addSequenceFeature(new SequenceFeature("CDS", "cds", 1, 2, 0f, null)); seq2.addSequenceFeature(new SequenceFeature("CDS", "cds", 3, 6, 0f, null)); seq2.addSequenceFeature(new SequenceFeature("CDS", "cds", 8, 10, 0f, null)); seq2.addSequenceFeature(new SequenceFeature("CDS", "cds", 12, 12, 0f, null)); seq2.addSequenceFeature(new SequenceFeature("CDS", "cds", 13, 15, 0f, null)); List cdsColumns = AlignmentUtils.findCdsColumns(new SequenceI[] { seq1, seq2 }); assertEquals(4, cdsColumns.size()); assertEquals("[1, 2]", Arrays.toString(cdsColumns.get(0))); assertEquals("[5, 9]", Arrays.toString(cdsColumns.get(1))); assertEquals("[11, 17]", Arrays.toString(cdsColumns.get(2))); assertEquals("[19, 23]", Arrays.toString(cdsColumns.get(3))); } }