X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FHiddenColumnsTest.java;h=291619978959643f7266efc2173b089f5506aaa9;hb=fa906a98b4d665e4bf2ab0ae3605c4682730bd83;hp=9bbba5fb623a44d7472eb05de868cd307f02a20e;hpb=8be202b71704e4b7e10e3a366446492623a3c322;p=jalview.git diff --git a/test/jalview/datamodel/HiddenColumnsTest.java b/test/jalview/datamodel/HiddenColumnsTest.java index 9bbba5f..2916199 100644 --- a/test/jalview/datamodel/HiddenColumnsTest.java +++ b/test/jalview/datamodel/HiddenColumnsTest.java @@ -26,7 +26,6 @@ import static org.testng.AssertJUnit.assertFalse; import static org.testng.AssertJUnit.assertTrue; import jalview.analysis.AlignmentGenerator; -import jalview.util.Comparison; import java.util.Arrays; import java.util.BitSet; @@ -260,172 +259,6 @@ public class HiddenColumnsTest assertFalse(cs2.hasHiddenColumns()); } - /** - * Test the code used to locate the reference sequence ruler origin - */ - @Test(groups = { "Functional" }) - public void testLocateVisibleStartofSequence() - { - // create random alignment - AlignmentGenerator gen = new AlignmentGenerator(false); - AlignmentI al = gen.generate(50, 20, 123, 5, 5); - - HiddenColumns cs = al.getHiddenColumns(); - ColumnSelection colsel = new ColumnSelection(); - - SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---"); - assertEquals(2, seq.findIndex(seq.getStart())); - - // no hidden columns - assertEquals(seq.findIndex(seq.getStart()) - 1, cs.locateVisibleStartOfSequence(seq)); - - // hidden column on gap after end of sequence - should not affect bounds - colsel.hideSelectedColumns(13, al.getHiddenColumns()); - assertEquals(seq.findIndex(seq.getStart()) - 1,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - // hidden column on gap before beginning of sequence - should vis bounds by - // one - colsel.hideSelectedColumns(0, al.getHiddenColumns()); - assertEquals(seq.findIndex(seq.getStart()) - 2,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - // hide columns around most of sequence - leave one residue remaining - cs.hideColumns(1, 3); - cs.hideColumns(6, 11); - assertEquals("-D", - cs.getVisibleSequenceStrings(0, 5, new SequenceI[] - { seq })[0]); - - assertEquals(1, cs.locateVisibleStartOfSequence(seq)); - cs.revealAllHiddenColumns(colsel); - - // hide whole sequence - should just get location of hidden region - // containing sequence - cs.hideColumns(1, 11); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 15); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - SequenceI seq2 = new Sequence("RefSeq2", "-------A-SD-ASD--E---"); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(7, 17); - assertEquals(0,cs.locateVisibleStartOfSequence(seq2)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(3, 17); - assertEquals(0,cs.locateVisibleStartOfSequence(seq2)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(3, 19); - assertEquals(0,cs.locateVisibleStartOfSequence(seq2)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 0); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 1); - assertEquals(1,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 2); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(1, 1); - assertEquals(2,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(1, 2); - assertEquals(1,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(1, 3); - assertEquals(1,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 2); - cs.hideColumns(5, 6); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 2); - cs.hideColumns(5, 6); - cs.hideColumns(9, 10); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 2); - cs.hideColumns(7, 11); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(2, 4); - cs.hideColumns(7, 11); - assertEquals(1,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(2, 4); - cs.hideColumns(7, 12); - assertEquals(1,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(1, 11); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 12); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 4); - cs.hideColumns(6, 12); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 1); - cs.hideColumns(3, 12); - assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(3, 14); - cs.hideColumns(17, 19); - assertEquals(3,cs.locateVisibleStartOfSequence(seq2)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(3, 7); - cs.hideColumns(9, 14); - cs.hideColumns(17, 19); - assertEquals(9,cs.locateVisibleStartOfSequence(seq2)); - - cs.revealAllHiddenColumns(colsel); - cs.hideColumns(0, 1); - cs.hideColumns(3, 4); - cs.hideColumns(6, 8); - cs.hideColumns(10, 12); - assertEquals(6, cs.locateVisibleStartOfSequence(seq)); - - } - - @Test(groups = { "Functional" }) - public void testLocateVisibleStartPathologicals() - { - // test some pathological cases we missed - AlignmentI al = new Alignment( - new SequenceI[] - { new Sequence("refseqGaptest", "KTDVTI----------NFI-----G----L") }); - HiddenColumns cs = new HiddenColumns(); - cs.hideList(al.getSequenceAt(0).getInsertions()); - assertEquals("G", "" - + al.getSequenceAt(0).getCharAt(cs.visibleToAbsoluteColumn(9))); - - // KM: no idea what this is meant to be testing... seems to be an unfinished - // test - } @Test(groups = { "Functional" }) public void testHideColumns() @@ -440,6 +273,7 @@ public class HiddenColumnsTest Iterator regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[5, 5]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 1); colsel.hideSelectedColumns(3, al.getHiddenColumns()); regions = cs.iterator(); @@ -447,6 +281,7 @@ public class HiddenColumnsTest // two hidden ranges, in order: assertEquals("[3, 3]", Arrays.toString(regions.next())); assertEquals("[5, 5]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 2); // hiding column 4 expands [3, 3] to [3, 4] // and merges to [5, 5] to make [3, 5] @@ -454,16 +289,19 @@ public class HiddenColumnsTest regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[3, 5]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 3); // clear hidden columns (note they are added to selected) cs.revealAllHiddenColumns(colsel); // it is now actually null but getter returns an empty list assertEquals(0, cs.getNumberOfRegions()); + assertEquals(cs.getSize(), 0); cs.hideColumns(3, 6); regions = cs.iterator(); int[] firstHiddenRange = regions.next(); assertEquals("[3, 6]", Arrays.toString(firstHiddenRange)); + assertEquals(cs.getSize(), 4); // adding a subrange of already hidden should do nothing cs.hideColumns(4, 5); @@ -471,45 +309,53 @@ public class HiddenColumnsTest assertEquals(1, cs.getNumberOfRegions()); assertEquals("[3, 6]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 4); cs.hideColumns(3, 5); regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[3, 6]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 4); cs.hideColumns(4, 6); regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[3, 6]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 4); cs.hideColumns(3, 6); regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[3, 6]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 4); cs.revealAllHiddenColumns(colsel); cs.hideColumns(2, 4); regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[2, 4]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 3); // extend contiguous with 2 positions overlap cs.hideColumns(3, 5); regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[2, 5]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 4); // extend contiguous with 1 position overlap cs.hideColumns(5, 6); regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[2, 6]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 5); // extend contiguous with overlap both ends: cs.hideColumns(1, 7); regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[1, 7]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 7); cs.revealAllHiddenColumns(colsel); cs.hideColumns(15, 18); @@ -520,6 +366,7 @@ public class HiddenColumnsTest assertEquals("[2, 4]", Arrays.toString(regions.next())); assertEquals("[7, 9]", Arrays.toString(regions.next())); assertEquals("[15, 18]", Arrays.toString(regions.next())); + assertEquals(cs.getSize(), 10); } /** @@ -609,6 +456,8 @@ public class HiddenColumnsTest public void testIsVisible() { HiddenColumns cs = new HiddenColumns(); + assertTrue(cs.isVisible(5)); + cs.hideColumns(2, 4); cs.hideColumns(6, 7); assertTrue(cs.isVisible(0)); @@ -641,11 +490,13 @@ public class HiddenColumnsTest assertEquals(2, cs.getNumberOfRegions()); assertEquals("[49, 59]", Arrays.toString(regions.next())); assertEquals("[69, 79]", Arrays.toString(regions.next())); + assertEquals(22, cs.getSize()); cs.hideColumns(48, 80); regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[48, 80]", Arrays.toString(regions.next())); + assertEquals(33, cs.getSize()); /* * another...joining hidden ranges @@ -659,6 +510,7 @@ public class HiddenColumnsTest regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[10, 60]", Arrays.toString(regions.next())); + assertEquals(51, cs.getSize()); /* * another...left overlap, subsumption, right overlap, @@ -676,10 +528,11 @@ public class HiddenColumnsTest assertEquals(2, cs.getNumberOfRegions()); assertEquals("[10, 50]", Arrays.toString(regions.next())); assertEquals("[60, 70]", Arrays.toString(regions.next())); + assertEquals(52, cs.getSize()); } @Test(groups = { "Functional" }) - public void testHideBitset() + public void testHideColumns_BitSet() { HiddenColumns cs; @@ -690,22 +543,26 @@ public class HiddenColumnsTest cs = new HiddenColumns(); cs.hideColumns(one); assertEquals(1, cs.getNumberOfRegions()); + assertEquals(1, cs.getSize()); one.set(2); cs = new HiddenColumns(); cs.hideColumns(one); assertEquals(1, cs.getNumberOfRegions()); + assertEquals(2, cs.getSize()); one.set(3); cs = new HiddenColumns(); cs.hideColumns(one); assertEquals(1, cs.getNumberOfRegions()); + assertEquals(3, cs.getSize()); // split one.clear(2); cs = new HiddenColumns(); cs.hideColumns(one); assertEquals(2, cs.getNumberOfRegions()); + assertEquals(2, cs.getSize()); assertEquals(0, cs.visibleToAbsoluteColumn(0)); assertEquals(2, cs.visibleToAbsoluteColumn(1)); @@ -715,6 +572,7 @@ public class HiddenColumnsTest one.clear(1); cs = new HiddenColumns(); cs.hideColumns(one); + assertEquals(1, cs.getSize()); assertEquals(1, cs.getNumberOfRegions()); @@ -725,46 +583,6 @@ public class HiddenColumnsTest } @Test(groups = { "Functional" }) - public void hideColumns_BitSetAndRange() - { - HiddenColumns hc = new HiddenColumns(); - hc.hideColumns(3, 5); - hc.hideColumns(15, 20); - hc.hideColumns(45, 60); - - BitSet tohide = new BitSet(); - - // all unhidden if tohide is empty and range covers hidden - hc.hideColumns(tohide, 1, 70); - assertTrue(!hc.hasHiddenColumns()); - - hc.hideColumns(3, 5); - hc.hideColumns(15, 20); - hc.hideColumns(45, 60); - - // but not if range does not cover hidden - hc.hideColumns(tohide, 23, 40); - assertTrue(hc.hasHiddenColumns()); - - // and partial unhide if range partially covers - hc.hideColumns(tohide, 1, 17); - Iterator it = hc.iterator(); - assertTrue(it.hasNext()); - int[] region = it.next(); - - assertEquals(18, region[0]); - assertEquals(20, region[1]); - - assertTrue(it.hasNext()); - region = it.next(); - - assertEquals(45, region[0]); - assertEquals(60, region[1]); - - assertFalse(it.hasNext()); - } - - @Test(groups = { "Functional" }) public void testRegionsToString() { HiddenColumns hc = new HiddenColumns(); @@ -859,123 +677,6 @@ public class HiddenColumnsTest } @Test(groups = "Functional") - public void testPropagateInsertions() - { - // create an alignment with no gaps - this will be the profile seq and other - // JPRED seqs - AlignmentGenerator gen = new AlignmentGenerator(false); - AlignmentI al = gen.generate(25, 10, 1234, 0, 0); - - // get the profileseq - SequenceI profileseq = al.getSequenceAt(0); - SequenceI gappedseq = new Sequence(profileseq); - gappedseq.insertCharAt(5, al.getGapCharacter()); - gappedseq.insertCharAt(6, al.getGapCharacter()); - gappedseq.insertCharAt(7, al.getGapCharacter()); - gappedseq.insertCharAt(8, al.getGapCharacter()); - - // force different kinds of padding - al.getSequenceAt(3).deleteChars(2, 23); - al.getSequenceAt(4).deleteChars(2, 27); - al.getSequenceAt(5).deleteChars(10, 27); - - // create an alignment view with the gapped sequence - SequenceI[] seqs = new SequenceI[1]; - seqs[0] = gappedseq; - AlignmentI newal = new Alignment(seqs); - HiddenColumns hidden = new HiddenColumns(); - hidden.hideColumns(15, 17); - - AlignmentView view = new AlignmentView(newal, hidden, null, true, false, - false); - - // confirm that original contigs are as expected - Iterator visible = hidden.getVisContigsIterator(0, 25, false); - int[] region = visible.next(); - assertEquals("[0, 14]", Arrays.toString(region)); - region = visible.next(); - assertEquals("[18, 24]", Arrays.toString(region)); - - // propagate insertions - HiddenColumns result = HiddenColumns.propagateInsertions(profileseq, al, - view); - - // confirm that the contigs have changed to account for the gaps - visible = result.getVisContigsIterator(0, 25, false); - region = visible.next(); - assertEquals("[0, 10]", Arrays.toString(region)); - region = visible.next(); - assertEquals("[14, 24]", Arrays.toString(region)); - - // confirm the alignment has been changed so that the other sequences have - // gaps inserted where the columns are hidden - assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[10])); - assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[11])); - assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[12])); - assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[13])); - assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[14])); - - } - - @Test(groups = "Functional") - public void testPropagateInsertionsOverlap() - { - // test propagateInsertions where gaps and hiddenColumns overlap - - // create an alignment with no gaps - this will be the profile seq and other - // JPRED seqs - AlignmentGenerator gen = new AlignmentGenerator(false); - AlignmentI al = gen.generate(20, 10, 1234, 0, 0); - - // get the profileseq - SequenceI profileseq = al.getSequenceAt(0); - SequenceI gappedseq = new Sequence(profileseq); - gappedseq.insertCharAt(5, al.getGapCharacter()); - gappedseq.insertCharAt(6, al.getGapCharacter()); - gappedseq.insertCharAt(7, al.getGapCharacter()); - gappedseq.insertCharAt(8, al.getGapCharacter()); - - // create an alignment view with the gapped sequence - SequenceI[] seqs = new SequenceI[1]; - seqs[0] = gappedseq; - AlignmentI newal = new Alignment(seqs); - - // hide columns so that some overlap with the gaps - HiddenColumns hidden = new HiddenColumns(); - hidden.hideColumns(7, 10); - - AlignmentView view = new AlignmentView(newal, hidden, null, true, false, - false); - - // confirm that original contigs are as expected - Iterator visible = hidden.getVisContigsIterator(0, 20, false); - int[] region = visible.next(); - assertEquals("[0, 6]", Arrays.toString(region)); - region = visible.next(); - assertEquals("[11, 19]", Arrays.toString(region)); - assertFalse(visible.hasNext()); - - // propagate insertions - HiddenColumns result = HiddenColumns.propagateInsertions(profileseq, al, - view); - - // confirm that the contigs have changed to account for the gaps - visible = result.getVisContigsIterator(0, 20, false); - region = visible.next(); - assertEquals("[0, 4]", Arrays.toString(region)); - region = visible.next(); - assertEquals("[7, 19]", Arrays.toString(region)); - assertFalse(visible.hasNext()); - - // confirm the alignment has been changed so that the other sequences have - // gaps inserted where the columns are hidden - assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[4])); - assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[5])); - assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[6])); - assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[7])); - } - - @Test(groups = "Functional") public void testHasHiddenColumns() { HiddenColumns h = new HiddenColumns(); @@ -1038,42 +739,42 @@ public class HiddenColumnsTest } @Test(groups = "Functional") - public void testGetHiddenBoundaryLeft() + public void testGetNextHiddenBoundary_Left() { HiddenColumns h = new HiddenColumns(); // returns same value if no hidden cols - assertEquals(3, h.getHiddenBoundaryLeft(3)); + assertEquals(3, h.getNextHiddenBoundary(true, 3)); h.hideColumns(5, 10); - assertEquals(10, h.getHiddenBoundaryLeft(15)); - assertEquals(3, h.getHiddenBoundaryLeft(3)); - assertEquals(7, h.getHiddenBoundaryLeft(7)); + assertEquals(10, h.getNextHiddenBoundary(true, 15)); + assertEquals(3, h.getNextHiddenBoundary(true, 3)); + assertEquals(7, h.getNextHiddenBoundary(true, 7)); h.hideColumns(15, 20); - assertEquals(10, h.getHiddenBoundaryLeft(15)); - assertEquals(20, h.getHiddenBoundaryLeft(21)); + assertEquals(10, h.getNextHiddenBoundary(true, 15)); + assertEquals(20, h.getNextHiddenBoundary(true, 21)); } @Test(groups = "Functional") - public void testGetHiddenBoundaryRight() + public void testGetNextHiddenBoundary_Right() { HiddenColumns h = new HiddenColumns(); // returns same value if no hidden cols - assertEquals(3, h.getHiddenBoundaryRight(3)); + assertEquals(3, h.getNextHiddenBoundary(false, 3)); h.hideColumns(5, 10); - assertEquals(5, h.getHiddenBoundaryRight(3)); - assertEquals(15, h.getHiddenBoundaryRight(15)); - assertEquals(7, h.getHiddenBoundaryRight(7)); + assertEquals(5, h.getNextHiddenBoundary(false, 3)); + assertEquals(15, h.getNextHiddenBoundary(false, 15)); + assertEquals(7, h.getNextHiddenBoundary(false, 7)); h.hideColumns(15, 20); - assertEquals(15, h.getHiddenBoundaryRight(7)); - assertEquals(15, h.getHiddenBoundaryRight(14)); + assertEquals(15, h.getNextHiddenBoundary(false, 7)); + assertEquals(15, h.getNextHiddenBoundary(false, 14)); // returns same value if there is no next hidden column - assertEquals(22, h.getHiddenBoundaryRight(22)); + assertEquals(22, h.getNextHiddenBoundary(false, 22)); } @Test(groups = "Functional") @@ -1111,7 +812,7 @@ public class HiddenColumnsTest assertFalse(result.hasNext()); } - @Test(groups = "Functional") + /* @Test(groups = "Functional") public void testGetVisibleSequenceStrings() { HiddenColumns h = new HiddenColumns(); @@ -1124,13 +825,13 @@ public class HiddenColumnsTest assertEquals(2, result.length); assertEquals("WKQES", result[0]); assertEquals("RNDTG", result[1]); - + h.hideColumns(6, 8); result = h.getVisibleSequenceStrings(5, 10, seqs); assertEquals(2, result.length); assertEquals("WS", result[0]); assertEquals("RG", result[1]); - + SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---"); ColumnSelection sel = new ColumnSelection(); h.revealAllHiddenColumns(sel); @@ -1139,7 +840,7 @@ public class HiddenColumnsTest assertEquals("-D", h.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]); - } + }*/ @Test(groups = "Functional") public void testHideInsertionsFor() @@ -1151,12 +852,14 @@ public class HiddenColumnsTest h.hideList(seq2.getInsertions()); assertTrue(h.equals(h2)); + assertEquals(0, h.getSize()); h.hideList(seq1.getInsertions()); h2.hideColumns(3, 5); h2.hideColumns(9, 9); h2.hideColumns(19, 20); assertTrue(h.equals(h2)); + assertEquals(6, h.getSize()); } @Test(groups = "Functional") @@ -1165,42 +868,88 @@ public class HiddenColumnsTest HiddenColumns h = new HiddenColumns(); HiddenColumns h2 = new HiddenColumns(); - BitSet tohide = new BitSet(21); + BitSet tohide = new BitSet(25); h.hideColumns(tohide); assertTrue(h.equals(h2)); - // when setting bitset, first param is invlusive, second exclusive + // when setting bitset, first param is inclusive, second exclusive tohide.set(3, 6); tohide.set(9); tohide.set(15, 21); - h.hideColumns(tohide, 5, 23); + h.clearAndHideColumns(tohide, 5, 23); h2.hideColumns(5, 5); h2.hideColumns(9, 9); h2.hideColumns(15, 20); assertTrue(h.equals(h2)); + assertEquals(h.getSize(), h2.getSize()); tohide.clear(); tohide.set(41); - h.hideColumns(tohide, 23, 30); + h.clearAndHideColumns(tohide, 23, 30); assertTrue(h.equals(h2)); + assertEquals(h.getSize(), h2.getSize()); tohide.set(41); - h.hideColumns(tohide, 30, 45); + h.clearAndHideColumns(tohide, 30, 45); h2.hideColumns(41, 41); assertTrue(h.equals(h2)); + assertEquals(h.getSize(), h2.getSize()); tohide.clear(); tohide.set(25, 28); - h.hideColumns(tohide, 17, 50); + h.clearAndHideColumns(tohide, 17, 50); h2 = new HiddenColumns(); - h2.hideColumns(17, 20); + h2.hideColumns(5, 5); + h2.hideColumns(9, 9); + h2.hideColumns(15, 16); h2.hideColumns(25, 27); - h2.hideColumns(41, 41); + assertTrue(h.equals(h2)); + assertEquals(h.getSize(), h2.getSize()); + + HiddenColumns hc = new HiddenColumns(); + hc.hideColumns(3, 5); + hc.hideColumns(15, 20); + hc.hideColumns(45, 60); + + tohide = new BitSet(); + + // all unhidden if tohide is empty and range covers hidden + hc.clearAndHideColumns(tohide, 1, 70); + assertTrue(!hc.hasHiddenColumns()); + assertEquals(0, hc.getSize()); + + hc.hideColumns(3, 5); + hc.hideColumns(15, 20); + hc.hideColumns(45, 60); + assertEquals(25, hc.getSize()); + + // but not if range does not cover hidden + hc.clearAndHideColumns(tohide, 23, 40); + assertTrue(hc.hasHiddenColumns()); + assertEquals(25, hc.getSize()); + + // and partial unhide if range partially covers + hc.clearAndHideColumns(tohide, 1, 17); + Iterator it = hc.iterator(); + assertTrue(it.hasNext()); + int[] region = it.next(); + + assertEquals(18, region[0]); + assertEquals(20, region[1]); + + assertTrue(it.hasNext()); + region = it.next(); + + assertEquals(45, region[0]); + assertEquals(60, region[1]); + + assertFalse(it.hasNext()); + assertEquals(19, hc.getSize()); } @Test(groups = "Functional") - public void testSubtractVisibleColumns() + public void testOffsetByVisibleColumns() { HiddenColumns h = new HiddenColumns(); int result = h.offsetByVisibleColumns(-1, 10); @@ -1380,7 +1129,7 @@ public class HiddenColumnsTest public void testBoundedStartIterator() { HiddenColumns h = new HiddenColumns(); - Iterator it = h.getBoundedStartIterator(0, 10); + Iterator it = h.getStartRegionIterator(0, 10); // no hidden columns = nothing to iterate over assertFalse(it.hasNext()); @@ -1389,7 +1138,7 @@ public class HiddenColumnsTest // all regions are returned h.hideColumns(3, 10); h.hideColumns(14, 16); - it = h.getBoundedStartIterator(0, 20); + it = h.getStartRegionIterator(0, 20); assertTrue(it.hasNext()); int next = it.next(); assertEquals(3, next); @@ -1399,12 +1148,12 @@ public class HiddenColumnsTest // [start,end] does not contain a start of a region // no regions to iterate over - it = h.getBoundedStartIterator(4, 5); + it = h.getStartRegionIterator(4, 5); assertFalse(it.hasNext()); // [start,end] fully contains 1 region and start of last // - 2 regions returned - it = h.getBoundedStartIterator(3, 7); + it = h.getStartRegionIterator(3, 7); assertTrue(it.hasNext()); next = it.next(); assertEquals(3, next); @@ -1414,7 +1163,7 @@ public class HiddenColumnsTest // [start,end] contains whole of last region // - 1 region returned - it = h.getBoundedStartIterator(4, 20); + it = h.getStartRegionIterator(4, 20); assertTrue(it.hasNext()); next = it.next(); assertEquals(6, next); @@ -1560,7 +1309,7 @@ public class HiddenColumnsTest HiddenColumns h = new HiddenColumns(); Iterator it = h.getVisibleColsIterator(0, 10); - assertTrue(it instanceof VisibleColsIterator); + assertTrue(it instanceof RangeElementsIterator); } @Test(groups = "Functional")