+/*
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9)
+ * Copyright (C) 2015 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 <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
+ */
package jalview.commands;
import static org.testng.AssertJUnit.assertEquals;
private Alignment al;
- @BeforeMethod
+ @BeforeMethod(alwaysRun = true)
public void setUp()
{
testee = new EditCommand();
/**
* Test inserting gap characters
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testAppendEdit_insertGap()
{
// set a non-standard gap character to prove it is actually used
* Test deleting characters from sequences. Note the deleteGap() action does
* not check that only gap characters are being removed.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testAppendEdit_deleteGap()
{
testee.appendEdit(Action.DELETE_GAP, seqs, 4, 3, al, true);
* Test a cut action. The command should store the cut characters to support
* undo.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testCut()
{
Edit ec = testee.new Edit(Action.CUT, seqs, 4, 3, al);
- testee.cut(ec, new AlignmentI[]
- { al });
+ testee.cut(ec, new AlignmentI[] { al });
assertEquals("abcdhjk", seqs[0].getSequenceAsString());
assertEquals("fghjnopq", seqs[1].getSequenceAsString());
assertEquals("qrstxyz", seqs[2].getSequenceAsString());
/**
* Test a Paste action, where this adds sequences to an alignment.
*/
- @Test(groups =
- { "Functional" }, enabled = false)
+ @Test(groups = { "Functional" }, enabled = false)
// TODO fix so it works
public void testPaste_addToAlignment()
{
newSeqs[1] = new Sequence("newseq1", "JWMPDH");
Edit ec = testee.new Edit(Action.PASTE, newSeqs, 0, al.getWidth(), al);
- testee.paste(ec, new AlignmentI[]
- { al });
+ testee.paste(ec, new AlignmentI[] { al });
assertEquals(6, al.getSequences().size());
assertEquals("1234567890", seqs[3].getSequenceAsString());
assertEquals("ACEFKL", seqs[4].getSequenceAsString());
/**
* Test insertGap followed by undo command
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testUndo_insertGap()
{
// Edit ec = testee.new Edit(Action.INSERT_GAP, seqs, 4, 3, '?');
testee.appendEdit(Action.INSERT_GAP, seqs, 4, 3, al, true);
// check something changed
assertEquals("abcd???efghjk", seqs[0].getSequenceAsString());
- testee.undoCommand(new AlignmentI[]
- { al });
+ testee.undoCommand(new AlignmentI[] { al });
assertEquals("abcdefghjk", seqs[0].getSequenceAsString());
assertEquals("fghjklmnopq", seqs[1].getSequenceAsString());
assertEquals("qrstuvwxyz", seqs[2].getSequenceAsString());
/**
* Test deleteGap followed by undo command
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testUndo_deleteGap()
{
testee.appendEdit(Action.DELETE_GAP, seqs, 4, 3, al, true);
// check something changed
assertEquals("abcdhjk", seqs[0].getSequenceAsString());
- testee.undoCommand(new AlignmentI[]
- { al });
+ testee.undoCommand(new AlignmentI[] { al });
// deleteGap doesn't 'remember' deleted characters, only gaps get put back
assertEquals("abcd???hjk", seqs[0].getSequenceAsString());
assertEquals("fghj???nopq", seqs[1].getSequenceAsString());
/**
* Test several commands followed by an undo command
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testUndo_multipleCommands()
{
// delete positions 3/4/5 (counting from 1)
assertEquals("12?890", seqs[3].getSequenceAsString());
// undo edit commands
- testee.undoCommand(new AlignmentI[]
- { al });
+ testee.undoCommand(new AlignmentI[] { al });
assertEquals("ab?????hjk", seqs[0].getSequenceAsString());
assertEquals("12?????890", seqs[3].getSequenceAsString());
}
* Unit test for JAL-1594 bug: click and drag sequence right to insert gaps -
* undo did not remove them all.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testUndo_multipleInsertGaps()
{
testee.appendEdit(Action.INSERT_GAP, seqs, 4, 1, al, true);
testee.appendEdit(Action.INSERT_GAP, seqs, 6, 1, al, true);
// undo edit commands
- testee.undoCommand(new AlignmentI[]
- { al });
+ testee.undoCommand(new AlignmentI[] { al });
assertEquals("abcdefghjk", seqs[0].getSequenceAsString());
assertEquals("1234567890", seqs[3].getSequenceAsString());
/**
* Test cut followed by undo command
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testUndo_cut()
{
testee.appendEdit(Action.CUT, seqs, 4, 3, al, true);
// check something changed
assertEquals("abcdhjk", seqs[0].getSequenceAsString());
- testee.undoCommand(new AlignmentI[]
- { al });
+ testee.undoCommand(new AlignmentI[] { al });
assertEquals("abcdefghjk", seqs[0].getSequenceAsString());
assertEquals("fghjklmnopq", seqs[1].getSequenceAsString());
assertEquals("qrstuvwxyz", seqs[2].getSequenceAsString());
/**
* Test the replace command (used to manually edit a sequence)
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testReplace()
{
// seem to need a dataset sequence on the edited sequence here
seqs[1].setDatasetSequence(seqs[1]);
- new EditCommand("", Action.REPLACE, "ZXY", new SequenceI[]
- { seqs[1] }, 4, 8, al);
+ new EditCommand("", Action.REPLACE, "ZXY", new SequenceI[] { seqs[1] },
+ 4, 8, al);
assertEquals("abcdefghjk", seqs[0].getSequenceAsString());
assertEquals("qrstuvwxyz", seqs[2].getSequenceAsString());
assertEquals("1234567890", seqs[3].getSequenceAsString());
* Test that the addEdit command correctly merges insert gap commands when
* possible.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testAddEdit_multipleInsertGap()
{
/*
* 3 insert gap in a row (aka mouse drag right):
*/
- Edit e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[]
- { seqs[0] }, 1, 1, al);
+ Edit e = new EditCommand().new Edit(Action.INSERT_GAP,
+ new SequenceI[] { seqs[0] }, 1, 1, al);
testee.addEdit(e);
SequenceI edited = new Sequence("seq0", "a?bcdefghjk");
edited.setDatasetSequence(seqs[0].getDatasetSequence());
- e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[]
- { edited }, 2, 1, al);
+ e = new EditCommand().new Edit(Action.INSERT_GAP,
+ new SequenceI[] { edited }, 2, 1, al);
testee.addEdit(e);
edited = new Sequence("seq0", "a??bcdefghjk");
edited.setDatasetSequence(seqs[0].getDatasetSequence());
- e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[]
- { edited }, 3, 1, al);
+ e = new EditCommand().new Edit(Action.INSERT_GAP,
+ new SequenceI[] { edited }, 3, 1, al);
testee.addEdit(e);
assertEquals(1, testee.getSize());
assertEquals(Action.INSERT_GAP, testee.getEdit(0).getAction());
/*
* Add a non-contiguous edit - should not be merged.
*/
- e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[]
- { edited }, 5, 2, al);
+ e = new EditCommand().new Edit(Action.INSERT_GAP,
+ new SequenceI[] { edited }, 5, 2, al);
testee.addEdit(e);
assertEquals(2, testee.getSize());
assertEquals(5, testee.getEdit(1).getPosition());
/*
* Add a Delete after the Insert - should not be merged.
*/
- e = new EditCommand().new Edit(Action.DELETE_GAP, new SequenceI[]
- { edited }, 6, 2, al);
+ e = new EditCommand().new Edit(Action.DELETE_GAP,
+ new SequenceI[] { edited }, 6, 2, al);
testee.addEdit(e);
assertEquals(3, testee.getSize());
assertEquals(Action.DELETE_GAP, testee.getEdit(2).getAction());
* Test that the addEdit command correctly merges delete gap commands when
* possible.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testAddEdit_multipleDeleteGap()
{
/*
* 3 delete gap in a row (aka mouse drag left):
*/
seqs[0].setSequence("a???bcdefghjk");
- Edit e = new EditCommand().new Edit(Action.DELETE_GAP, new SequenceI[]
- { seqs[0] }, 4, 1, al);
+ Edit e = new EditCommand().new Edit(Action.DELETE_GAP,
+ new SequenceI[] { seqs[0] }, 4, 1, al);
testee.addEdit(e);
assertEquals(1, testee.getSize());
SequenceI edited = new Sequence("seq0", "a??bcdefghjk");
edited.setDatasetSequence(seqs[0].getDatasetSequence());
- e = new EditCommand().new Edit(Action.DELETE_GAP, new SequenceI[]
- { edited }, 3, 1, al);
+ e = new EditCommand().new Edit(Action.DELETE_GAP,
+ new SequenceI[] { edited }, 3, 1, al);
testee.addEdit(e);
assertEquals(1, testee.getSize());
edited = new Sequence("seq0", "a?bcdefghjk");
edited.setDatasetSequence(seqs[0].getDatasetSequence());
- e = new EditCommand().new Edit(Action.DELETE_GAP, new SequenceI[]
- { edited }, 2, 1, al);
+ e = new EditCommand().new Edit(Action.DELETE_GAP,
+ new SequenceI[] { edited }, 2, 1, al);
testee.addEdit(e);
assertEquals(1, testee.getSize());
assertEquals(Action.DELETE_GAP, testee.getEdit(0).getAction());
/*
* Add a non-contiguous edit - should not be merged.
*/
- e = new EditCommand().new Edit(Action.DELETE_GAP, new SequenceI[]
- { edited }, 2, 1, al);
+ e = new EditCommand().new Edit(Action.DELETE_GAP,
+ new SequenceI[] { edited }, 2, 1, al);
testee.addEdit(e);
assertEquals(2, testee.getSize());
assertEquals(Action.DELETE_GAP, testee.getEdit(0).getAction());
/*
* Add an Insert after the Delete - should not be merged.
*/
- e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[]
- { edited }, 1, 1, al);
+ e = new EditCommand().new Edit(Action.INSERT_GAP,
+ new SequenceI[] { edited }, 1, 1, al);
testee.addEdit(e);
assertEquals(3, testee.getSize());
assertEquals(Action.INSERT_GAP, testee.getEdit(2).getAction());
* case when they appear contiguous but are acting on different sequences.
* They should not be merged.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testAddEdit_removeAllGaps()
{
seqs[0].setSequence("a???bcdefghjk");
- Edit e = new EditCommand().new Edit(Action.DELETE_GAP, new SequenceI[]
- { seqs[0] }, 4, 1, al);
+ Edit e = new EditCommand().new Edit(Action.DELETE_GAP,
+ new SequenceI[] { seqs[0] }, 4, 1, al);
testee.addEdit(e);
seqs[1].setSequence("f??ghjklmnopq");
* Test that the addEdit command correctly merges insert gap commands acting
* on a multi-sequence selection.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testAddEdit_groupInsertGaps()
{
/*
* 2 insert gap in a row (aka mouse drag right), on two sequences:
*/
- Edit e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[]
- { seqs[0], seqs[1] }, 1, 1, al);
+ Edit e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[] {
+ seqs[0], seqs[1] }, 1, 1, al);
testee.addEdit(e);
SequenceI seq1edited = new Sequence("seq0", "a?bcdefghjk");
seq1edited.setDatasetSequence(seqs[0].getDatasetSequence());
SequenceI seq2edited = new Sequence("seq1", "f?ghjklmnopq");
seq2edited.setDatasetSequence(seqs[1].getDatasetSequence());
- e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[]
- { seq1edited, seq2edited }, 2, 1, al);
+ e = new EditCommand().new Edit(Action.INSERT_GAP, new SequenceI[] {
+ seq1edited, seq2edited }, 2, 1, al);
testee.addEdit(e);
assertEquals(1, testee.getSize());
* <li>last: --A--B-CDEF</li>
* </ul>
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testPriorState_multipleInserts()
{
EditCommand command = new EditCommand();
SequenceI seq = new Sequence("", "--A--B-CDEF");
SequenceI ds = new Sequence("", "ABCDEF");
seq.setDatasetSequence(ds);
- SequenceI[] seqs = new SequenceI[]
- { seq };
+ SequenceI[] seqs = new SequenceI[] { seq };
Edit e = command.new Edit(Action.INSERT_GAP, seqs, 1, 2, '-');
command.addEdit(e);
e = command.new Edit(Action.INSERT_GAP, seqs, 4, 1, '-');
* <li>End: ABC</li>
* </ul>
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testPriorState_removeAllGaps()
{
EditCommand command = new EditCommand();
SequenceI seq = new Sequence("", "ABC");
SequenceI ds = new Sequence("", "ABC");
seq.setDatasetSequence(ds);
- SequenceI[] seqs = new SequenceI[]
- { seq };
+ SequenceI[] seqs = new SequenceI[] { seq };
Edit e = command.new Edit(Action.DELETE_GAP, seqs, 1, 1, '-');
command.addEdit(e);
e = command.new Edit(Action.DELETE_GAP, seqs, 2, 1, '-');
/**
* Test for 'undoing' a single delete edit.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testPriorState_singleDelete()
{
EditCommand command = new EditCommand();
SequenceI seq = new Sequence("", "ABCDEF");
SequenceI ds = new Sequence("", "ABCDEF");
seq.setDatasetSequence(ds);
- SequenceI[] seqs = new SequenceI[]
- { seq };
+ SequenceI[] seqs = new SequenceI[] { seq };
Edit e = command.new Edit(Action.DELETE_GAP, seqs, 2, 2, '-');
command.addEdit(e);
-
+
Map<SequenceI, SequenceI> unwound = command.priorState(false);
assertEquals("AB--CDEF", unwound.get(ds).getSequenceAsString());
}
/**
* Test 'undoing' a single gap insertion edit command.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testPriorState_singleInsert()
{
EditCommand command = new EditCommand();
SequenceI seq = new Sequence("", "AB---CDEF");
SequenceI ds = new Sequence("", "ABCDEF");
seq.setDatasetSequence(ds);
- SequenceI[] seqs = new SequenceI[]
- { seq };
+ SequenceI[] seqs = new SequenceI[] { seq };
Edit e = command.new Edit(Action.INSERT_GAP, seqs, 2, 3, '-');
command.addEdit(e);
-
+
Map<SequenceI, SequenceI> unwound = command.priorState(false);
assertEquals("ABCDEF", unwound.get(ds).getSequenceAsString());
}
* Test that mimics 'remove all gaps' action. This generates delete gap edits
* for contiguous gaps in each sequence separately.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testPriorState_removeGapsMultipleSeqs()
{
EditCommand command = new EditCommand();
SequenceI seq = new Sequence("", "ABC-DEF");
SequenceI ds1 = new Sequence("", "ABCDEF");
seq.setDatasetSequence(ds1);
- SequenceI[] seqs = new SequenceI[]
- { seq };
+ SequenceI[] seqs = new SequenceI[] { seq };
Edit e = command.new Edit(Action.DELETE_GAP, seqs, 0, 2, '-');
command.addEdit(e);
seq = new Sequence("", "ABCDEF");
seq.setDatasetSequence(ds1);
- seqs = new SequenceI[]
- { seq };
+ seqs = new SequenceI[] { seq };
e = command.new Edit(Action.DELETE_GAP, seqs, 3, 1, '-');
command.addEdit(e);
-
+
/*
* Two edits for the second sequence
*/
seq = new Sequence("", "FGHI--J");
SequenceI ds2 = new Sequence("", "FGHIJ");
seq.setDatasetSequence(ds2);
- seqs = new SequenceI[]
- { seq };
+ seqs = new SequenceI[] { seq };
e = command.new Edit(Action.DELETE_GAP, seqs, 2, 1, '-');
command.addEdit(e);
seq = new Sequence("", "FGHIJ");
seq.setDatasetSequence(ds2);
- seqs = new SequenceI[]
- { seq };
+ seqs = new SequenceI[] { seq };
e = command.new Edit(Action.DELETE_GAP, seqs, 4, 2, '-');
command.addEdit(e);
seq = new Sequence("", "MNOPQ");
SequenceI ds3 = new Sequence("", "MNOPQ");
seq.setDatasetSequence(ds3);
- seqs = new SequenceI[]
- { seq };
+ seqs = new SequenceI[] { seq };
e = command.new Edit(Action.DELETE_GAP, seqs, 1, 1, '-');
command.addEdit(e);
* series Delete Gap edits that each act on all sequences that share a gapped
* column region.
*/
- @Test(groups ={ "Functional" })
+ @Test(groups = { "Functional" })
public void testPriorState_removeGappedCols()
{
EditCommand command = new EditCommand();
SequenceI seq3 = new Sequence("", "M-NO--PQ");
SequenceI ds3 = new Sequence("", "MNOPQ");
seq3.setDatasetSequence(ds3);
- SequenceI[] seqs = new SequenceI[]
- { seq1, seq2, seq3 };
+ SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3 };
Edit e = command.new Edit(Action.DELETE_GAP, seqs, 0, 1, '-');
command.addEdit(e);
seq2.setDatasetSequence(ds2);
seq3 = new Sequence("", "M-NOPQ");
seq3.setDatasetSequence(ds3);
- seqs = new SequenceI[]
- { seq1, seq2, seq3 };
+ seqs = new SequenceI[] { seq1, seq2, seq3 };
e = command.new Edit(Action.DELETE_GAP, seqs, 4, 2, '-');
command.addEdit(e);
git://source.jalview.org / jalview.git / blobdiff