test/jalview/util/MappingUtilsTest.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.util;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertSame;
  25 import static org.testng.AssertJUnit.assertTrue;
  26
  27 import jalview.api.AlignViewportI;
  28 import jalview.commands.EditCommand;
  29 import jalview.commands.EditCommand.Action;
  30 import jalview.commands.EditCommand.Edit;
  31 import jalview.datamodel.AlignedCodonFrame;
  32 import jalview.datamodel.Alignment;
  33 import jalview.datamodel.AlignmentI;
  34 import jalview.datamodel.ColumnSelection;
  35 import jalview.datamodel.SearchResults;
  36 import jalview.datamodel.SearchResults.Match;
  37 import jalview.datamodel.Sequence;
  38 import jalview.datamodel.SequenceGroup;
  39 import jalview.datamodel.SequenceI;
  40 import jalview.gui.AlignViewport;
  41 import jalview.io.AppletFormatAdapter;
  42 import jalview.io.FormatAdapter;
  43
  44 import java.awt.Color;
  45 import java.io.IOException;
  46 import java.util.ArrayList;
  47 import java.util.Arrays;
  48 import java.util.List;
  49
  50 import org.testng.annotations.Test;
  51
  52 public class MappingUtilsTest
  53 {
  54   private AlignViewportI dnaView;
  55
  56   private AlignViewportI proteinView;
  57
  58   /**
  59    * Simple test of mapping with no intron involved.
  60    */
  61   @Test(groups = { "Functional" })
  62   public void testBuildSearchResults()
  63   {
  64     final Sequence seq1 = new Sequence("Seq1/5-10", "C-G-TA-GC");
  65     seq1.createDatasetSequence();
  66
  67     final Sequence aseq1 = new Sequence("Seq1/12-13", "-P-R");
  68     aseq1.createDatasetSequence();
  69
  70     /*
  71      * Map dna bases 5-10 to protein residues 12-13
  72      */
  73     AlignedCodonFrame acf = new AlignedCodonFrame();
  74     MapList map = new MapList(new int[] { 5, 10 }, new int[] { 12, 13 }, 3,
  75             1);
  76     acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map);
  77     List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[]
  78     { acf });
  79
  80     /*
  81      * Check protein residue 12 maps to codon 5-7, 13 to codon 8-10
  82      */
  83     SearchResults sr = MappingUtils.buildSearchResults(aseq1, 12, acfList);
  84     assertEquals(1, sr.getResults().size());
  85     Match m = sr.getResults().get(0);
  86     assertEquals(seq1.getDatasetSequence(), m.getSequence());
  87     assertEquals(5, m.getStart());
  88     assertEquals(7, m.getEnd());
  89     sr = MappingUtils.buildSearchResults(aseq1, 13, acfList);
  90     assertEquals(1, sr.getResults().size());
  91     m = sr.getResults().get(0);
  92     assertEquals(seq1.getDatasetSequence(), m.getSequence());
  93     assertEquals(8, m.getStart());
  94     assertEquals(10, m.getEnd());
  95
  96     /*
  97      * Check inverse mappings, from codons 5-7, 8-10 to protein 12, 13
  98      */
  99     for (int i = 5; i < 11; i++)
 100     {
 101       sr = MappingUtils.buildSearchResults(seq1, i, acfList);
 102       assertEquals(1, sr.getResults().size());
 103       m = sr.getResults().get(0);
 104       assertEquals(aseq1.getDatasetSequence(), m.getSequence());
 105       int residue = i > 7 ? 13 : 12;
 106       assertEquals(residue, m.getStart());
 107       assertEquals(residue, m.getEnd());
 108     }
 109   }
 110
 111   /**
 112    * Simple test of mapping with introns involved.
 113    */
 114   @Test(groups = { "Functional" })
 115   public void testBuildSearchResults_withIntron()
 116   {
 117     final Sequence seq1 = new Sequence("Seq1/5-17", "c-G-tAGa-GcAgCtt");
 118     seq1.createDatasetSequence();
 119
 120     final Sequence aseq1 = new Sequence("Seq1/8-9", "-E-D");
 121     aseq1.createDatasetSequence();
 122
 123     /*
 124      * Map dna bases [6, 8, 9], [11, 13, 115] to protein residues 8 and 9
 125      */
 126     AlignedCodonFrame acf = new AlignedCodonFrame();
 127     MapList map = new MapList(new int[] { 6, 6, 8, 9, 11, 11, 13, 13, 15,
 128         15 }, new int[] { 8, 9 }, 3, 1);
 129     acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map);
 130     List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[]
 131     { acf });
 132
 133     /*
 134      * Check protein residue 8 maps to [6, 8, 9]
 135      */
 136     SearchResults sr = MappingUtils.buildSearchResults(aseq1, 8, acfList);
 137     assertEquals(2, sr.getResults().size());
 138     Match m = sr.getResults().get(0);
 139     assertEquals(seq1.getDatasetSequence(), m.getSequence());
 140     assertEquals(6, m.getStart());
 141     assertEquals(6, m.getEnd());
 142     m = sr.getResults().get(1);
 143     assertEquals(seq1.getDatasetSequence(), m.getSequence());
 144     assertEquals(8, m.getStart());
 145     assertEquals(9, m.getEnd());
 146
 147     /*
 148      * Check protein residue 9 maps to [11, 13, 15]
 149      */
 150     sr = MappingUtils.buildSearchResults(aseq1, 9, acfList);
 151     assertEquals(3, sr.getResults().size());
 152     m = sr.getResults().get(0);
 153     assertEquals(seq1.getDatasetSequence(), m.getSequence());
 154     assertEquals(11, m.getStart());
 155     assertEquals(11, m.getEnd());
 156     m = sr.getResults().get(1);
 157     assertEquals(seq1.getDatasetSequence(), m.getSequence());
 158     assertEquals(13, m.getStart());
 159     assertEquals(13, m.getEnd());
 160     m = sr.getResults().get(2);
 161     assertEquals(seq1.getDatasetSequence(), m.getSequence());
 162     assertEquals(15, m.getStart());
 163     assertEquals(15, m.getEnd());
 164
 165     /*
 166      * Check inverse mappings, from codons to protein
 167      */
 168     for (int i = 5; i < 18; i++)
 169     {
 170       sr = MappingUtils.buildSearchResults(seq1, i, acfList);
 171       int residue = (i == 6 || i == 8 || i == 9) ? 8 : (i == 11 || i == 13
 172               || i == 15 ? 9 : 0);
 173       if (residue == 0)
 174       {
 175         assertEquals(0, sr.getResults().size());
 176         continue;
 177       }
 178       assertEquals(1, sr.getResults().size());
 179       m = sr.getResults().get(0);
 180       assertEquals(aseq1.getDatasetSequence(), m.getSequence());
 181       assertEquals(residue, m.getStart());
 182       assertEquals(residue, m.getEnd());
 183     }
 184   }
 185
 186   /**
 187    * Test mapping a sequence group made of entire sequences.
 188    *
 189    * @throws IOException
 190    */
 191   @Test(groups = { "Functional" })
 192   public void testMapSequenceGroup_sequences() throws IOException
 193   {
 194     /*
 195      * Set up dna and protein Seq1/2/3 with mappings (held on the protein
 196      * viewport).
 197      */
 198     AlignmentI cdna = loadAlignment(">Seq1\nACG\n>Seq2\nTGA\n>Seq3\nTAC\n",
 199             "FASTA");
 200     cdna.setDataset(null);
 201     AlignmentI protein = loadAlignment(">Seq1\nK\n>Seq2\nL\n>Seq3\nQ\n",
 202             "FASTA");
 203     protein.setDataset(null);
 204     AlignedCodonFrame acf = new AlignedCodonFrame();
 205     MapList map = new MapList(new int[] { 1, 3 }, new int[] { 1, 1 }, 3, 1);
 206     for (int seq = 0; seq < 3; seq++)
 207     {
 208       acf.addMap(cdna.getSequenceAt(seq).getDatasetSequence(), protein
 209               .getSequenceAt(seq).getDatasetSequence(), map);
 210     }
 211     List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[]
 212     { acf });
 213
 214     AlignViewportI dnaView = new AlignViewport(cdna);
 215     AlignViewportI proteinView = new AlignViewport(protein);
 216     protein.setCodonFrames(acfList);
 217
 218     /*
 219      * Select Seq1 and Seq3 in the protein (startRes=endRes=0)
 220      */
 221     SequenceGroup sg = new SequenceGroup();
 222     sg.setColourText(true);
 223     sg.setIdColour(Color.GREEN);
 224     sg.setOutlineColour(Color.LIGHT_GRAY);
 225     sg.addSequence(protein.getSequenceAt(0), false);
 226     sg.addSequence(protein.getSequenceAt(2), false);
 227
 228     /*
 229      * Verify the mapped sequence group in dna
 230      */
 231     SequenceGroup mappedGroup = MappingUtils.mapSequenceGroup(sg,
 232             proteinView, dnaView);
 233     assertTrue(mappedGroup.getColourText());
 234     assertSame(sg.getIdColour(), mappedGroup.getIdColour());
 235     assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour());
 236     assertEquals(2, mappedGroup.getSequences().size());
 237     assertSame(cdna.getSequenceAt(0), mappedGroup.getSequences().get(0));
 238     assertSame(cdna.getSequenceAt(2), mappedGroup.getSequences().get(1));
 239     assertEquals(0, mappedGroup.getStartRes());
 240     assertEquals(2, mappedGroup.getEndRes());
 241
 242     /*
 243      * Verify mapping sequence group from dna to protein
 244      */
 245     sg.clear();
 246     sg.addSequence(cdna.getSequenceAt(1), false);
 247     sg.addSequence(cdna.getSequenceAt(0), false);
 248     sg.setStartRes(0);
 249     sg.setEndRes(2);
 250     mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView);
 251     assertTrue(mappedGroup.getColourText());
 252     assertSame(sg.getIdColour(), mappedGroup.getIdColour());
 253     assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour());
 254     assertEquals(2, mappedGroup.getSequences().size());
 255     assertSame(protein.getSequenceAt(1), mappedGroup.getSequences().get(0));
 256     assertSame(protein.getSequenceAt(0), mappedGroup.getSequences().get(1));
 257     assertEquals(0, mappedGroup.getStartRes());
 258     assertEquals(0, mappedGroup.getEndRes());
 259   }
 260
 261   /**
 262    * Helper method to load an alignment and ensure dataset sequences are set up.
 263    *
 264    * @param data
 265    * @param format
 266    *          TODO
 267    * @return
 268    * @throws IOException
 269    */
 270   protected AlignmentI loadAlignment(final String data, String format)
 271           throws IOException
 272   {
 273     AlignmentI a = new FormatAdapter().readFile(data,
 274             AppletFormatAdapter.PASTE, format);
 275     a.setDataset(null);
 276     return a;
 277   }
 278
 279   /**
 280    * Test mapping a column selection in protein to its dna equivalent
 281    *
 282    * @throws IOException
 283    */
 284   @Test(groups = { "Functional" })
 285   public void testMapColumnSelection_proteinToDna() throws IOException
 286   {
 287     setupMappedAlignments();
 288
 289     ColumnSelection colsel = new ColumnSelection();
 290
 291     /*
 292      * Column 0 in protein picks up Seq2/L, Seq3/G which map to cols 0-4 and 0-3
 293      * in dna respectively, overall 0-4
 294      */
 295     colsel.addElement(0);
 296     ColumnSelection cs = MappingUtils.mapColumnSelection(colsel,
 297             proteinView, dnaView);
 298     assertEquals("[0, 1, 2, 3, 4]", cs.getSelected().toString());
 299
 300     /*
 301      * Column 1 in protein picks up Seq1/K which maps to cols 0-3 in dna
 302      */
 303     colsel.clear();
 304     colsel.addElement(1);
 305     cs = MappingUtils.mapColumnSelection(colsel, proteinView, dnaView);
 306     assertEquals("[0, 1, 2, 3]", cs.getSelected().toString());
 307
 308     /*
 309      * Column 2 in protein picks up gaps only - no mapping
 310      */
 311     colsel.clear();
 312     colsel.addElement(2);
 313     cs = MappingUtils.mapColumnSelection(colsel, proteinView, dnaView);
 314     assertEquals("[]", cs.getSelected().toString());
 315
 316     /*
 317      * Column 3 in protein picks up Seq1/P, Seq2/Q, Seq3/S which map to columns
 318      * 6-9, 6-10, 5-8 respectively, overall to 5-10
 319      */
 320     colsel.clear();
 321     colsel.addElement(3);
 322     cs = MappingUtils.mapColumnSelection(colsel, proteinView, dnaView);
 323     assertEquals("[5, 6, 7, 8, 9, 10]", cs.getSelected().toString());
 324
 325     /*
 326      * Combine selection of columns 1 and 3 to get a discontiguous mapped
 327      * selection
 328      */
 329     colsel.clear();
 330     colsel.addElement(1);
 331     colsel.addElement(3);
 332     cs = MappingUtils.mapColumnSelection(colsel, proteinView, dnaView);
 333     assertEquals("[0, 1, 2, 3, 5, 6, 7, 8, 9, 10]", cs.getSelected()
 334             .toString());
 335   }
 336
 337   /**
 338    * Set up mappings for tests from 3 dna to 3 protein sequences. Sequences have
 339    * offset start positions for a more general test case.
 340    *
 341    * @throws IOException
 342    */
 343   protected void setupMappedAlignments() throws IOException
 344   {
 345     /*
 346      * Set up dna and protein Seq1/2/3 with mappings (held on the protein
 347      * viewport). Lower case for introns.
 348      */
 349     AlignmentI cdna = loadAlignment(">Seq1/10-18\nAC-GctGtC-T\n"
 350             + ">Seq2/20-27\nTc-GA-G-T-Tc\n" + ">Seq3/30-38\nTtTT-AaCGg-\n",
 351             "FASTA");
 352     cdna.setDataset(null);
 353     AlignmentI protein = loadAlignment(
 354             ">Seq1/40-41\n-K-P\n>Seq2/50-51\nL--Q\n>Seq3/60-61\nG--S\n",
 355             "FASTA");
 356     protein.setDataset(null);
 357
 358     // map first dna to first protein seq
 359     AlignedCodonFrame acf = new AlignedCodonFrame();
 360     MapList map = new MapList(new int[] { 10, 12, 15, 15, 17, 18 },
 361             new int[] { 40, 41 }, 3, 1);
 362     acf.addMap(cdna.getSequenceAt(0).getDatasetSequence(), protein
 363             .getSequenceAt(0).getDatasetSequence(), map);
 364
 365     // map second dna to second protein seq
 366     map = new MapList(new int[] { 20, 20, 22, 23, 24, 26 }, new int[] { 50,
 367         51 }, 3, 1);
 368     acf.addMap(cdna.getSequenceAt(1).getDatasetSequence(), protein
 369             .getSequenceAt(1).getDatasetSequence(), map);
 370
 371     // map third dna to third protein seq
 372     map = new MapList(new int[] { 30, 30, 32, 34, 36, 37 }, new int[] { 60,
 373         61 }, 3, 1);
 374     acf.addMap(cdna.getSequenceAt(2).getDatasetSequence(), protein
 375             .getSequenceAt(2).getDatasetSequence(), map);
 376     List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[]
 377     { acf });
 378
 379     dnaView = new AlignViewport(cdna);
 380     proteinView = new AlignViewport(protein);
 381     protein.setCodonFrames(acfList);
 382   }
 383
 384   /**
 385    * Test mapping a column selection in dna to its protein equivalent
 386    *
 387    * @throws IOException
 388    */
 389   @Test(groups = { "Functional" })
 390   public void testMapColumnSelection_dnaToProtein() throws IOException
 391   {
 392     setupMappedAlignments();
 393
 394     ColumnSelection colsel = new ColumnSelection();
 395
 396     /*
 397      * Column 0 in dna picks up first bases which map to residue 1, columns 0-1
 398      * in protein.
 399      */
 400     colsel.addElement(0);
 401     ColumnSelection cs = MappingUtils.mapColumnSelection(colsel, dnaView,
 402             proteinView);
 403     assertEquals("[0, 1]", cs.getSelected().toString());
 404
 405     /*
 406      * Columns 3-5 in dna map to the first residues in protein Seq1, Seq2, and
 407      * the first two in Seq3. Overall to columns 0, 1, 3 (col2 is all gaps).
 408      */
 409     colsel.addElement(3);
 410     colsel.addElement(4);
 411     colsel.addElement(5);
 412     cs = MappingUtils.mapColumnSelection(colsel, dnaView, proteinView);
 413     assertEquals("[0, 1, 3]", cs.getSelected().toString());
 414   }
 415
 416   @Test(groups = { "Functional" })
 417   public void testMapColumnSelection_null() throws IOException
 418   {
 419     setupMappedAlignments();
 420     ColumnSelection cs = MappingUtils.mapColumnSelection(null, dnaView,
 421             proteinView);
 422     assertTrue("mapped selection not empty", cs.getSelected().isEmpty());
 423   }
 424
 425   /**
 426    * Tests for the method that converts a series of [start, end] ranges to
 427    * single positions
 428    */
 429   @Test(groups = { "Functional" })
 430   public void testFlattenRanges()
 431   {
 432     assertEquals("[1, 2, 3, 4]",
 433             Arrays.toString(MappingUtils.flattenRanges(new int[] { 1, 4 })));
 434     assertEquals(
 435             "[1, 2, 3, 4]",
 436             Arrays.toString(MappingUtils.flattenRanges(new int[] { 1, 2, 3,
 437                 4 })));
 438     assertEquals(
 439             "[1, 2, 3, 4]",
 440             Arrays.toString(MappingUtils.flattenRanges(new int[] { 1, 1, 2,
 441                 2, 3, 3, 4, 4 })));
 442     assertEquals(
 443             "[1, 2, 3, 4, 7, 8, 9, 12]",
 444             Arrays.toString(MappingUtils.flattenRanges(new int[] { 1, 4, 7,
 445                 9, 12, 12 })));
 446     // trailing unpaired start position is ignored:
 447     assertEquals(
 448             "[1, 2, 3, 4, 7, 8, 9, 12]",
 449             Arrays.toString(MappingUtils.flattenRanges(new int[] { 1, 4, 7,
 450                 9, 12, 12, 15 })));
 451   }
 452
 453   /**
 454    * Test mapping a sequence group made of entire columns.
 455    *
 456    * @throws IOException
 457    */
 458   @Test(groups = { "Functional" })
 459   public void testMapSequenceGroup_columns() throws IOException
 460   {
 461     /*
 462      * Set up dna and protein Seq1/2/3 with mappings (held on the protein
 463      * viewport).
 464      */
 465     AlignmentI cdna = loadAlignment(
 466             ">Seq1\nACGGCA\n>Seq2\nTGACAG\n>Seq3\nTACGTA\n", "FASTA");
 467     cdna.setDataset(null);
 468     AlignmentI protein = loadAlignment(">Seq1\nKA\n>Seq2\nLQ\n>Seq3\nQV\n",
 469             "FASTA");
 470     protein.setDataset(null);
 471     AlignedCodonFrame acf = new AlignedCodonFrame();
 472     MapList map = new MapList(new int[] { 1, 6 }, new int[] { 1, 2 }, 3, 1);
 473     for (int seq = 0; seq < 3; seq++)
 474     {
 475       acf.addMap(cdna.getSequenceAt(seq).getDatasetSequence(), protein
 476               .getSequenceAt(seq).getDatasetSequence(), map);
 477     }
 478     List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[]
 479     { acf });
 480
 481     AlignViewportI dnaView = new AlignViewport(cdna);
 482     AlignViewportI proteinView = new AlignViewport(protein);
 483     protein.setCodonFrames(acfList);
 484
 485     /*
 486      * Select all sequences, column 2 in the protein
 487      */
 488     SequenceGroup sg = new SequenceGroup();
 489     sg.setColourText(true);
 490     sg.setIdColour(Color.GREEN);
 491     sg.setOutlineColour(Color.LIGHT_GRAY);
 492     sg.addSequence(protein.getSequenceAt(0), false);
 493     sg.addSequence(protein.getSequenceAt(1), false);
 494     sg.addSequence(protein.getSequenceAt(2), false);
 495     sg.setStartRes(1);
 496     sg.setEndRes(1);
 497
 498     /*
 499      * Verify the mapped sequence group in dna
 500      */
 501     SequenceGroup mappedGroup = MappingUtils.mapSequenceGroup(sg,
 502             proteinView, dnaView);
 503     assertTrue(mappedGroup.getColourText());
 504     assertSame(sg.getIdColour(), mappedGroup.getIdColour());
 505     assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour());
 506     assertEquals(3, mappedGroup.getSequences().size());
 507     assertSame(cdna.getSequenceAt(0), mappedGroup.getSequences().get(0));
 508     assertSame(cdna.getSequenceAt(1), mappedGroup.getSequences().get(1));
 509     assertSame(cdna.getSequenceAt(2), mappedGroup.getSequences().get(2));
 510     assertEquals(3, mappedGroup.getStartRes());
 511     assertEquals(5, mappedGroup.getEndRes());
 512
 513     /*
 514      * Verify mapping sequence group from dna to protein
 515      */
 516     sg.clear();
 517     sg.addSequence(cdna.getSequenceAt(0), false);
 518     sg.addSequence(cdna.getSequenceAt(1), false);
 519     sg.addSequence(cdna.getSequenceAt(2), false);
 520     // select columns 2 and 3 in DNA which span protein columns 0 and 1
 521     sg.setStartRes(2);
 522     sg.setEndRes(3);
 523     mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView);
 524     assertTrue(mappedGroup.getColourText());
 525     assertSame(sg.getIdColour(), mappedGroup.getIdColour());
 526     assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour());
 527     assertEquals(3, mappedGroup.getSequences().size());
 528     assertSame(protein.getSequenceAt(0), mappedGroup.getSequences().get(0));
 529     assertSame(protein.getSequenceAt(1), mappedGroup.getSequences().get(1));
 530     assertSame(protein.getSequenceAt(2), mappedGroup.getSequences().get(2));
 531     assertEquals(0, mappedGroup.getStartRes());
 532     assertEquals(1, mappedGroup.getEndRes());
 533   }
 534
 535   /**
 536    * Test mapping a sequence group made of a sequences/columns region.
 537    *
 538    * @throws IOException
 539    */
 540   @Test(groups = { "Functional" })
 541   public void testMapSequenceGroup_region() throws IOException
 542   {
 543     /*
 544      * Set up gapped dna and protein Seq1/2/3 with mappings (held on the protein
 545      * viewport).
 546      */
 547     AlignmentI cdna = loadAlignment(
 548             ">Seq1\nA-CG-GC--AT-CA\n>Seq2\n-TG-AC-AG-T-AT\n>Seq3\n-T--ACG-TAAT-G\n",
 549             "FASTA");
 550     cdna.setDataset(null);
 551     AlignmentI protein = loadAlignment(
 552             ">Seq1\n-KA-S\n>Seq2\n--L-QY\n>Seq3\nQ-V-M\n", "FASTA");
 553     protein.setDataset(null);
 554     AlignedCodonFrame acf = new AlignedCodonFrame();
 555     MapList map = new MapList(new int[] { 1, 9 }, new int[] { 1, 3 }, 3, 1);
 556     for (int seq = 0; seq < 3; seq++)
 557     {
 558       acf.addMap(cdna.getSequenceAt(seq).getDatasetSequence(), protein
 559               .getSequenceAt(seq).getDatasetSequence(), map);
 560     }
 561     List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[]
 562     { acf });
 563
 564     AlignViewportI dnaView = new AlignViewport(cdna);
 565     AlignViewportI proteinView = new AlignViewport(protein);
 566     protein.setCodonFrames(acfList);
 567
 568     /*
 569      * Select Seq1 and Seq2 in the protein, column 1 (K/-). Expect mapped
 570      * sequence group to cover Seq1, columns 0-3 (ACG). Because the selection
 571      * only includes a gap in Seq2 there is no mappable selection region in the
 572      * corresponding DNA.
 573      */
 574     SequenceGroup sg = new SequenceGroup();
 575     sg.setColourText(true);
 576     sg.setIdColour(Color.GREEN);
 577     sg.setOutlineColour(Color.LIGHT_GRAY);
 578     sg.addSequence(protein.getSequenceAt(0), false);
 579     sg.addSequence(protein.getSequenceAt(1), false);
 580     sg.setStartRes(1);
 581     sg.setEndRes(1);
 582
 583     /*
 584      * Verify the mapped sequence group in dna
 585      */
 586     SequenceGroup mappedGroup = MappingUtils.mapSequenceGroup(sg,
 587             proteinView, dnaView);
 588     assertTrue(mappedGroup.getColourText());
 589     assertSame(sg.getIdColour(), mappedGroup.getIdColour());
 590     assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour());
 591     assertEquals(1, mappedGroup.getSequences().size());
 592     assertSame(cdna.getSequenceAt(0), mappedGroup.getSequences().get(0));
 593     // Seq2 in protein has a gap in column 1 - ignored
 594     // Seq1 has K which should map to columns 0-3 in Seq1
 595     assertEquals(0, mappedGroup.getStartRes());
 596     assertEquals(3, mappedGroup.getEndRes());
 597
 598     /*
 599      * Now select cols 2-4 in protein. These cover Seq1:AS Seq2:LQ Seq3:VM which
 600      * extend over DNA columns 3-12, 1-7, 6-13 respectively, or 1-13 overall.
 601      */
 602     sg.setStartRes(2);
 603     sg.setEndRes(4);
 604     mappedGroup = MappingUtils.mapSequenceGroup(sg, proteinView, dnaView);
 605     assertEquals(1, mappedGroup.getStartRes());
 606     assertEquals(13, mappedGroup.getEndRes());
 607
 608     /*
 609      * Verify mapping sequence group from dna to protein
 610      */
 611     sg.clear();
 612     sg.addSequence(cdna.getSequenceAt(0), false);
 613
 614     // select columns 4,5 - includes Seq1:codon2 (A) only
 615     sg.setStartRes(4);
 616     sg.setEndRes(5);
 617     mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView);
 618     assertEquals(2, mappedGroup.getStartRes());
 619     assertEquals(2, mappedGroup.getEndRes());
 620
 621     // add Seq2 to dna selection cols 4-5 include codons 1 and 2 (LQ)
 622     sg.addSequence(cdna.getSequenceAt(1), false);
 623     mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView);
 624     assertEquals(2, mappedGroup.getStartRes());
 625     assertEquals(4, mappedGroup.getEndRes());
 626
 627     // add Seq3 to dna selection cols 4-5 include codon 1 (Q)
 628     sg.addSequence(cdna.getSequenceAt(2), false);
 629     mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView);
 630     assertEquals(0, mappedGroup.getStartRes());
 631     assertEquals(4, mappedGroup.getEndRes());
 632   }
 633
 634   @Test(groups = { "Functional" })
 635   public void testFindMappingsForSequence()
 636   {
 637     SequenceI seq1 = new Sequence("Seq1", "ABC");
 638     SequenceI seq2 = new Sequence("Seq2", "ABC");
 639     SequenceI seq3 = new Sequence("Seq3", "ABC");
 640     SequenceI seq4 = new Sequence("Seq4", "ABC");
 641     seq1.createDatasetSequence();
 642     seq2.createDatasetSequence();
 643     seq3.createDatasetSequence();
 644     seq4.createDatasetSequence();
 645
 646     /*
 647      * Create mappings from seq1 to seq2, seq2 to seq1, seq3 to seq1
 648      */
 649     AlignedCodonFrame acf1 = new AlignedCodonFrame();
 650     MapList map = new MapList(new int[] { 1, 3 }, new int[] { 1, 3 }, 1, 1);
 651     acf1.addMap(seq1.getDatasetSequence(), seq2.getDatasetSequence(), map);
 652     AlignedCodonFrame acf2 = new AlignedCodonFrame();
 653     acf2.addMap(seq2.getDatasetSequence(), seq1.getDatasetSequence(), map);
 654     AlignedCodonFrame acf3 = new AlignedCodonFrame();
 655     acf3.addMap(seq3.getDatasetSequence(), seq1.getDatasetSequence(), map);
 656
 657     List<AlignedCodonFrame> mappings = new ArrayList<AlignedCodonFrame>();
 658     mappings.add(acf1);
 659     mappings.add(acf2);
 660     mappings.add(acf3);
 661
 662     /*
 663      * Seq1 has three mappings
 664      */
 665     List<AlignedCodonFrame> result = MappingUtils.findMappingsForSequence(
 666             seq1, mappings);
 667     assertEquals(3, result.size());
 668     assertTrue(result.contains(acf1));
 669     assertTrue(result.contains(acf2));
 670     assertTrue(result.contains(acf3));
 671
 672     /*
 673      * Seq2 has two mappings
 674      */
 675     result = MappingUtils.findMappingsForSequence(seq2, mappings);
 676     assertEquals(2, result.size());
 677     assertTrue(result.contains(acf1));
 678     assertTrue(result.contains(acf2));
 679
 680     /*
 681      * Seq3 has one mapping
 682      */
 683     result = MappingUtils.findMappingsForSequence(seq3, mappings);
 684     assertEquals(1, result.size());
 685     assertTrue(result.contains(acf3));
 686
 687     /*
 688      * Seq4 has no mappings
 689      */
 690     result = MappingUtils.findMappingsForSequence(seq4, mappings);
 691     assertEquals(0, result.size());
 692
 693     result = MappingUtils.findMappingsForSequence(null, mappings);
 694     assertEquals(0, result.size());
 695
 696     result = MappingUtils.findMappingsForSequence(seq1, null);
 697     assertEquals(0, result.size());
 698
 699     result = MappingUtils.findMappingsForSequence(null, null);
 700     assertEquals(0, result.size());
 701   }
 702
 703   @Test(groups = { "Functional" })
 704   public void testMapEditCommand()
 705   {
 706     SequenceI dna = new Sequence("Seq1", "---ACG---GCATCA", 8, 16);
 707     SequenceI protein = new Sequence("Seq2", "-T-AS", 5, 7);
 708     dna.createDatasetSequence();
 709     protein.createDatasetSequence();
 710     AlignedCodonFrame acf = new AlignedCodonFrame();
 711     MapList map = new MapList(new int[] { 8, 16 }, new int[] { 5, 7 }, 3, 1);
 712     acf.addMap(dna.getDatasetSequence(), protein.getDatasetSequence(), map);
 713     List<AlignedCodonFrame> mappings = new ArrayList<AlignedCodonFrame>();
 714     mappings.add(acf);
 715
 716     AlignmentI prot = new Alignment(new SequenceI[] { protein });
 717     prot.setCodonFrames(mappings);
 718     AlignmentI nuc = new Alignment(new SequenceI[] { dna });
 719
 720     /*
 721      * construct and perform the edit command to turn "-T-AS" in to "-T-A--S"
 722      * i.e. insert two gaps at column 4
 723      */
 724     EditCommand ec = new EditCommand();
 725     final Edit edit = ec.new Edit(Action.INSERT_GAP,
 726             new SequenceI[] { protein }, 4, 2, '-');
 727     ec.appendEdit(edit, prot, true, null);
 728
 729     /*
 730      * the mapped edit command should be to insert 6 gaps before base 4 in the
 731      * nucleotide sequence, which corresponds to aligned column 12 in the dna
 732      */
 733     EditCommand mappedEdit = MappingUtils.mapEditCommand(ec, false, nuc,
 734             '-', mappings);
 735     assertEquals(1, mappedEdit.getEdits().size());
 736     Edit e = mappedEdit.getEdits().get(0);
 737     assertEquals(1, e.getSequences().length);
 738     assertEquals(dna, e.getSequences()[0]);
 739     assertEquals(12, e.getPosition());
 740     assertEquals(6, e.getNumber());
 741   }
 742
 743   /**
 744    * Tests for the method that converts a series of [start, end] ranges to
 745    * single positions, where the mapping is to a reverse strand i.e. start is
 746    * greater than end point mapped to
 747    */
 748   @Test(groups = { "Functional" })
 749   public void testFlattenRanges_reverseStrand()
 750   {
 751     assertEquals("[4, 3, 2, 1]",
 752             Arrays.toString(MappingUtils.flattenRanges(new int[] { 4, 1 })));
 753     assertEquals(
 754             "[4, 3, 2, 1]",
 755             Arrays.toString(MappingUtils.flattenRanges(new int[] { 4, 3, 2,
 756                 1 })));
 757     assertEquals(
 758             "[4, 3, 2, 1]",
 759             Arrays.toString(MappingUtils.flattenRanges(new int[] { 4, 4, 3,
 760                 3, 2, 2, 1, 1 })));
 761     assertEquals(
 762             "[12, 9, 8, 7, 4, 3, 2, 1]",
 763             Arrays.toString(MappingUtils.flattenRanges(new int[] { 12, 12,
 764                 9, 7, 4, 1 })));
 765     // forwards and backwards anyone?
 766     assertEquals(
 767             "[4, 5, 6, 3, 2, 1]",
 768             Arrays.toString(MappingUtils.flattenRanges(new int[] { 4, 6, 3,
 769                 1 })));
 770     // backwards and forwards
 771     assertEquals(
 772             "[3, 2, 1, 4, 5, 6]",
 773             Arrays.toString(MappingUtils.flattenRanges(new int[] { 3, 1, 4,
 774                 6 })));
 775     // trailing unpaired start position is ignored:
 776     assertEquals(
 777             "[12, 9, 8, 7, 4, 3, 2]",
 778             Arrays.toString(MappingUtils.flattenRanges(new int[] { 12, 12,
 779                 9, 7, 4, 2, 1 })));
 780   }
 781 }