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.Arrays;
  47 import java.util.Collections;
  48 import java.util.HashSet;
  49 import java.util.LinkedHashSet;
  50 import java.util.List;
  51 import java.util.Set;
  52
  53 import org.testng.annotations.Test;
  54
  55 public class MappingUtilsTest
  56 {
  57   private AlignViewportI dnaView;
  58
  59   private AlignViewportI proteinView;
  60
  61   /**
  62    * Simple test of mapping with no intron involved.
  63    */
  64   @Test(groups = { "Functional" })
  65   public void testBuildSearchResults()
  66   {
  67     final Sequence seq1 = new Sequence("Seq1/5-10", "C-G-TA-GC");
  68     seq1.createDatasetSequence();
  69
  70     final Sequence aseq1 = new Sequence("Seq1/12-13", "-P-R");
  71     aseq1.createDatasetSequence();
  72
  73     /*
  74      * Map dna bases 5-10 to protein residues 12-13
  75      */
  76     AlignedCodonFrame acf = new AlignedCodonFrame();
  77     MapList map = new MapList(new int[] { 5, 10 }, new int[] { 12, 13 }, 3,
  78             1);
  79     acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map);
  80     Set<AlignedCodonFrame> acfList = Collections.singleton(acf);
  81
  82     /*
  83      * Check protein residue 12 maps to codon 5-7, 13 to codon 8-10
  84      */
  85     SearchResults sr = MappingUtils.buildSearchResults(aseq1, 12, acfList);
  86     assertEquals(1, sr.getResults().size());
  87     Match m = sr.getResults().get(0);
  88     assertEquals(seq1.getDatasetSequence(), m.getSequence());
  89     assertEquals(5, m.getStart());
  90     assertEquals(7, m.getEnd());
  91     sr = MappingUtils.buildSearchResults(aseq1, 13, acfList);
  92     assertEquals(1, sr.getResults().size());
  93     m = sr.getResults().get(0);
  94     assertEquals(seq1.getDatasetSequence(), m.getSequence());
  95     assertEquals(8, m.getStart());
  96     assertEquals(10, m.getEnd());
  97
  98     /*
  99      * Check inverse mappings, from codons 5-7, 8-10 to protein 12, 13
 100      */
 101     for (int i = 5; i < 11; i++)
 102     {
 103       sr = MappingUtils.buildSearchResults(seq1, i, acfList);
 104       assertEquals(1, sr.getResults().size());
 105       m = sr.getResults().get(0);
 106       assertEquals(aseq1.getDatasetSequence(), m.getSequence());
 107       int residue = i > 7 ? 13 : 12;
 108       assertEquals(residue, m.getStart());
 109       assertEquals(residue, m.getEnd());
 110     }
 111   }
 112
 113   /**
 114    * Simple test of mapping with introns involved.
 115    */
 116   @Test(groups = { "Functional" })
 117   public void testBuildSearchResults_withIntron()
 118   {
 119     final Sequence seq1 = new Sequence("Seq1/5-17", "c-G-tAGa-GcAgCtt");
 120     seq1.createDatasetSequence();
 121
 122     final Sequence aseq1 = new Sequence("Seq1/8-9", "-E-D");
 123     aseq1.createDatasetSequence();
 124
 125     /*
 126      * Map dna bases [6, 8, 9], [11, 13, 115] to protein residues 8 and 9
 127      */
 128     AlignedCodonFrame acf = new AlignedCodonFrame();
 129     MapList map = new MapList(new int[] { 6, 6, 8, 9, 11, 11, 13, 13, 15,
 130         15 }, new int[] { 8, 9 }, 3, 1);
 131     acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map);
 132     Set<AlignedCodonFrame> acfList = Collections.singleton(acf);
 133
 134     /*
 135      * Check protein residue 8 maps to [6, 8, 9]
 136      */
 137     SearchResults sr = MappingUtils.buildSearchResults(aseq1, 8, acfList);
 138     assertEquals(2, sr.getResults().size());
 139     Match m = sr.getResults().get(0);
 140     assertEquals(seq1.getDatasetSequence(), m.getSequence());
 141     assertEquals(6, m.getStart());
 142     assertEquals(6, m.getEnd());
 143     m = sr.getResults().get(1);
 144     assertEquals(seq1.getDatasetSequence(), m.getSequence());
 145     assertEquals(8, m.getStart());
 146     assertEquals(9, m.getEnd());
 147
 148     /*
 149      * Check protein residue 9 maps to [11, 13, 15]
 150      */
 151     sr = MappingUtils.buildSearchResults(aseq1, 9, acfList);
 152     assertEquals(3, sr.getResults().size());
 153     m = sr.getResults().get(0);
 154     assertEquals(seq1.getDatasetSequence(), m.getSequence());
 155     assertEquals(11, m.getStart());
 156     assertEquals(11, m.getEnd());
 157     m = sr.getResults().get(1);
 158     assertEquals(seq1.getDatasetSequence(), m.getSequence());
 159     assertEquals(13, m.getStart());
 160     assertEquals(13, m.getEnd());
 161     m = sr.getResults().get(2);
 162     assertEquals(seq1.getDatasetSequence(), m.getSequence());
 163     assertEquals(15, m.getStart());
 164     assertEquals(15, m.getEnd());
 165
 166     /*
 167      * Check inverse mappings, from codons to protein
 168      */
 169     for (int i = 5; i < 18; i++)
 170     {
 171       sr = MappingUtils.buildSearchResults(seq1, i, acfList);
 172       int residue = (i == 6 || i == 8 || i == 9) ? 8 : (i == 11 || i == 13
 173               || i == 15 ? 9 : 0);
 174       if (residue == 0)
 175       {
 176         assertEquals(0, sr.getResults().size());
 177         continue;
 178       }
 179       assertEquals(1, sr.getResults().size());
 180       m = sr.getResults().get(0);
 181       assertEquals(aseq1.getDatasetSequence(), m.getSequence());
 182       assertEquals(residue, m.getStart());
 183       assertEquals(residue, m.getEnd());
 184     }
 185   }
 186
 187   /**
 188    * Test mapping a sequence group made of entire sequences.
 189    *
 190    * @throws IOException
 191    */
 192   @Test(groups = { "Functional" })
 193   public void testMapSequenceGroup_sequences() throws IOException
 194   {
 195     /*
 196      * Set up dna and protein Seq1/2/3 with mappings (held on the protein
 197      * viewport).
 198      */
 199     AlignmentI cdna = loadAlignment(">Seq1\nACG\n>Seq2\nTGA\n>Seq3\nTAC\n",
 200             "FASTA");
 201     cdna.setDataset(null);
 202     AlignmentI protein = loadAlignment(">Seq1\nK\n>Seq2\nL\n>Seq3\nQ\n",
 203             "FASTA");
 204     protein.setDataset(null);
 205     AlignedCodonFrame acf = new AlignedCodonFrame();
 206     MapList map = new MapList(new int[] { 1, 3 }, new int[] { 1, 1 }, 3, 1);
 207     for (int seq = 0; seq < 3; seq++)
 208     {
 209       acf.addMap(cdna.getSequenceAt(seq).getDatasetSequence(), protein
 210               .getSequenceAt(seq).getDatasetSequence(), map);
 211     }
 212     Set<AlignedCodonFrame> acfList = Collections.singleton(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 },
 368             3, 1);
 369     acf.addMap(cdna.getSequenceAt(1).getDatasetSequence(), protein
 370             .getSequenceAt(1).getDatasetSequence(), map);
 371
 372     // map third dna to third protein seq
 373     map = new MapList(new int[] { 30, 30, 32, 34, 36, 37 }, new int[] { 60,
 374         61 }, 3, 1);
 375     acf.addMap(cdna.getSequenceAt(2).getDatasetSequence(), protein
 376             .getSequenceAt(2).getDatasetSequence(), map);
 377     Set<AlignedCodonFrame> acfList = Collections.singleton(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     // 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     Set<AlignedCodonFrame> acfList = Collections.singleton(acf);
 479
 480     AlignViewportI dnaView = new AlignViewport(cdna);
 481     AlignViewportI proteinView = new AlignViewport(protein);
 482     protein.setCodonFrames(acfList);
 483
 484     /*
 485      * Select all sequences, column 2 in the protein
 486      */
 487     SequenceGroup sg = new SequenceGroup();
 488     sg.setColourText(true);
 489     sg.setIdColour(Color.GREEN);
 490     sg.setOutlineColour(Color.LIGHT_GRAY);
 491     sg.addSequence(protein.getSequenceAt(0), false);
 492     sg.addSequence(protein.getSequenceAt(1), false);
 493     sg.addSequence(protein.getSequenceAt(2), false);
 494     sg.setStartRes(1);
 495     sg.setEndRes(1);
 496
 497     /*
 498      * Verify the mapped sequence group in dna
 499      */
 500     SequenceGroup mappedGroup = MappingUtils.mapSequenceGroup(sg,
 501             proteinView, dnaView);
 502     assertTrue(mappedGroup.getColourText());
 503     assertSame(sg.getIdColour(), mappedGroup.getIdColour());
 504     assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour());
 505     assertEquals(3, mappedGroup.getSequences().size());
 506     assertSame(cdna.getSequenceAt(0), mappedGroup.getSequences().get(0));
 507     assertSame(cdna.getSequenceAt(1), mappedGroup.getSequences().get(1));
 508     assertSame(cdna.getSequenceAt(2), mappedGroup.getSequences().get(2));
 509     assertEquals(3, mappedGroup.getStartRes());
 510     assertEquals(5, mappedGroup.getEndRes());
 511
 512     /*
 513      * Verify mapping sequence group from dna to protein
 514      */
 515     sg.clear();
 516     sg.addSequence(cdna.getSequenceAt(0), false);
 517     sg.addSequence(cdna.getSequenceAt(1), false);
 518     sg.addSequence(cdna.getSequenceAt(2), false);
 519     // select columns 2 and 3 in DNA which span protein columns 0 and 1
 520     sg.setStartRes(2);
 521     sg.setEndRes(3);
 522     mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView);
 523     assertTrue(mappedGroup.getColourText());
 524     assertSame(sg.getIdColour(), mappedGroup.getIdColour());
 525     assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour());
 526     assertEquals(3, mappedGroup.getSequences().size());
 527     assertSame(protein.getSequenceAt(0), mappedGroup.getSequences().get(0));
 528     assertSame(protein.getSequenceAt(1), mappedGroup.getSequences().get(1));
 529     assertSame(protein.getSequenceAt(2), mappedGroup.getSequences().get(2));
 530     assertEquals(0, mappedGroup.getStartRes());
 531     assertEquals(1, mappedGroup.getEndRes());
 532   }
 533
 534   /**
 535    * Test mapping a sequence group made of a sequences/columns region.
 536    *
 537    * @throws IOException
 538    */
 539   @Test(groups = { "Functional" })
 540   public void testMapSequenceGroup_region() throws IOException
 541   {
 542     /*
 543      * Set up gapped dna and protein Seq1/2/3 with mappings (held on the protein
 544      * viewport).
 545      */
 546     AlignmentI cdna = loadAlignment(
 547             ">Seq1\nA-CG-GC--AT-CA\n>Seq2\n-TG-AC-AG-T-AT\n>Seq3\n-T--ACG-TAAT-G\n",
 548             "FASTA");
 549     cdna.setDataset(null);
 550     AlignmentI protein = loadAlignment(
 551             ">Seq1\n-KA-S\n>Seq2\n--L-QY\n>Seq3\nQ-V-M\n", "FASTA");
 552     protein.setDataset(null);
 553     AlignedCodonFrame acf = new AlignedCodonFrame();
 554     MapList map = new MapList(new int[] { 1, 9 }, new int[] { 1, 3 }, 3, 1);
 555     for (int seq = 0; seq < 3; seq++)
 556     {
 557       acf.addMap(cdna.getSequenceAt(seq).getDatasetSequence(), protein
 558               .getSequenceAt(seq).getDatasetSequence(), map);
 559     }
 560     Set<AlignedCodonFrame> acfList = Collections.singleton(acf);
 561
 562     AlignViewportI dnaView = new AlignViewport(cdna);
 563     AlignViewportI proteinView = new AlignViewport(protein);
 564     protein.setCodonFrames(acfList);
 565
 566     /*
 567      * Select Seq1 and Seq2 in the protein, column 1 (K/-). Expect mapped
 568      * sequence group to cover Seq1, columns 0-3 (ACG). Because the selection
 569      * only includes a gap in Seq2 there is no mappable selection region in the
 570      * corresponding DNA.
 571      */
 572     SequenceGroup sg = new SequenceGroup();
 573     sg.setColourText(true);
 574     sg.setIdColour(Color.GREEN);
 575     sg.setOutlineColour(Color.LIGHT_GRAY);
 576     sg.addSequence(protein.getSequenceAt(0), false);
 577     sg.addSequence(protein.getSequenceAt(1), false);
 578     sg.setStartRes(1);
 579     sg.setEndRes(1);
 580
 581     /*
 582      * Verify the mapped sequence group in dna
 583      */
 584     SequenceGroup mappedGroup = MappingUtils.mapSequenceGroup(sg,
 585             proteinView, dnaView);
 586     assertTrue(mappedGroup.getColourText());
 587     assertSame(sg.getIdColour(), mappedGroup.getIdColour());
 588     assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour());
 589     assertEquals(1, mappedGroup.getSequences().size());
 590     assertSame(cdna.getSequenceAt(0), mappedGroup.getSequences().get(0));
 591     // Seq2 in protein has a gap in column 1 - ignored
 592     // Seq1 has K which should map to columns 0-3 in Seq1
 593     assertEquals(0, mappedGroup.getStartRes());
 594     assertEquals(3, mappedGroup.getEndRes());
 595
 596     /*
 597      * Now select cols 2-4 in protein. These cover Seq1:AS Seq2:LQ Seq3:VM which
 598      * extend over DNA columns 3-12, 1-7, 6-13 respectively, or 1-13 overall.
 599      */
 600     sg.setStartRes(2);
 601     sg.setEndRes(4);
 602     mappedGroup = MappingUtils.mapSequenceGroup(sg, proteinView, dnaView);
 603     assertEquals(1, mappedGroup.getStartRes());
 604     assertEquals(13, mappedGroup.getEndRes());
 605
 606     /*
 607      * Verify mapping sequence group from dna to protein
 608      */
 609     sg.clear();
 610     sg.addSequence(cdna.getSequenceAt(0), false);
 611
 612     // select columns 4,5 - includes Seq1:codon2 (A) only
 613     sg.setStartRes(4);
 614     sg.setEndRes(5);
 615     mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView);
 616     assertEquals(2, mappedGroup.getStartRes());
 617     assertEquals(2, mappedGroup.getEndRes());
 618
 619     // add Seq2 to dna selection cols 4-5 include codons 1 and 2 (LQ)
 620     sg.addSequence(cdna.getSequenceAt(1), false);
 621     mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView);
 622     assertEquals(2, mappedGroup.getStartRes());
 623     assertEquals(4, mappedGroup.getEndRes());
 624
 625     // add Seq3 to dna selection cols 4-5 include codon 1 (Q)
 626     sg.addSequence(cdna.getSequenceAt(2), false);
 627     mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView);
 628     assertEquals(0, mappedGroup.getStartRes());
 629     assertEquals(4, mappedGroup.getEndRes());
 630   }
 631
 632   @Test(groups = { "Functional" })
 633   public void testFindMappingsForSequence()
 634   {
 635     SequenceI seq1 = new Sequence("Seq1", "ABC");
 636     SequenceI seq2 = new Sequence("Seq2", "ABC");
 637     SequenceI seq3 = new Sequence("Seq3", "ABC");
 638     SequenceI seq4 = new Sequence("Seq4", "ABC");
 639     seq1.createDatasetSequence();
 640     seq2.createDatasetSequence();
 641     seq3.createDatasetSequence();
 642     seq4.createDatasetSequence();
 643
 644     /*
 645      * Create mappings from seq1 to seq2, seq2 to seq1, seq3 to seq1
 646      */
 647     AlignedCodonFrame acf1 = new AlignedCodonFrame();
 648     MapList map = new MapList(new int[] { 1, 3 }, new int[] { 1, 3 }, 1, 1);
 649     acf1.addMap(seq1.getDatasetSequence(), seq2.getDatasetSequence(), map);
 650     AlignedCodonFrame acf2 = new AlignedCodonFrame();
 651     acf2.addMap(seq2.getDatasetSequence(), seq1.getDatasetSequence(), map);
 652     AlignedCodonFrame acf3 = new AlignedCodonFrame();
 653     acf3.addMap(seq3.getDatasetSequence(), seq1.getDatasetSequence(), map);
 654
 655     Set<AlignedCodonFrame> mappings = new HashSet<AlignedCodonFrame>();
 656     mappings.add(acf1);
 657     mappings.add(acf2);
 658     mappings.add(acf3);
 659
 660     /*
 661      * Seq1 has three mappings
 662      */
 663     List<AlignedCodonFrame> result = MappingUtils.findMappingsForSequence(
 664             seq1, mappings);
 665     assertEquals(3, result.size());
 666     assertTrue(result.contains(acf1));
 667     assertTrue(result.contains(acf2));
 668     assertTrue(result.contains(acf3));
 669
 670     /*
 671      * Seq2 has two mappings
 672      */
 673     result = MappingUtils.findMappingsForSequence(seq2, mappings);
 674     assertEquals(2, result.size());
 675     assertTrue(result.contains(acf1));
 676     assertTrue(result.contains(acf2));
 677
 678     /*
 679      * Seq3 has one mapping
 680      */
 681     result = MappingUtils.findMappingsForSequence(seq3, mappings);
 682     assertEquals(1, result.size());
 683     assertTrue(result.contains(acf3));
 684
 685     /*
 686      * Seq4 has no mappings
 687      */
 688     result = MappingUtils.findMappingsForSequence(seq4, mappings);
 689     assertEquals(0, result.size());
 690
 691     result = MappingUtils.findMappingsForSequence(null, mappings);
 692     assertEquals(0, result.size());
 693
 694     result = MappingUtils.findMappingsForSequence(seq1, null);
 695     assertEquals(0, result.size());
 696
 697     result = MappingUtils.findMappingsForSequence(null, null);
 698     assertEquals(0, result.size());
 699   }
 700
 701   @Test(groups = { "Functional" })
 702   public void testMapEditCommand()
 703   {
 704     SequenceI dna = new Sequence("Seq1", "---ACG---GCATCA", 8, 16);
 705     SequenceI protein = new Sequence("Seq2", "-T-AS", 5, 7);
 706     dna.createDatasetSequence();
 707     protein.createDatasetSequence();
 708     AlignedCodonFrame acf = new AlignedCodonFrame();
 709     MapList map = new MapList(new int[] { 8, 16 }, new int[] { 5, 7 }, 3, 1);
 710     acf.addMap(dna.getDatasetSequence(), protein.getDatasetSequence(), map);
 711     Set<AlignedCodonFrame> mappings = new LinkedHashSet<AlignedCodonFrame>();
 712     mappings.add(acf);
 713
 714     AlignmentI prot = new Alignment(new SequenceI[] { protein });
 715     prot.setCodonFrames(mappings);
 716     AlignmentI nuc = new Alignment(new SequenceI[] { dna });
 717
 718     /*
 719      * construct and perform the edit command to turn "-T-AS" in to "-T-A--S"
 720      * i.e. insert two gaps at column 4
 721      */
 722     EditCommand ec = new EditCommand();
 723     final Edit edit = ec.new Edit(Action.INSERT_GAP,
 724             new SequenceI[] { protein }, 4, 2, '-');
 725     ec.appendEdit(edit, prot, true, null);
 726
 727     /*
 728      * the mapped edit command should be to insert 6 gaps before base 4 in the
 729      * nucleotide sequence, which corresponds to aligned column 12 in the dna
 730      */
 731     EditCommand mappedEdit = MappingUtils.mapEditCommand(ec, false, nuc,
 732             '-', mappings);
 733     assertEquals(1, mappedEdit.getEdits().size());
 734     Edit e = mappedEdit.getEdits().get(0);
 735     assertEquals(1, e.getSequences().length);
 736     assertEquals(dna, e.getSequences()[0]);
 737     assertEquals(12, e.getPosition());
 738     assertEquals(6, e.getNumber());
 739   }
 740 }