test/jalview/commands/EditCommandTest.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.commands;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertSame;
  25
  26 import jalview.commands.EditCommand.Action;
  27 import jalview.commands.EditCommand.Edit;
  28 import jalview.datamodel.Alignment;
  29 import jalview.datamodel.AlignmentI;
  30 import jalview.datamodel.Sequence;
  31 import jalview.datamodel.SequenceI;
  32
  33 import java.util.Map;
  34
  35 import org.testng.annotations.BeforeMethod;
  36 import org.testng.annotations.Test;
  37
  38 /**
  39  * Unit tests for EditCommand
  40  *
  41  * @author gmcarstairs
  42  *
  43  */
  44 public class EditCommandTest
  45 {
  46
  47   private EditCommand testee;
  48
  49   private SequenceI[] seqs;
  50
  51   private Alignment al;
  52
  53   @BeforeMethod(alwaysRun = true)
  54   public void setUp()
  55   {
  56     testee = new EditCommand();
  57     seqs = new SequenceI[4];
  58     seqs[0] = new Sequence("seq0", "abcdefghjk");
  59     seqs[0].setDatasetSequence(new Sequence("seq0ds", "abcdefghjk"));
  60     seqs[1] = new Sequence("seq1", "fghjklmnopq");
  61     seqs[1].setDatasetSequence(new Sequence("seq1ds", "fghjklmnopq"));
  62     seqs[2] = new Sequence("seq2", "qrstuvwxyz");
  63     seqs[2].setDatasetSequence(new Sequence("seq2ds", "qrstuvwxyz"));
  64     seqs[3] = new Sequence("seq3", "1234567890");
  65     seqs[3].setDatasetSequence(new Sequence("seq3ds", "1234567890"));
  66     al = new Alignment(seqs);
  67     al.setGapCharacter('?');
  68   }
  69
  70   /**
  71    * Test inserting gap characters
  72    */
  73   @Test(groups = { "Functional" })
  74   public void testAppendEdit_insertGap()
  75   {
  76     // set a non-standard gap character to prove it is actually used
  77     testee.appendEdit(Action.INSERT_GAP, seqs, 4, 3, al, true);
  78     assertEquals("abcd???efghjk", seqs[0].getSequenceAsString());
  79     assertEquals("fghj???klmnopq", seqs[1].getSequenceAsString());
  80     assertEquals("qrst???uvwxyz", seqs[2].getSequenceAsString());
  81     assertEquals("1234???567890", seqs[3].getSequenceAsString());
  82
  83     // todo: test for handling out of range positions?
  84   }
  85
  86   /**
  87    * Test deleting characters from sequences. Note the deleteGap() action does
  88    * not check that only gap characters are being removed.
  89    */
  90   @Test(groups = { "Functional" })
  91   public void testAppendEdit_deleteGap()
  92   {
  93     testee.appendEdit(Action.DELETE_GAP, seqs, 4, 3, al, true);
  94     assertEquals("abcdhjk", seqs[0].getSequenceAsString());
  95     assertEquals("fghjnopq", seqs[1].getSequenceAsString());
  96     assertEquals("qrstxyz", seqs[2].getSequenceAsString());
  97     assertEquals("1234890", seqs[3].getSequenceAsString());
  98   }
  99
 100   /**
 101    * Test a cut action. The command should store the cut characters to support
 102    * undo.
 103    */
 104   @Test(groups = { "Functional" })
 105   public void testCut()
 106   {
 107     Edit ec = testee.new Edit(Action.CUT, seqs, 4, 3, al);
 108     EditCommand.cut(ec, new AlignmentI[] { al });
 109     assertEquals("abcdhjk", seqs[0].getSequenceAsString());
 110     assertEquals("fghjnopq", seqs[1].getSequenceAsString());
 111     assertEquals("qrstxyz", seqs[2].getSequenceAsString());
 112     assertEquals("1234890", seqs[3].getSequenceAsString());
 113
 114     assertEquals("efg", new String(ec.string[0]));
 115     assertEquals("klm", new String(ec.string[1]));
 116     assertEquals("uvw", new String(ec.string[2]));
 117     assertEquals("567", new String(ec.string[3]));
 118     // TODO: case where whole sequence is deleted as nothing left; etc
 119   }
 120
 121   /**
 122    * Test a Paste action, where this adds sequences to an alignment.
 123    */
 124   @Test(groups = { "Functional" }, enabled = false)
 125   // TODO fix so it works
 126   public void testPaste_addToAlignment()
 127   {
 128     SequenceI[] newSeqs = new SequenceI[2];
 129     newSeqs[0] = new Sequence("newseq0", "ACEFKL");
 130     newSeqs[1] = new Sequence("newseq1", "JWMPDH");
 131
 132     Edit ec = testee.new Edit(Action.PASTE, newSeqs, 0, al.getWidth(), al);
 133     EditCommand.paste(ec, new AlignmentI[] { al });
 134     assertEquals(6, al.getSequences().size());
 135     assertEquals("1234567890", seqs[3].getSequenceAsString());
 136     assertEquals("ACEFKL", seqs[4].getSequenceAsString());
 137     assertEquals("JWMPDH", seqs[5].getSequenceAsString());
 138   }
 139
 140   /**
 141    * Test insertGap followed by undo command
 142    */
 143   @Test(groups = { "Functional" })
 144   public void testUndo_insertGap()
 145   {
 146     // Edit ec = testee.new Edit(Action.INSERT_GAP, seqs, 4, 3, '?');
 147     testee.appendEdit(Action.INSERT_GAP, seqs, 4, 3, al, true);
 148     // check something changed
 149     assertEquals("abcd???efghjk", seqs[0].getSequenceAsString());
 150     testee.undoCommand(new AlignmentI[] { al });
 151     assertEquals("abcdefghjk", seqs[0].getSequenceAsString());
 152     assertEquals("fghjklmnopq", seqs[1].getSequenceAsString());
 153     assertEquals("qrstuvwxyz", seqs[2].getSequenceAsString());
 154     assertEquals("1234567890", seqs[3].getSequenceAsString());
 155   }
 156
 157   /**
 158    * Test deleteGap followed by undo command
 159    */
 160   @Test(groups = { "Functional" })
 161   public void testUndo_deleteGap()
 162   {
 163     testee.appendEdit(Action.DELETE_GAP, seqs, 4, 3, al, true);
 164     // check something changed
 165     assertEquals("abcdhjk", seqs[0].getSequenceAsString());
 166     testee.undoCommand(new AlignmentI[] { al });
 167     // deleteGap doesn't 'remember' deleted characters, only gaps get put back
 168     assertEquals("abcd???hjk", seqs[0].getSequenceAsString());
 169     assertEquals("fghj???nopq", seqs[1].getSequenceAsString());
 170     assertEquals("qrst???xyz", seqs[2].getSequenceAsString());
 171     assertEquals("1234???890", seqs[3].getSequenceAsString());
 172   }
 173
 174   /**
 175    * Test several commands followed by an undo command
 176    */
 177   @Test(groups = { "Functional" })
 178   public void testUndo_multipleCommands()
 179   {
 180     // delete positions 3/4/5 (counting from 1)
 181     testee.appendEdit(Action.DELETE_GAP, seqs, 2, 3, al, true);
 182     assertEquals("abfghjk", seqs[0].getSequenceAsString());
 183     assertEquals("1267890", seqs[3].getSequenceAsString());
 184
 185     // insert 2 gaps after the second residue
 186     testee.appendEdit(Action.INSERT_GAP, seqs, 2, 2, al, true);
 187     assertEquals("ab??fghjk", seqs[0].getSequenceAsString());
 188     assertEquals("12??67890", seqs[3].getSequenceAsString());
 189
 190     // delete positions 4/5/6
 191     testee.appendEdit(Action.DELETE_GAP, seqs, 3, 3, al, true);
 192     assertEquals("ab?hjk", seqs[0].getSequenceAsString());
 193     assertEquals("12?890", seqs[3].getSequenceAsString());
 194
 195     // undo edit commands
 196     testee.undoCommand(new AlignmentI[] { al });
 197     assertEquals("ab?????hjk", seqs[0].getSequenceAsString());
 198     assertEquals("12?????890", seqs[3].getSequenceAsString());
 199   }
 200
 201   /**
 202    * Unit test for JAL-1594 bug: click and drag sequence right to insert gaps -
 203    * undo did not remove them all.
 204    */
 205   @Test(groups = { "Functional" })
 206   public void testUndo_multipleInsertGaps()
 207   {
 208     testee.appendEdit(Action.INSERT_GAP, seqs, 4, 1, al, true);
 209     testee.appendEdit(Action.INSERT_GAP, seqs, 5, 1, al, true);
 210     testee.appendEdit(Action.INSERT_GAP, seqs, 6, 1, al, true);
 211
 212     // undo edit commands
 213     testee.undoCommand(new AlignmentI[] { al });
 214     assertEquals("abcdefghjk", seqs[0].getSequenceAsString());
 215     assertEquals("1234567890", seqs[3].getSequenceAsString());
 216
 217   }
 218
 219   /**
 220    * Test cut followed by undo command
 221    */
 222   @Test(groups = { "Functional" })
 223   public void testUndo_cut()
 224   {
 225     testee.appendEdit(Action.CUT, seqs, 4, 3, al, true);
 226     // check something changed
 227     assertEquals("abcdhjk", seqs[0].getSequenceAsString());
 228     testee.undoCommand(new AlignmentI[] { al });
 229     assertEquals("abcdefghjk", seqs[0].getSequenceAsString());
 230     assertEquals("fghjklmnopq", seqs[1].getSequenceAsString());
 231     assertEquals("qrstuvwxyz", seqs[2].getSequenceAsString());
 232     assertEquals("1234567890", seqs[3].getSequenceAsString());
 233   }
 234
 235   /**
 236    * Test the replace command (used to manually edit a sequence)
 237    */
 238   @Test(groups = { "Functional" })
 239   public void testReplace()
 240   {
 241     // seem to need a dataset sequence on the edited sequence here
 242     seqs[1].createDatasetSequence();
 243     new EditCommand("", Action.REPLACE, "ZXY", new SequenceI[] { seqs[1] },
 244             4, 8, al);
 245     assertEquals("abcdefghjk", seqs[0].getSequenceAsString());
 246     assertEquals("qrstuvwxyz", seqs[2].getSequenceAsString());
 247     assertEquals("1234567890", seqs[3].getSequenceAsString());
 248     seqs[1] = new Sequence("seq1", "fghjZXYnopq");
 249   }
 250
 251   /**
 252    * Test that the addEdit command correctly merges insert gap commands when
 253    * possible.
 254    */
 255   @Test(groups = { "Functional" })
 256   public void testAddEdit_multipleInsertGap()
 257   {
 258     /*
 259      * 3 insert gap in a row (aka mouse drag right):
 260      */
 261     Edit e = new EditCommand().new Edit(Action.INSERT_GAP,
 262             new SequenceI[] { seqs[0] }, 1, 1, al);
 263     testee.addEdit(e);
 264     SequenceI edited = new Sequence("seq0", "a?bcdefghjk");
 265     edited.setDatasetSequence(seqs[0].getDatasetSequence());
 266     e = new EditCommand().new Edit(Action.INSERT_GAP,
 267             new SequenceI[] { edited }, 2, 1, al);
 268     testee.addEdit(e);
 269     edited = new Sequence("seq0", "a??bcdefghjk");
 270     edited.setDatasetSequence(seqs[0].getDatasetSequence());
 271     e = new EditCommand().new Edit(Action.INSERT_GAP,
 272             new SequenceI[] { edited }, 3, 1, al);
 273     testee.addEdit(e);
 274     assertEquals(1, testee.getSize());
 275     assertEquals(Action.INSERT_GAP, testee.getEdit(0).getAction());
 276     assertEquals(1, testee.getEdit(0).getPosition());
 277     assertEquals(3, testee.getEdit(0).getNumber());
 278
 279     /*
 280      * Add a non-contiguous edit - should not be merged.
 281      */
 282     e = new EditCommand().new Edit(Action.INSERT_GAP,
 283             new SequenceI[] { edited }, 5, 2, al);
 284     testee.addEdit(e);
 285     assertEquals(2, testee.getSize());
 286     assertEquals(5, testee.getEdit(1).getPosition());
 287     assertEquals(2, testee.getEdit(1).getNumber());
 288
 289     /*
 290      * Add a Delete after the Insert - should not be merged.
 291      */
 292     e = new EditCommand().new Edit(Action.DELETE_GAP,
 293             new SequenceI[] { edited }, 6, 2, al);
 294     testee.addEdit(e);
 295     assertEquals(3, testee.getSize());
 296     assertEquals(Action.DELETE_GAP, testee.getEdit(2).getAction());
 297     assertEquals(6, testee.getEdit(2).getPosition());
 298     assertEquals(2, testee.getEdit(2).getNumber());
 299   }
 300
 301   /**
 302    * Test that the addEdit command correctly merges delete gap commands when
 303    * possible.
 304    */
 305   @Test(groups = { "Functional" })
 306   public void testAddEdit_multipleDeleteGap()
 307   {
 308     /*
 309      * 3 delete gap in a row (aka mouse drag left):
 310      */
 311     seqs[0].setSequence("a???bcdefghjk");
 312     Edit e = new EditCommand().new Edit(Action.DELETE_GAP,
 313             new SequenceI[] { seqs[0] }, 4, 1, al);
 314     testee.addEdit(e);
 315     assertEquals(1, testee.getSize());
 316
 317     SequenceI edited = new Sequence("seq0", "a??bcdefghjk");
 318     edited.setDatasetSequence(seqs[0].getDatasetSequence());
 319     e = new EditCommand().new Edit(Action.DELETE_GAP,
 320             new SequenceI[] { edited }, 3, 1, al);
 321     testee.addEdit(e);
 322     assertEquals(1, testee.getSize());
 323
 324     edited = new Sequence("seq0", "a?bcdefghjk");
 325     edited.setDatasetSequence(seqs[0].getDatasetSequence());
 326     e = new EditCommand().new Edit(Action.DELETE_GAP,
 327             new SequenceI[] { edited }, 2, 1, al);
 328     testee.addEdit(e);
 329     assertEquals(1, testee.getSize());
 330     assertEquals(Action.DELETE_GAP, testee.getEdit(0).getAction());
 331     assertEquals(2, testee.getEdit(0).getPosition());
 332     assertEquals(3, testee.getEdit(0).getNumber());
 333
 334     /*
 335      * Add a non-contiguous edit - should not be merged.
 336      */
 337     e = new EditCommand().new Edit(Action.DELETE_GAP,
 338             new SequenceI[] { edited }, 2, 1, al);
 339     testee.addEdit(e);
 340     assertEquals(2, testee.getSize());
 341     assertEquals(Action.DELETE_GAP, testee.getEdit(0).getAction());
 342     assertEquals(2, testee.getEdit(1).getPosition());
 343     assertEquals(1, testee.getEdit(1).getNumber());
 344
 345     /*
 346      * Add an Insert after the Delete - should not be merged.
 347      */
 348     e = new EditCommand().new Edit(Action.INSERT_GAP,
 349             new SequenceI[] { edited }, 1, 1, al);
 350     testee.addEdit(e);
 351     assertEquals(3, testee.getSize());
 352     assertEquals(Action.INSERT_GAP, testee.getEdit(2).getAction());
 353     assertEquals(1, testee.getEdit(2).getPosition());
 354     assertEquals(1, testee.getEdit(2).getNumber());
 355   }
 356
 357   /**
 358    * Test that the addEdit command correctly handles 'remove gaps' edits for the
 359    * case when they appear contiguous but are acting on different sequences.
 360    * They should not be merged.
 361    */
 362   @Test(groups = { "Functional" })
 363   public void testAddEdit_removeAllGaps()
 364   {
 365     seqs[0].setSequence("a???bcdefghjk");
 366     Edit e = new EditCommand().new Edit(Action.DELETE_GAP,
 367             new SequenceI[] { seqs[0] }, 4, 1, al);
 368     testee.addEdit(e);
 369
 370     seqs[1].setSequence("f??ghjklmnopq");
 371     Edit e2 = new EditCommand().new Edit(Action.DELETE_GAP, new SequenceI[]
 372     { seqs[1] }, 3, 1, al);
 373     testee.addEdit(e2);
 374     assertEquals(2, testee.getSize());
 375     assertSame(e, testee.getEdit(0));
 376     assertSame(e2, testee.getEdit(1));
 377   }
 378
 379   /**
 380    * Test that the addEdit command correctly merges insert gap commands acting
 381    * on a multi-sequence selection.
 382    */
 383   @Test(groups = { "Functional" })
 384   public void testAddEdit_groupInsertGaps()
 385   {
 386     /*
 387      * 2 insert gap in a row (aka mouse drag right), on two sequences:
 388      */
 389     Edit e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[] {
 390         seqs[0], seqs[1] }, 1, 1, al);
 391     testee.addEdit(e);
 392     SequenceI seq1edited = new Sequence("seq0", "a?bcdefghjk");
 393     seq1edited.setDatasetSequence(seqs[0].getDatasetSequence());
 394     SequenceI seq2edited = new Sequence("seq1", "f?ghjklmnopq");
 395     seq2edited.setDatasetSequence(seqs[1].getDatasetSequence());
 396     e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[] {
 397         seq1edited, seq2edited }, 2, 1, al);
 398     testee.addEdit(e);
 399
 400     assertEquals(1, testee.getSize());
 401     assertEquals(Action.INSERT_GAP, testee.getEdit(0).getAction());
 402     assertEquals(1, testee.getEdit(0).getPosition());
 403     assertEquals(2, testee.getEdit(0).getNumber());
 404     assertEquals(seqs[0].getDatasetSequence(), testee.getEdit(0)
 405             .getSequences()[0].getDatasetSequence());
 406     assertEquals(seqs[1].getDatasetSequence(), testee.getEdit(0)
 407             .getSequences()[1].getDatasetSequence());
 408   }
 409
 410   /**
 411    * Test for 'undoing' a series of gap insertions.
 412    * <ul>
 413    * <li>Start: ABCDEF insert 2 at pos 1</li>
 414    * <li>next: A--BCDEF insert 1 at pos 4</li>
 415    * <li>next: A--B-CDEF insert 2 at pos 0</li>
 416    * <li>last: --A--B-CDEF</li>
 417    * </ul>
 418    */
 419   @Test(groups = { "Functional" })
 420   public void testPriorState_multipleInserts()
 421   {
 422     EditCommand command = new EditCommand();
 423     SequenceI seq = new Sequence("", "--A--B-CDEF");
 424     SequenceI ds = new Sequence("", "ABCDEF");
 425     seq.setDatasetSequence(ds);
 426     SequenceI[] sqs = new SequenceI[] { seq };
 427     Edit e = command.new Edit(Action.INSERT_GAP, sqs, 1, 2, '-');
 428     command.addEdit(e);
 429     e = command.new Edit(Action.INSERT_GAP, sqs, 4, 1, '-');
 430     command.addEdit(e);
 431     e = command.new Edit(Action.INSERT_GAP, sqs, 0, 2, '-');
 432     command.addEdit(e);
 433
 434     Map<SequenceI, SequenceI> unwound = command.priorState(false);
 435     assertEquals("ABCDEF", unwound.get(ds).getSequenceAsString());
 436   }
 437
 438   /**
 439    * Test for 'undoing' a series of gap deletions.
 440    * <ul>
 441    * <li>Start: A-B-C delete 1 at pos 1</li>
 442    * <li>Next: AB-C delete 1 at pos 2</li>
 443    * <li>End: ABC</li>
 444    * </ul>
 445    */
 446   @Test(groups = { "Functional" })
 447   public void testPriorState_removeAllGaps()
 448   {
 449     EditCommand command = new EditCommand();
 450     SequenceI seq = new Sequence("", "ABC");
 451     SequenceI ds = new Sequence("", "ABC");
 452     seq.setDatasetSequence(ds);
 453     SequenceI[] sqs = new SequenceI[] { seq };
 454     Edit e = command.new Edit(Action.DELETE_GAP, sqs, 1, 1, '-');
 455     command.addEdit(e);
 456     e = command.new Edit(Action.DELETE_GAP, sqs, 2, 1, '-');
 457     command.addEdit(e);
 458
 459     Map<SequenceI, SequenceI> unwound = command.priorState(false);
 460     assertEquals("A-B-C", unwound.get(ds).getSequenceAsString());
 461   }
 462
 463   /**
 464    * Test for 'undoing' a single delete edit.
 465    */
 466   @Test(groups = { "Functional" })
 467   public void testPriorState_singleDelete()
 468   {
 469     EditCommand command = new EditCommand();
 470     SequenceI seq = new Sequence("", "ABCDEF");
 471     SequenceI ds = new Sequence("", "ABCDEF");
 472     seq.setDatasetSequence(ds);
 473     SequenceI[] sqs = new SequenceI[] { seq };
 474     Edit e = command.new Edit(Action.DELETE_GAP, sqs, 2, 2, '-');
 475     command.addEdit(e);
 476
 477     Map<SequenceI, SequenceI> unwound = command.priorState(false);
 478     assertEquals("AB--CDEF", unwound.get(ds).getSequenceAsString());
 479   }
 480
 481   /**
 482    * Test 'undoing' a single gap insertion edit command.
 483    */
 484   @Test(groups = { "Functional" })
 485   public void testPriorState_singleInsert()
 486   {
 487     EditCommand command = new EditCommand();
 488     SequenceI seq = new Sequence("", "AB---CDEF");
 489     SequenceI ds = new Sequence("", "ABCDEF");
 490     seq.setDatasetSequence(ds);
 491     SequenceI[] sqs = new SequenceI[] { seq };
 492     Edit e = command.new Edit(Action.INSERT_GAP, sqs, 2, 3, '-');
 493     command.addEdit(e);
 494
 495     Map<SequenceI, SequenceI> unwound = command.priorState(false);
 496     SequenceI prior = unwound.get(ds);
 497     assertEquals("ABCDEF", prior.getSequenceAsString());
 498     assertEquals(1, prior.getStart());
 499     assertEquals(6, prior.getEnd());
 500   }
 501
 502   /**
 503    * Test 'undoing' a single gap insertion edit command, on a sequence whose
 504    * start residue is other than 1
 505    */
 506   @Test(groups = { "Functional" })
 507   public void testPriorState_singleInsertWithOffset()
 508   {
 509     EditCommand command = new EditCommand();
 510     SequenceI seq = new Sequence("", "AB---CDEF", 8, 13);
 511     // SequenceI ds = new Sequence("", "ABCDEF", 8, 13);
 512     // seq.setDatasetSequence(ds);
 513     seq.createDatasetSequence();
 514     SequenceI[] sqs = new SequenceI[] { seq };
 515     Edit e = command.new Edit(Action.INSERT_GAP, sqs, 2, 3, '-');
 516     command.addEdit(e);
 517
 518     Map<SequenceI, SequenceI> unwound = command.priorState(false);
 519     SequenceI prior = unwound.get(seq.getDatasetSequence());
 520     assertEquals("ABCDEF", prior.getSequenceAsString());
 521     assertEquals(8, prior.getStart());
 522     assertEquals(13, prior.getEnd());
 523   }
 524
 525   /**
 526    * Test that mimics 'remove all gaps' action. This generates delete gap edits
 527    * for contiguous gaps in each sequence separately.
 528    */
 529   @Test(groups = { "Functional" })
 530   public void testPriorState_removeGapsMultipleSeqs()
 531   {
 532     EditCommand command = new EditCommand();
 533     String original1 = "--ABC-DEF";
 534     String original2 = "FG-HI--J";
 535     String original3 = "M-NOPQ";
 536
 537     /*
 538      * Two edits for the first sequence
 539      */
 540     SequenceI seq = new Sequence("", "ABC-DEF");
 541     SequenceI ds1 = new Sequence("", "ABCDEF");
 542     seq.setDatasetSequence(ds1);
 543     SequenceI[] sqs = new SequenceI[] { seq };
 544     Edit e = command.new Edit(Action.DELETE_GAP, sqs, 0, 2, '-');
 545     command.addEdit(e);
 546     seq = new Sequence("", "ABCDEF");
 547     seq.setDatasetSequence(ds1);
 548     sqs = new SequenceI[] { seq };
 549     e = command.new Edit(Action.DELETE_GAP, sqs, 3, 1, '-');
 550     command.addEdit(e);
 551
 552     /*
 553      * Two edits for the second sequence
 554      */
 555     seq = new Sequence("", "FGHI--J");
 556     SequenceI ds2 = new Sequence("", "FGHIJ");
 557     seq.setDatasetSequence(ds2);
 558     sqs = new SequenceI[] { seq };
 559     e = command.new Edit(Action.DELETE_GAP, sqs, 2, 1, '-');
 560     command.addEdit(e);
 561     seq = new Sequence("", "FGHIJ");
 562     seq.setDatasetSequence(ds2);
 563     sqs = new SequenceI[] { seq };
 564     e = command.new Edit(Action.DELETE_GAP, sqs, 4, 2, '-');
 565     command.addEdit(e);
 566
 567     /*
 568      * One edit for the third sequence.
 569      */
 570     seq = new Sequence("", "MNOPQ");
 571     SequenceI ds3 = new Sequence("", "MNOPQ");
 572     seq.setDatasetSequence(ds3);
 573     sqs = new SequenceI[] { seq };
 574     e = command.new Edit(Action.DELETE_GAP, sqs, 1, 1, '-');
 575     command.addEdit(e);
 576
 577     Map<SequenceI, SequenceI> unwound = command.priorState(false);
 578     assertEquals(original1, unwound.get(ds1).getSequenceAsString());
 579     assertEquals(original2, unwound.get(ds2).getSequenceAsString());
 580     assertEquals(original3, unwound.get(ds3).getSequenceAsString());
 581   }
 582
 583   /**
 584    * Test that mimics 'remove all gapped columns' action. This generates a
 585    * series Delete Gap edits that each act on all sequences that share a gapped
 586    * column region.
 587    */
 588   @Test(groups = { "Functional" })
 589   public void testPriorState_removeGappedCols()
 590   {
 591     EditCommand command = new EditCommand();
 592     String original1 = "--ABC--DEF";
 593     String original2 = "-G-HI--J";
 594     String original3 = "-M-NO--PQ";
 595
 596     /*
 597      * First edit deletes the first column.
 598      */
 599     SequenceI seq1 = new Sequence("", "-ABC--DEF");
 600     SequenceI ds1 = new Sequence("", "ABCDEF");
 601     seq1.setDatasetSequence(ds1);
 602     SequenceI seq2 = new Sequence("", "G-HI--J");
 603     SequenceI ds2 = new Sequence("", "GHIJ");
 604     seq2.setDatasetSequence(ds2);
 605     SequenceI seq3 = new Sequence("", "M-NO--PQ");
 606     SequenceI ds3 = new Sequence("", "MNOPQ");
 607     seq3.setDatasetSequence(ds3);
 608     SequenceI[] sqs = new SequenceI[] { seq1, seq2, seq3 };
 609     Edit e = command.new Edit(Action.DELETE_GAP, sqs, 0, 1, '-');
 610     command.addEdit(e);
 611
 612     /*
 613      * Second edit deletes what is now columns 4 and 5.
 614      */
 615     seq1 = new Sequence("", "-ABCDEF");
 616     seq1.setDatasetSequence(ds1);
 617     seq2 = new Sequence("", "G-HIJ");
 618     seq2.setDatasetSequence(ds2);
 619     seq3 = new Sequence("", "M-NOPQ");
 620     seq3.setDatasetSequence(ds3);
 621     sqs = new SequenceI[] { seq1, seq2, seq3 };
 622     e = command.new Edit(Action.DELETE_GAP, sqs, 4, 2, '-');
 623     command.addEdit(e);
 624
 625     Map<SequenceI, SequenceI> unwound = command.priorState(false);
 626     assertEquals(original1, unwound.get(ds1).getSequenceAsString());
 627     assertEquals(original2, unwound.get(ds2).getSequenceAsString());
 628     assertEquals(original3, unwound.get(ds3).getSequenceAsString());
 629     assertEquals(ds1, unwound.get(ds1).getDatasetSequence());
 630     assertEquals(ds2, unwound.get(ds2).getDatasetSequence());
 631     assertEquals(ds3, unwound.get(ds3).getDatasetSequence());
 632   }
 633 }