X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fcommands%2FEditCommandTest.java;h=155f00eee8972351d8f38ecf5a66c123eb7aaa4e;hb=091704be1e1e54b7990e8e6a10f7c0fd12d33416;hp=69379d0f845615dda44c7ae7a5a3f444c518ecf6;hpb=8f118c154e74caaef6bec19acd0466904ac424d4;p=jalview.git diff --git a/test/jalview/commands/EditCommandTest.java b/test/jalview/commands/EditCommandTest.java index 69379d0..155f00e 100644 --- a/test/jalview/commands/EditCommandTest.java +++ b/test/jalview/commands/EditCommandTest.java @@ -21,6 +21,7 @@ package jalview.commands; import static org.testng.AssertJUnit.assertEquals; +import static org.testng.AssertJUnit.assertNull; import static org.testng.AssertJUnit.assertSame; import jalview.commands.EditCommand.Action; @@ -28,10 +29,16 @@ import jalview.commands.EditCommand.Edit; import jalview.datamodel.Alignment; import jalview.datamodel.AlignmentI; import jalview.datamodel.Sequence; +import jalview.datamodel.SequenceFeature; import jalview.datamodel.SequenceI; +import jalview.datamodel.features.SequenceFeatures; +import jalview.gui.JvOptionPane; +import java.util.List; import java.util.Map; +import org.testng.Assert; +import org.testng.annotations.BeforeClass; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; @@ -43,6 +50,21 @@ import org.testng.annotations.Test; */ public class EditCommandTest { + /* + * compute n(n+1)/2 e.g. + * func(5) = 5 + 4 + 3 + 2 + 1 = 15 + */ + private static int func(int i) + { + return i * (i + 1) / 2; + } + + @BeforeClass(alwaysRun = true) + public void setUpJvOptionPane() + { + JvOptionPane.setInteractiveMode(false); + JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); + } private EditCommand testee; @@ -105,7 +127,7 @@ public class EditCommandTest public void testCut() { Edit ec = testee.new Edit(Action.CUT, seqs, 4, 3, al); - testee.cut(ec, new AlignmentI[] { al }); + EditCommand.cut(ec, new AlignmentI[] { al }); assertEquals("abcdhjk", seqs[0].getSequenceAsString()); assertEquals("fghjnopq", seqs[1].getSequenceAsString()); assertEquals("qrstxyz", seqs[2].getSequenceAsString()); @@ -130,7 +152,7 @@ public class EditCommandTest newSeqs[1] = new Sequence("newseq1", "JWMPDH"); Edit ec = testee.new Edit(Action.PASTE, newSeqs, 0, al.getWidth(), al); - testee.paste(ec, new AlignmentI[] { al }); + EditCommand.paste(ec, new AlignmentI[] { al }); assertEquals(6, al.getSequences().size()); assertEquals("1234567890", seqs[3].getSequenceAsString()); assertEquals("ACEFKL", seqs[4].getSequenceAsString()); @@ -239,7 +261,7 @@ public class EditCommandTest public void testReplace() { // seem to need a dataset sequence on the edited sequence here - seqs[1].setDatasetSequence(seqs[1]); + seqs[1].createDatasetSequence(); new EditCommand("", Action.REPLACE, "ZXY", new SequenceI[] { seqs[1] }, 4, 8, al); assertEquals("abcdefghjk", seqs[0].getSequenceAsString()); @@ -423,12 +445,12 @@ public class EditCommandTest SequenceI seq = new Sequence("", "--A--B-CDEF"); SequenceI ds = new Sequence("", "ABCDEF"); seq.setDatasetSequence(ds); - SequenceI[] seqs = new SequenceI[] { seq }; - Edit e = command.new Edit(Action.INSERT_GAP, seqs, 1, 2, '-'); + SequenceI[] sqs = new SequenceI[] { seq }; + Edit e = command.new Edit(Action.INSERT_GAP, sqs, 1, 2, '-'); command.addEdit(e); - e = command.new Edit(Action.INSERT_GAP, seqs, 4, 1, '-'); + e = command.new Edit(Action.INSERT_GAP, sqs, 4, 1, '-'); command.addEdit(e); - e = command.new Edit(Action.INSERT_GAP, seqs, 0, 2, '-'); + e = command.new Edit(Action.INSERT_GAP, sqs, 0, 2, '-'); command.addEdit(e); Map unwound = command.priorState(false); @@ -450,10 +472,10 @@ public class EditCommandTest SequenceI seq = new Sequence("", "ABC"); SequenceI ds = new Sequence("", "ABC"); seq.setDatasetSequence(ds); - SequenceI[] seqs = new SequenceI[] { seq }; - Edit e = command.new Edit(Action.DELETE_GAP, seqs, 1, 1, '-'); + SequenceI[] sqs = new SequenceI[] { seq }; + Edit e = command.new Edit(Action.DELETE_GAP, sqs, 1, 1, '-'); command.addEdit(e); - e = command.new Edit(Action.DELETE_GAP, seqs, 2, 1, '-'); + e = command.new Edit(Action.DELETE_GAP, sqs, 2, 1, '-'); command.addEdit(e); Map unwound = command.priorState(false); @@ -470,8 +492,8 @@ public class EditCommandTest SequenceI seq = new Sequence("", "ABCDEF"); SequenceI ds = new Sequence("", "ABCDEF"); seq.setDatasetSequence(ds); - SequenceI[] seqs = new SequenceI[] { seq }; - Edit e = command.new Edit(Action.DELETE_GAP, seqs, 2, 2, '-'); + SequenceI[] sqs = new SequenceI[] { seq }; + Edit e = command.new Edit(Action.DELETE_GAP, sqs, 2, 2, '-'); command.addEdit(e); Map unwound = command.priorState(false); @@ -488,12 +510,38 @@ public class EditCommandTest SequenceI seq = new Sequence("", "AB---CDEF"); SequenceI ds = new Sequence("", "ABCDEF"); seq.setDatasetSequence(ds); - SequenceI[] seqs = new SequenceI[] { seq }; - Edit e = command.new Edit(Action.INSERT_GAP, seqs, 2, 3, '-'); + SequenceI[] sqs = new SequenceI[] { seq }; + Edit e = command.new Edit(Action.INSERT_GAP, sqs, 2, 3, '-'); command.addEdit(e); Map unwound = command.priorState(false); - assertEquals("ABCDEF", unwound.get(ds).getSequenceAsString()); + SequenceI prior = unwound.get(ds); + assertEquals("ABCDEF", prior.getSequenceAsString()); + assertEquals(1, prior.getStart()); + assertEquals(6, prior.getEnd()); + } + + /** + * Test 'undoing' a single gap insertion edit command, on a sequence whose + * start residue is other than 1 + */ + @Test(groups = { "Functional" }) + public void testPriorState_singleInsertWithOffset() + { + EditCommand command = new EditCommand(); + SequenceI seq = new Sequence("", "AB---CDEF", 8, 13); + // SequenceI ds = new Sequence("", "ABCDEF", 8, 13); + // seq.setDatasetSequence(ds); + seq.createDatasetSequence(); + SequenceI[] sqs = new SequenceI[] { seq }; + Edit e = command.new Edit(Action.INSERT_GAP, sqs, 2, 3, '-'); + command.addEdit(e); + + Map unwound = command.priorState(false); + SequenceI prior = unwound.get(seq.getDatasetSequence()); + assertEquals("ABCDEF", prior.getSequenceAsString()); + assertEquals(8, prior.getStart()); + assertEquals(13, prior.getEnd()); } /** @@ -514,13 +562,13 @@ public class EditCommandTest SequenceI seq = new Sequence("", "ABC-DEF"); SequenceI ds1 = new Sequence("", "ABCDEF"); seq.setDatasetSequence(ds1); - SequenceI[] seqs = new SequenceI[] { seq }; - Edit e = command.new Edit(Action.DELETE_GAP, seqs, 0, 2, '-'); + SequenceI[] sqs = new SequenceI[] { seq }; + Edit e = command.new Edit(Action.DELETE_GAP, sqs, 0, 2, '-'); command.addEdit(e); seq = new Sequence("", "ABCDEF"); seq.setDatasetSequence(ds1); - seqs = new SequenceI[] { seq }; - e = command.new Edit(Action.DELETE_GAP, seqs, 3, 1, '-'); + sqs = new SequenceI[] { seq }; + e = command.new Edit(Action.DELETE_GAP, sqs, 3, 1, '-'); command.addEdit(e); /* @@ -529,13 +577,13 @@ public class EditCommandTest seq = new Sequence("", "FGHI--J"); SequenceI ds2 = new Sequence("", "FGHIJ"); seq.setDatasetSequence(ds2); - seqs = new SequenceI[] { seq }; - e = command.new Edit(Action.DELETE_GAP, seqs, 2, 1, '-'); + sqs = new SequenceI[] { seq }; + e = command.new Edit(Action.DELETE_GAP, sqs, 2, 1, '-'); command.addEdit(e); seq = new Sequence("", "FGHIJ"); seq.setDatasetSequence(ds2); - seqs = new SequenceI[] { seq }; - e = command.new Edit(Action.DELETE_GAP, seqs, 4, 2, '-'); + sqs = new SequenceI[] { seq }; + e = command.new Edit(Action.DELETE_GAP, sqs, 4, 2, '-'); command.addEdit(e); /* @@ -544,8 +592,8 @@ public class EditCommandTest seq = new Sequence("", "MNOPQ"); SequenceI ds3 = new Sequence("", "MNOPQ"); seq.setDatasetSequence(ds3); - seqs = new SequenceI[] { seq }; - e = command.new Edit(Action.DELETE_GAP, seqs, 1, 1, '-'); + sqs = new SequenceI[] { seq }; + e = command.new Edit(Action.DELETE_GAP, sqs, 1, 1, '-'); command.addEdit(e); Map unwound = command.priorState(false); @@ -579,8 +627,8 @@ public class EditCommandTest SequenceI seq3 = new Sequence("", "M-NO--PQ"); SequenceI ds3 = new Sequence("", "MNOPQ"); seq3.setDatasetSequence(ds3); - SequenceI[] seqs = new SequenceI[] { seq1, seq2, seq3 }; - Edit e = command.new Edit(Action.DELETE_GAP, seqs, 0, 1, '-'); + SequenceI[] sqs = new SequenceI[] { seq1, seq2, seq3 }; + Edit e = command.new Edit(Action.DELETE_GAP, sqs, 0, 1, '-'); command.addEdit(e); /* @@ -592,8 +640,8 @@ public class EditCommandTest seq2.setDatasetSequence(ds2); seq3 = new Sequence("", "M-NOPQ"); seq3.setDatasetSequence(ds3); - seqs = new SequenceI[] { seq1, seq2, seq3 }; - e = command.new Edit(Action.DELETE_GAP, seqs, 4, 2, '-'); + sqs = new SequenceI[] { seq1, seq2, seq3 }; + e = command.new Edit(Action.DELETE_GAP, sqs, 4, 2, '-'); command.addEdit(e); Map unwound = command.priorState(false); @@ -604,4 +652,222 @@ public class EditCommandTest assertEquals(ds2, unwound.get(ds2).getDatasetSequence()); assertEquals(ds3, unwound.get(ds3).getDatasetSequence()); } + + /** + * Test a cut action's relocation of sequence features + */ + @Test(groups = { "Functional" }) + public void testCut_withFeatures() + { + /* + * create sequence features before, after and overlapping + * a cut of columns/residues 4-7 + */ + SequenceI seq0 = seqs[0]; + seq0.addSequenceFeature(new SequenceFeature("before", "", 1, 3, 0f, + null)); + seq0.addSequenceFeature(new SequenceFeature("overlap left", "", 2, 6, + 0f, null)); + seq0.addSequenceFeature(new SequenceFeature("internal", "", 5, 6, 0f, + null)); + seq0.addSequenceFeature(new SequenceFeature("overlap right", "", 7, 8, + 0f, null)); + seq0.addSequenceFeature(new SequenceFeature("after", "", 8, 10, 0f, + null)); + + Edit ec = testee.new Edit(Action.CUT, seqs, 3, 4, al); // cols 3-6 base 0 + EditCommand.cut(ec, new AlignmentI[] { al }); + + List sfs = seq0.getSequenceFeatures(); + SequenceFeatures.sortFeatures(sfs, true); + + assertEquals(4, sfs.size()); // feature internal to cut has been deleted + SequenceFeature sf = sfs.get(0); + assertEquals("before", sf.getType()); + assertEquals(1, sf.getBegin()); + assertEquals(3, sf.getEnd()); + sf = sfs.get(1); + assertEquals("overlap left", sf.getType()); + assertEquals(2, sf.getBegin()); + assertEquals(3, sf.getEnd()); // truncated by cut + sf = sfs.get(2); + assertEquals("overlap right", sf.getType()); + assertEquals(4, sf.getBegin()); // shifted left by cut + assertEquals(5, sf.getEnd()); // truncated by cut + sf = sfs.get(3); + assertEquals("after", sf.getType()); + assertEquals(4, sf.getBegin()); // shifted left by cut + assertEquals(6, sf.getEnd()); // shifted left by cut + } + + /** + * Test a cut action's relocation of sequence features, with full coverage of + * all possible feature and cut locations for a 5-position ungapped sequence + */ + @Test(groups = { "Functional" }) + public void testCut_withFeatures_exhaustive() + { + /* + * create a sequence features on each subrange of 1-5 + */ + SequenceI seq0 = new Sequence("seq", "ABCDE"); + AlignmentI alignment = new Alignment(new SequenceI[] { seq0 }); + alignment.setDataset(null); + for (int from = 1; from <= seq0.getLength(); from++) + { + for (int to = from; to <= seq0.getLength(); to++) + { + String desc = String.format("%d-%d", from, to); + SequenceFeature sf = new SequenceFeature("test", desc, from, to, + 0f, + null); + sf.setValue("from", Integer.valueOf(from)); + sf.setValue("to", Integer.valueOf(to)); + seq0.addSequenceFeature(sf); + } + } + // sanity check + List sfs = seq0.getSequenceFeatures(); + assertEquals(func(5), sfs.size()); + + /* + * now perform all possible cuts of subranges of 1-5 (followed by Undo) + * and validate the resulting remaining sequence features! + */ + SequenceI[] sqs = new SequenceI[] { seq0 }; + + // goal is to have this passing for all from/to values!! + // for (int from = 0; from < seq0.getLength(); from++) + // { + // for (int to = from; to < seq0.getLength(); to++) + for (int from = 1; from < 3; from++) + { + for (int to = 2; to < 3; to++) + { + testee.appendEdit(Action.CUT, sqs, from, (to - from + 1), + alignment, true); + + sfs = seq0.getSequenceFeatures(); + + /* + * confirm the number of features has reduced by the + * number of features within the cut region i.e. by + * func(length of cut) + */ + String msg = String.format("Cut %d-%d ", from, to); + if (to - from == 4) + { + // all columns cut + assertNull(sfs); + } + else + { + assertEquals(msg + "wrong number of features left", func(5) + - func(to - from + 1), sfs.size()); + } + + /* + * inspect individual features + */ + if (sfs != null) + { + for (SequenceFeature sf : sfs) + { + checkFeatureRelocation(sf, from + 1, to + 1); + } + } + /* + * undo ready for next cut + */ + testee.undoCommand(new AlignmentI[] { alignment }); + assertEquals(func(5), seq0.getSequenceFeatures().size()); + } + } + } + + /** + * Helper method to check a feature has been correctly relocated after a cut + * + * @param sf + * @param from + * start of cut (first residue cut) + * @param to + * end of cut (last residue cut) + */ + private void checkFeatureRelocation(SequenceFeature sf, int from, int to) + { + // TODO handle the gapped sequence case as well + int cutSize = to - from + 1; + int oldFrom = ((Integer) sf.getValue("from")).intValue(); + int oldTo = ((Integer) sf.getValue("to")).intValue(); + + String msg = String.format( + "Feature %s relocated to %d-%d after cut of %d-%d", + sf.getDescription(), sf.getBegin(), sf.getEnd(), from, to); + if (oldTo < from) + { + // before cut region so unchanged + assertEquals("1: " + msg, oldFrom, sf.getBegin()); + assertEquals("2: " + msg, oldTo, sf.getEnd()); + } + else if (oldFrom > to) + { + // follows cut region - shift by size of cut + assertEquals("3: " + msg, oldFrom - cutSize, sf.getBegin()); + assertEquals("4: " + msg, oldTo - cutSize, sf.getEnd()); + } + else if (oldFrom < from && oldTo > to) + { + // feature encloses cut region - shrink it right + assertEquals("5: " + msg, oldFrom, sf.getBegin()); + assertEquals("6: " + msg, oldTo - cutSize, sf.getEnd()); + } + else if (oldFrom < from) + { + // feature overlaps left side of cut region - truncated right + assertEquals("7: " + msg, from - 1, sf.getEnd()); + } + else if (oldTo > to) + { + // feature overlaps right side of cut region - truncated left + assertEquals("8: " + msg, from, sf.getBegin()); + assertEquals("9: " + msg, from + oldTo - to - 1, sf.getEnd()); + } + else + { + // feature internal to cut - should have been deleted! + Assert.fail(msg + " - should have been deleted"); + } + } + + /** + * Test a cut action's relocation of sequence features + */ + @Test(groups = { "Functional" }) + public void testCut_gappedWithFeatures() + { + /* + * create sequence features before, after and overlapping + * a cut of columns/residues 4-7 + */ + SequenceI seq0 = new Sequence("seq", "A-BCC"); + seq0.addSequenceFeature(new SequenceFeature("", "", 3, 4, 0f, + null)); + AlignmentI alignment = new Alignment(new SequenceI[] { seq0 }); + // cut columns of A-B + Edit ec = testee.new Edit(Action.CUT, seqs, 0, 3, alignment); // cols 0-3 + // base 0 + EditCommand.cut(ec, new AlignmentI[] { alignment }); + + /* + * feature on CC(3-4) should now be on CC(1-2) + */ + List sfs = seq0.getSequenceFeatures(); + assertEquals(1, sfs.size()); + SequenceFeature sf = sfs.get(0); + assertEquals(1, sf.getBegin()); + assertEquals(2, sf.getEnd()); + + // TODO add further cases including Undo - see JAL-2541 + } }