X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FHiddenSequencesTest.java;h=779598808f8622ef88748c6e4006c20770d1686b;hb=136c0793b90b72b928c4d77dc109dd5c644e00d3;hp=cae3536eb2592e6b9397185ca4e07fe09d8fb468;hpb=8677e6e34e291edc58c1da2fc9c958473754143f;p=jalview.git diff --git a/test/jalview/datamodel/HiddenSequencesTest.java b/test/jalview/datamodel/HiddenSequencesTest.java index cae3536..7795988 100644 --- a/test/jalview/datamodel/HiddenSequencesTest.java +++ b/test/jalview/datamodel/HiddenSequencesTest.java @@ -49,7 +49,7 @@ public class HiddenSequencesTest JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); } - static int SEQ_COUNT = 10; + static int SEQ_COUNT = 25; SequenceI[] seqs; @@ -62,8 +62,9 @@ public class HiddenSequencesTest seqs = new SequenceI[SEQ_COUNT]; for (int i = 0; i < SEQ_COUNT; i++) { - // sequence lengths are 1, 2, ... 10 - seqs[i] = new Sequence("Seq" + i, "abcdefghijk".substring(0, i + 1)); + // sequence lengths are 1, 2, ... 25 + seqs[i] = new Sequence("Seq" + i, + "abcdefghijklmnopqrstuvwxy".substring(0, i + 1)); } } @@ -89,7 +90,7 @@ public class HiddenSequencesTest /* * alignment is now seq0/2/3/4/7/8/9 */ - assertEquals(7, al.getHeight()); + assertEquals(SEQ_COUNT - 3, al.getHeight()); assertEquals(0, hs.adjustForHiddenSeqs(0)); assertEquals(2, hs.adjustForHiddenSeqs(1)); assertEquals(3, hs.adjustForHiddenSeqs(2)); @@ -193,7 +194,7 @@ public class HiddenSequencesTest /* * alignment is now seq0/2/3/4/7/8/9 */ - assertEquals(7, al.getHeight()); + assertEquals(SEQ_COUNT - 3, al.getHeight()); assertEquals(0, hs.findIndexWithoutHiddenSeqs(0)); assertEquals(0, hs.findIndexWithoutHiddenSeqs(1)); assertEquals(1, hs.findIndexWithoutHiddenSeqs(2)); @@ -207,6 +208,76 @@ public class HiddenSequencesTest } /** + * Test the method that finds the visible row position a given distance before + * another row + */ + @Test(groups = { "Functional" }) + public void testFindIndexNFromRow() + { + AlignmentI al = new Alignment(seqs); + HiddenSequences hs = new HiddenSequences(al); + + // test that without hidden rows, findIndexNFromRow returns + // position n above provided position + int pos = hs.subtractVisibleRows(3, 10); + assertEquals(7, pos); + + // 0 returns same position + pos = hs.subtractVisibleRows(0, 10); + assertEquals(10, pos); + + // overflow to top returns negative number + pos = hs.subtractVisibleRows(3, 0); + assertEquals(-3, pos); + + // test that with hidden rows above result row + // behaviour is the same as above + hs.hideSequence(seqs[1]); + hs.hideSequence(seqs[2]); + hs.hideSequence(seqs[3]); + + // position n above provided position + pos = hs.subtractVisibleRows(3, 10); + assertEquals(7, pos); + + // 0 returns same position + pos = hs.subtractVisibleRows(0, 10); + assertEquals(10, pos); + + // test with one set of hidden rows between start and required position + hs.hideSequence(seqs[12]); + hs.hideSequence(seqs[13]); + hs.hideSequence(seqs[14]); + hs.hideSequence(seqs[15]); + pos = hs.subtractVisibleRows(8, 17); + assertEquals(5, pos); + + // test with two sets of hidden rows between start and required position + hs.hideSequence(seqs[20]); + hs.hideSequence(seqs[21]); + pos = hs.subtractVisibleRows(8, 23); + assertEquals(9, pos); + + // repeat last 2 tests with no hidden columns to left of required position + hs.showAll(null); + + // test with one set of hidden rows between start and required position + hs.hideSequence(seqs[12]); + hs.hideSequence(seqs[13]); + hs.hideSequence(seqs[14]); + hs.hideSequence(seqs[15]); + pos = hs.subtractVisibleRows(8, 17); + assertEquals(5, pos); + + // test with two sets of hidden rows between start and required position + hs.hideSequence(seqs[20]); + hs.hideSequence(seqs[21]); + pos = hs.subtractVisibleRows(8, 23); + assertEquals(9, pos); + + } + + /** * Test the method that reconstructs (sort of) the full alignment including * hidden sequences */ @@ -289,7 +360,7 @@ public class HiddenSequencesTest assertTrue(al.getSequences().contains(seqs[1])); HiddenSequences hs = al.getHiddenSequences(); assertEquals(0, hs.getSize()); - assertEquals(10, al.getHeight()); + assertEquals(SEQ_COUNT, al.getHeight()); /* * hide the second sequence in the alignment @@ -299,7 +370,7 @@ public class HiddenSequencesTest assertTrue(hs.isHidden(seqs[1])); assertFalse(al.getSequences().contains(seqs[1])); assertEquals(1, hs.getSize()); - assertEquals(9, al.getHeight()); + assertEquals(SEQ_COUNT - 1, al.getHeight()); assertSame(seqs[2], al.getSequenceAt(1)); /* @@ -312,7 +383,7 @@ public class HiddenSequencesTest assertFalse(al.getSequences().contains(seqs[1])); assertFalse(al.getSequences().contains(seqs[2])); assertEquals(2, hs.getSize()); - assertEquals(8, al.getHeight()); + assertEquals(SEQ_COUNT - 2, al.getHeight()); /* * perform 'reveal' on what is now the second sequence in the alignment @@ -323,7 +394,54 @@ public class HiddenSequencesTest assertTrue(revealed.contains(seqs[1])); assertTrue(revealed.contains(seqs[2])); assertEquals(0, hs.getSize()); - assertEquals(10, al.getHeight()); + assertEquals(SEQ_COUNT, al.getHeight()); + } + + /** + * Test the method that adds a sequence to the hidden sequences and deletes it + * from the alignment, and its converse, where the first hidden sequences are + * at the bottom of the alignment (JAL-2437) + */ + @Test(groups = "Functional") + public void testHideShowLastSequences() + { + AlignmentI al = new Alignment(seqs); + assertTrue(al.getSequences().contains(seqs[1])); + HiddenSequences hs = al.getHiddenSequences(); + assertEquals(0, hs.getSize()); + assertEquals(SEQ_COUNT, al.getHeight()); + + /* + * hide the last sequence in the alignment + */ + hs.hideSequence(seqs[SEQ_COUNT - 1]); + assertFalse(hs.isHidden(seqs[SEQ_COUNT - 2])); + assertTrue(hs.isHidden(seqs[SEQ_COUNT - 1])); + assertFalse(al.getSequences().contains(seqs[SEQ_COUNT - 1])); + assertEquals(1, hs.getSize()); + assertEquals(SEQ_COUNT - 1, al.getHeight()); + + /* + * hide the third last sequence in the alignment + */ + hs.hideSequence(seqs[SEQ_COUNT - 3]); + assertFalse(hs.isHidden(seqs[SEQ_COUNT - 2])); + assertTrue(hs.isHidden(seqs[SEQ_COUNT - 3])); + assertFalse(al.getSequences().contains(seqs[SEQ_COUNT - 3])); + assertEquals(2, hs.getSize()); + assertEquals(SEQ_COUNT - 2, al.getHeight()); + + /* + * reveal all the sequences, which should be reinstated in the same order as they started in + */ + hs.showAll(null); + assertFalse(hs.isHidden(seqs[SEQ_COUNT - 3])); + assertFalse(hs.isHidden(seqs[SEQ_COUNT - 1])); + assertEquals(seqs[SEQ_COUNT - 3], al.getSequences().get(SEQ_COUNT - 3)); + assertEquals(seqs[SEQ_COUNT - 2], al.getSequences().get(SEQ_COUNT - 2)); + assertEquals(seqs[SEQ_COUNT - 1], al.getSequences().get(SEQ_COUNT - 1)); + assertEquals(0, hs.getSize()); + assertEquals(SEQ_COUNT, al.getHeight()); } @Test(groups = "Functional")