X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FHiddenColumnsTest.java;h=abde7c68264ff827dce8e3d6123f30e6f3947862;hb=57738a1f3c19b1c3a00bd3ac5108f8cd0af32f99;hp=320a19951c12e5eddea5e999c8eb13b81cc61d6d;hpb=2ae1f76a9c13f23ba553500fea0e58ec920830e5;p=jalview.git diff --git a/test/jalview/datamodel/HiddenColumnsTest.java b/test/jalview/datamodel/HiddenColumnsTest.java index 320a199..abde7c6 100644 --- a/test/jalview/datamodel/HiddenColumnsTest.java +++ b/test/jalview/datamodel/HiddenColumnsTest.java @@ -26,27 +26,15 @@ import static org.testng.AssertJUnit.assertFalse; import static org.testng.AssertJUnit.assertTrue; import jalview.analysis.AlignmentGenerator; -import jalview.gui.JvOptionPane; -import jalview.util.Comparison; import java.util.Arrays; import java.util.BitSet; import java.util.Iterator; -import java.util.Random; -import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; public class HiddenColumnsTest { - - @BeforeClass(alwaysRun = true) - public void setUpJvOptionPane() - { - JvOptionPane.setInteractiveMode(false); - JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); - } - /** * Test the method which counts the number of hidden columns */ @@ -78,22 +66,22 @@ public class HiddenColumnsTest public void testFindColumnPosition() { HiddenColumns cs = new HiddenColumns(); - assertEquals(5, cs.findColumnPosition(5)); + assertEquals(5, cs.absoluteToVisibleColumn(5)); // hiding column 6 makes no difference cs.hideColumns(6, 6); - assertEquals(5, cs.findColumnPosition(5)); + assertEquals(5, cs.absoluteToVisibleColumn(5)); // hiding column 4 moves column 5 to column 4 cs.hideColumns(4, 4); - assertEquals(4, cs.findColumnPosition(5)); + assertEquals(4, cs.absoluteToVisibleColumn(5)); // hiding column 4 moves column 4 to position 3 - assertEquals(3, cs.findColumnPosition(4)); + assertEquals(3, cs.absoluteToVisibleColumn(4)); // hiding columns 1 and 2 moves column 5 to column 2 cs.hideColumns(1, 2); - assertEquals(2, cs.findColumnPosition(5)); + assertEquals(2, cs.absoluteToVisibleColumn(5)); // check with > 1 hidden column regions // where some columns are in the hidden regions @@ -103,25 +91,25 @@ public class HiddenColumnsTest cs2.hideColumns(40, 44); // hiding columns 5-10 and 20-27 moves column 8 to column 4 - assertEquals(4, cs2.findColumnPosition(8)); + assertEquals(4, cs2.absoluteToVisibleColumn(8)); // and moves column 24 to 13 - assertEquals(13, cs2.findColumnPosition(24)); + assertEquals(13, cs2.absoluteToVisibleColumn(24)); // and moves column 28 to 14 - assertEquals(14, cs2.findColumnPosition(28)); + assertEquals(14, cs2.absoluteToVisibleColumn(28)); // and moves column 40 to 25 - assertEquals(25, cs2.findColumnPosition(40)); + assertEquals(25, cs2.absoluteToVisibleColumn(40)); // check when hidden columns start at 0 that the visible column // is returned as 0 HiddenColumns cs3 = new HiddenColumns(); cs3.hideColumns(0, 4); - assertEquals(0, cs3.findColumnPosition(2)); + assertEquals(0, cs3.absoluteToVisibleColumn(2)); // check that column after the last hidden region doesn't crash - assertEquals(46, cs2.findColumnPosition(65)); + assertEquals(46, cs2.absoluteToVisibleColumn(65)); } @Test(groups = { "Functional" }) @@ -129,7 +117,7 @@ public class HiddenColumnsTest { HiddenColumns cs = new HiddenColumns(); - Iterator visible = cs.getVisContigsIterator(3, 10); + Iterator visible = cs.getVisContigsIterator(3, 10, false); int[] region = visible.next(); assertEquals("[3, 9]", Arrays.toString(region)); assertFalse(visible.hasNext()); @@ -141,7 +129,7 @@ public class HiddenColumnsTest // Test both ends visible region // start position is inclusive, end position exclusive - visible = cs.getVisContigsIterator(1, 13); + visible = cs.getVisContigsIterator(1, 13, false); region = visible.next(); assertEquals("[1, 2]", Arrays.toString(region)); region = visible.next(); @@ -151,7 +139,7 @@ public class HiddenColumnsTest assertFalse(visible.hasNext()); // Test start hidden, end visible - visible = cs.getVisContigsIterator(4, 14); + visible = cs.getVisContigsIterator(4, 14, false); region = visible.next(); assertEquals("[7, 7]", Arrays.toString(region)); region = visible.next(); @@ -161,13 +149,13 @@ public class HiddenColumnsTest assertFalse(visible.hasNext()); // Test start hidden, end hidden - visible = cs.getVisContigsIterator(3, 10); + visible = cs.getVisContigsIterator(3, 10, false); region = visible.next(); assertEquals("[7, 7]", Arrays.toString(region)); assertFalse(visible.hasNext()); // Test start visible, end hidden - visible = cs.getVisContigsIterator(0, 13); + visible = cs.getVisContigsIterator(0, 13, false); region = visible.next(); assertEquals("[0, 2]", Arrays.toString(region)); region = visible.next(); @@ -177,7 +165,7 @@ public class HiddenColumnsTest assertFalse(visible.hasNext()); // Test empty result - visible = cs.getVisContigsIterator(4, 6); + visible = cs.getVisContigsIterator(4, 6, false); assertFalse(visible.hasNext()); } @@ -194,14 +182,31 @@ public class HiddenColumnsTest assertFalse(cs.equals(cs2)); assertFalse(cs2.equals(cs)); + // with the wrong kind of object + assertFalse(cs.equals(new HiddenColumnsCursor())); + + // with a different hiddenColumns object - by size + HiddenColumns cs3 = new HiddenColumns(); + cs3.hideColumns(2, 3); + assertFalse(cs.equals(cs3)); + // with hidden columns added in a different order cs2.hideColumns(6, 9); + assertFalse(cs.equals(cs2)); + assertFalse(cs2.equals(cs)); + cs2.hideColumns(5, 8); assertTrue(cs.equals(cs2)); assertTrue(cs.equals(cs)); assertTrue(cs2.equals(cs)); assertTrue(cs2.equals(cs2)); + + // different ranges, same size + cs.hideColumns(10, 12); + cs2.hideColumns(10, 15); + assertFalse(cs.equals(cs2)); + } @Test(groups = "Functional") @@ -211,18 +216,15 @@ public class HiddenColumnsTest cs.hideColumns(10, 11); cs.hideColumns(5, 7); Iterator regions = cs.iterator(); - assertEquals("[5, 7]", - Arrays.toString(regions.next())); + assertEquals("[5, 7]", Arrays.toString(regions.next())); HiddenColumns cs2 = new HiddenColumns(cs); regions = cs2.iterator(); assertTrue(cs2.hasHiddenColumns()); assertEquals(2, cs2.getNumberOfRegions()); // hidden columns are held in column order - assertEquals("[5, 7]", - Arrays.toString(regions.next())); - assertEquals("[10, 11]", - Arrays.toString(regions.next())); + assertEquals("[5, 7]", Arrays.toString(regions.next())); + assertEquals("[10, 11]", Arrays.toString(regions.next())); } @Test(groups = "Functional") @@ -237,8 +239,7 @@ public class HiddenColumnsTest Iterator regions = cs2.iterator(); // only [5,7] returned, offset by 1 - assertEquals("[4, 6]", - Arrays.toString(regions.next())); + assertEquals("[4, 6]", Arrays.toString(regions.next())); assertEquals(3, cs2.getSize()); cs2 = new HiddenColumns(cs, 8, 15, 4); @@ -246,178 +247,13 @@ public class HiddenColumnsTest assertTrue(cs2.hasHiddenColumns()); // only [10,11] returned, offset by 4 - assertEquals("[6, 7]", - Arrays.toString(regions.next())); + assertEquals("[6, 7]", Arrays.toString(regions.next())); assertEquals(2, cs2.getSize()); cs2 = new HiddenColumns(cs, 6, 10, 4); assertFalse(cs2.hasHiddenColumns()); } - /** - * Test the code used to locate the reference sequence ruler origin - */ - @Test(groups = { "Functional" }) - public void testLocateVisibleBoundsofSequence() - { - // 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 testLocateVisibleBoundsPathologicals() - { - // test some pathological cases we missed - AlignmentI al = new Alignment( - new SequenceI[] - { new Sequence("refseqGaptest", "KTDVTI----------NFI-----G----L") }); - HiddenColumns cs = new HiddenColumns(); - cs.hideInsertionsFor(al.getSequenceAt(0)); - assertEquals("G", "" - + al.getSequenceAt(0).getCharAt(cs.adjustForHiddenColumns(9))); - } - @Test(groups = { "Functional" }) public void testHideColumns() { @@ -431,6 +267,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(); @@ -438,6 +275,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] @@ -445,62 +283,80 @@ 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); regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); - assertEquals("[3, 6]", - Arrays.toString(regions.next())); + 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("[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("[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("[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); + cs.hideColumns(2, 4); + cs.hideColumns(7, 9); + regions = cs.iterator(); + assertEquals(3, cs.getNumberOfRegions()); + 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); } /** @@ -512,6 +368,11 @@ public class HiddenColumnsTest { ColumnSelection colsel = new ColumnSelection(); HiddenColumns cs = new HiddenColumns(); + + // test with null hidden columns + cs.revealHiddenColumns(5, colsel); + assertTrue(colsel.getSelected().isEmpty()); + cs.hideColumns(5, 8); colsel.addElement(10); cs.revealHiddenColumns(5, colsel); @@ -531,6 +392,26 @@ public class HiddenColumnsTest cs.revealHiddenColumns(6, colsel); assertEquals(prevSize, cs.getSize()); assertTrue(colsel.getSelected().isEmpty()); + + // reveal hidden columns when there is more than one region + cs.hideColumns(20, 23); + // now there are 2 hidden regions + assertEquals(2, cs.getNumberOfRegions()); + + cs.revealHiddenColumns(20, colsel); + + // hiddenColumns now has one region + assertEquals(1, cs.getNumberOfRegions()); + + // revealed columns are marked as selected (added to selection): + assertEquals("[20, 21, 22, 23]", colsel.getSelected().toString()); + + // call with a column past the end of the hidden column ranges + colsel.clear(); + cs.revealHiddenColumns(20, colsel); + // hiddenColumns still has 1 region + assertEquals(1, cs.getNumberOfRegions()); + assertTrue(colsel.getSelected().isEmpty()); } @Test(groups = { "Functional" }) @@ -538,6 +419,11 @@ public class HiddenColumnsTest { HiddenColumns hidden = new HiddenColumns(); ColumnSelection colsel = new ColumnSelection(); + + // test with null hidden columns + hidden.revealAllHiddenColumns(colsel); + assertTrue(colsel.getSelected().isEmpty()); + hidden.hideColumns(5, 8); hidden.hideColumns(2, 3); colsel.addElement(11); @@ -560,6 +446,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)); @@ -571,6 +459,7 @@ public class HiddenColumnsTest assertTrue(cs.isVisible(5)); assertFalse(cs.isVisible(6)); assertFalse(cs.isVisible(7)); + assertTrue(cs.isVisible(8)); } /** @@ -591,11 +480,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 @@ -609,6 +500,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, @@ -626,10 +518,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; @@ -638,62 +531,45 @@ public class HiddenColumnsTest // one hidden range one.set(1); cs = new HiddenColumns(); - cs.hideMarkedBits(one); + cs.hideColumns(one); assertEquals(1, cs.getNumberOfRegions()); + assertEquals(1, cs.getSize()); one.set(2); cs = new HiddenColumns(); - cs.hideMarkedBits(one); + cs.hideColumns(one); assertEquals(1, cs.getNumberOfRegions()); + assertEquals(2, cs.getSize()); one.set(3); cs = new HiddenColumns(); - cs.hideMarkedBits(one); + cs.hideColumns(one); assertEquals(1, cs.getNumberOfRegions()); + assertEquals(3, cs.getSize()); // split one.clear(2); cs = new HiddenColumns(); - cs.hideMarkedBits(one); + cs.hideColumns(one); assertEquals(2, cs.getNumberOfRegions()); + assertEquals(2, cs.getSize()); - assertEquals(0, cs.adjustForHiddenColumns(0)); - assertEquals(2, cs.adjustForHiddenColumns(1)); - assertEquals(4, cs.adjustForHiddenColumns(2)); + assertEquals(0, cs.visibleToAbsoluteColumn(0)); + assertEquals(2, cs.visibleToAbsoluteColumn(1)); + assertEquals(4, cs.visibleToAbsoluteColumn(2)); // one again one.clear(1); cs = new HiddenColumns(); - cs.hideMarkedBits(one); + cs.hideColumns(one); + assertEquals(1, cs.getSize()); assertEquals(1, cs.getNumberOfRegions()); - assertEquals(0, cs.adjustForHiddenColumns(0)); - assertEquals(1, cs.adjustForHiddenColumns(1)); - assertEquals(2, cs.adjustForHiddenColumns(2)); - assertEquals(4, cs.adjustForHiddenColumns(3)); - } - - @Test(groups = { "Functional" }) - public void testMarkHiddenRegions() - { - BitSet toMark, fromMark; - long seed = -3241532; - Random number = new Random(seed); - for (int n = 0; n < 1000; n++) - { - // create a random bitfield - toMark = BitSet - .valueOf(new long[] - { number.nextLong(), number.nextLong(), number.nextLong() }); - toMark.set(n * number.nextInt(10), n * (25 + number.nextInt(25))); - HiddenColumns hc = new HiddenColumns(); - hc.hideMarkedBits(toMark); - - // see if we can recover bitfield - hc.markHiddenRegions(fromMark = new BitSet()); - assertEquals(toMark, fromMark); - } + assertEquals(0, cs.visibleToAbsoluteColumn(0)); + assertEquals(1, cs.visibleToAbsoluteColumn(1)); + assertEquals(2, cs.visibleToAbsoluteColumn(2)); + assertEquals(4, cs.visibleToAbsoluteColumn(3)); } @Test(groups = { "Functional" }) @@ -713,7 +589,7 @@ public class HiddenColumnsTest } @Test(groups = "Functional") - public void testGetVisibleStartAndEndIndexTest() + public void testGetVisibleStartAndEndIndex() { Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); AlignmentI align = new Alignment(new SequenceI[] { seq }); @@ -739,6 +615,13 @@ public class HiddenColumnsTest System.out.println(startEnd[0] + " : " + startEnd[1]); assertEquals(1, startEnd[0]); assertEquals(23, startEnd[1]); + + // force lowest range to start of alignment + hc = new HiddenColumns(); + hc.hideColumns(3, 4); + startEnd = hc.getVisibleStartAndEndIndex(align.getWidth()); + assertEquals(0, startEnd[0]); + assertEquals(25, startEnd[1]); } @Test(groups = "Functional") @@ -757,6 +640,10 @@ public class HiddenColumnsTest assertEquals(3, result[0]); assertEquals(7, result[1]); + result = hc.getRegionWithEdgeAtRes(4); + assertEquals(10, result[0]); + assertEquals(10, result[1]); + result = hc.getRegionWithEdgeAtRes(5); assertEquals(10, result[0]); assertEquals(10, result[1]); @@ -774,118 +661,9 @@ public class HiddenColumnsTest result = hc.getRegionWithEdgeAtRes(8); assertEquals(14, result[0]); assertEquals(15, result[1]); - } - - @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()); - - // 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); - 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); - 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); - 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); - 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])); + result = hc.getRegionWithEdgeAtRes(16); + assertNull(result); } @Test(groups = "Functional") @@ -911,20 +689,20 @@ public class HiddenColumnsTest { HiddenColumns h = new HiddenColumns(); - // new HiddenColumns2 has no hidden cols - assertFalse(h.hasManyHiddenColumns()); + // h has no hidden cols + assertFalse(h.hasMultiHiddenColumnRegions()); // one set of columns hidden, returns false h.hideColumns(5, 10); - assertFalse(h.hasManyHiddenColumns()); + assertFalse(h.hasMultiHiddenColumnRegions()); // two sets hidden, returns true h.hideColumns(15, 17); - assertTrue(h.hasManyHiddenColumns()); + assertTrue(h.hasMultiHiddenColumnRegions()); // back to one block, asserts false h.hideColumns(11, 14); - assertFalse(h.hasManyHiddenColumns()); + assertFalse(h.hasMultiHiddenColumnRegions()); } @Test(groups = "Functional") @@ -932,58 +710,61 @@ public class HiddenColumnsTest { HiddenColumns h = new HiddenColumns(); // returns input value when there are no hidden columns - assertEquals(10, h.adjustForHiddenColumns(10)); + assertEquals(10, h.visibleToAbsoluteColumn(10)); h.hideColumns(20, 30); - assertEquals(10, h.adjustForHiddenColumns(10)); - assertEquals(20 + 11, h.adjustForHiddenColumns(20)); - assertEquals(35 + 11, h.adjustForHiddenColumns(35)); + assertEquals(10, h.visibleToAbsoluteColumn(10)); + assertEquals(20 + 11, h.visibleToAbsoluteColumn(20)); + assertEquals(35 + 11, h.visibleToAbsoluteColumn(35)); h.hideColumns(5, 7); - assertEquals(10 + 3, h.adjustForHiddenColumns(10)); - assertEquals(20 + 14, h.adjustForHiddenColumns(20)); - assertEquals(35 + 14, h.adjustForHiddenColumns(35)); + assertEquals(10 + 3, h.visibleToAbsoluteColumn(10)); + assertEquals(20 + 14, h.visibleToAbsoluteColumn(20)); + assertEquals(35 + 14, h.visibleToAbsoluteColumn(35)); ColumnSelection sel = new ColumnSelection(); h.revealAllHiddenColumns(sel); h.hideColumns(0, 1); - assertEquals(4, h.adjustForHiddenColumns(2)); + assertEquals(4, h.visibleToAbsoluteColumn(2)); } @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.getNextHiddenBoundary(false, 22)); } @Test(groups = "Functional") @@ -1021,7 +802,7 @@ public class HiddenColumnsTest assertFalse(result.hasNext()); } - @Test(groups = "Functional") + /* @Test(groups = "Functional") public void testGetVisibleSequenceStrings() { HiddenColumns h = new HiddenColumns(); @@ -1034,13 +815,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); @@ -1049,7 +830,7 @@ public class HiddenColumnsTest assertEquals("-D", h.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]); - } + }*/ @Test(groups = "Functional") public void testHideInsertionsFor() @@ -1059,129 +840,150 @@ public class HiddenColumnsTest SequenceI seq1 = new Sequence("TEST1", "GAL---MFW-KQESPVICY--HRNDT"); SequenceI seq2 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT"); - h.hideInsertionsFor(seq2); + h.hideList(seq2.getInsertions()); assertTrue(h.equals(h2)); + assertEquals(0, h.getSize()); - h.hideInsertionsFor(seq1); + 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") - public void testHideMarkedBits() + public void testHideColumns_BitSet_range() { HiddenColumns h = new HiddenColumns(); HiddenColumns h2 = new HiddenColumns(); - BitSet tohide = new BitSet(21); - h.hideMarkedBits(tohide); + BitSet tohide = new BitSet(25); + h.hideColumns(tohide); assertTrue(h.equals(h2)); - // NB in hideMarkedBits, the last bit is not set to hidden + // when setting bitset, first param is inclusive, second exclusive tohide.set(3, 6); tohide.set(9); - tohide.set(19, 21); - h.hideMarkedBits(tohide); + tohide.set(15, 21); + h.clearAndHideColumns(tohide, 5, 23); - h2.hideColumns(3, 5); + h2.hideColumns(5, 5); h2.hideColumns(9, 9); - h2.hideColumns(19, 20); + h2.hideColumns(15, 20); assertTrue(h.equals(h2)); - } + assertEquals(h.getSize(), h2.getSize()); - @Test(groups = "Functional") - public void testMakeVisibleAnnotation() - { - HiddenColumns h = new HiddenColumns(); - Annotation[] anns = new Annotation[] { null, null, new Annotation(1), - new Annotation(2), new Annotation(3), null, null, new Annotation(4), - new Annotation(5), new Annotation(6), new Annotation(7), - new Annotation(8) }; - AlignmentAnnotation ann = new AlignmentAnnotation("an", "some an", - anns); - - // without hidden cols, just truncates - h.makeVisibleAnnotation(3, 5, ann); - assertEquals(3, ann.annotations.length); - assertEquals(2.0f, ann.annotations[0].value); - assertEquals(3.0f, ann.annotations[1].value); - assertNull(ann.annotations[2]); - - anns = new Annotation[] { null, null, new Annotation(1), - new Annotation(2), new Annotation(3), null, null, new Annotation(4), - new Annotation(5), new Annotation(6), new Annotation(7), - new Annotation(8) }; - ann = new AlignmentAnnotation("an", "some an", anns); - h.hideColumns(4, 7); - h.makeVisibleAnnotation(1, 9, ann); - assertEquals(5, ann.annotations.length); - assertNull(ann.annotations[0]); - assertEquals(1.0f, ann.annotations[1].value); - assertEquals(2.0f, ann.annotations[2].value); - assertEquals(5.0f, ann.annotations[3].value); - assertEquals(6.0f, ann.annotations[4].value); - - anns = new Annotation[] { null, null, new Annotation(1), - new Annotation(2), new Annotation(3), null, null, new Annotation(4), - new Annotation(5), new Annotation(6), new Annotation(7), - new Annotation(8) }; - ann = new AlignmentAnnotation("an", "some an", anns); - h.hideColumns(1, 2); - h.makeVisibleAnnotation(1, 9, ann); - assertEquals(3, ann.annotations.length); - assertEquals(2.0f, ann.annotations[0].value); - assertEquals(5.0f, ann.annotations[1].value); - assertEquals(6.0f, ann.annotations[2].value); + tohide.clear(); + tohide.set(41); + h.clearAndHideColumns(tohide, 23, 30); + assertTrue(h.equals(h2)); + assertEquals(h.getSize(), h2.getSize()); + + tohide.set(41); + 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.clearAndHideColumns(tohide, 17, 50); + h2 = new HiddenColumns(); + h2.hideColumns(5, 5); + h2.hideColumns(9, 9); + h2.hideColumns(15, 16); + h2.hideColumns(25, 27); + 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.subtractVisibleColumns(1, 10); + int result = h.offsetByVisibleColumns(-1, 10); assertEquals(9, result); h.hideColumns(7, 9); - result = h.subtractVisibleColumns(4, 10); + result = h.offsetByVisibleColumns(-4, 10); assertEquals(3, result); h.hideColumns(14, 15); - result = h.subtractVisibleColumns(4, 10); + result = h.offsetByVisibleColumns(-4, 10); assertEquals(3, result); - result = h.subtractVisibleColumns(10, 17); + result = h.offsetByVisibleColumns(-10, 17); assertEquals(2, result); - result = h.subtractVisibleColumns(1, 7); + result = h.offsetByVisibleColumns(-1, 7); assertEquals(5, result); - result = h.subtractVisibleColumns(1, 8); + result = h.offsetByVisibleColumns(-1, 8); assertEquals(5, result); - result = h.subtractVisibleColumns(3, 15); + result = h.offsetByVisibleColumns(-3, 15); assertEquals(10, result); ColumnSelection sel = new ColumnSelection(); h.revealAllHiddenColumns(sel); h.hideColumns(0, 30); - result = h.subtractVisibleColumns(31, 0); + result = h.offsetByVisibleColumns(-31, 0); assertEquals(-31, result); HiddenColumns cs = new HiddenColumns(); - // test that without hidden columns, findColumnNToLeft returns + // test that without hidden columns, offsetByVisibleColumns returns // position n to left of provided position - long pos = cs.subtractVisibleColumns(3, 10); + long pos = cs.offsetByVisibleColumns(-3, 10); assertEquals(7, pos); // 0 returns same position - pos = cs.subtractVisibleColumns(0, 10); + pos = cs.offsetByVisibleColumns(0, 10); assertEquals(10, pos); // overflow to left returns negative number - pos = cs.subtractVisibleColumns(3, 0); + pos = cs.offsetByVisibleColumns(-3, 0); assertEquals(-3, pos); // test that with hidden columns to left of result column @@ -1189,21 +991,21 @@ public class HiddenColumnsTest cs.hideColumns(1, 3); // position n to left of provided position - pos = cs.subtractVisibleColumns(3, 10); + pos = cs.offsetByVisibleColumns(-3, 10); assertEquals(7, pos); // 0 returns same position - pos = cs.subtractVisibleColumns(0, 10); + pos = cs.offsetByVisibleColumns(0, 10); assertEquals(10, pos); // test with one set of hidden columns between start and required position cs.hideColumns(12, 15); - pos = cs.subtractVisibleColumns(8, 17); + pos = cs.offsetByVisibleColumns(-8, 17); assertEquals(5, pos); // test with two sets of hidden columns between start and required position cs.hideColumns(20, 21); - pos = cs.subtractVisibleColumns(8, 23); + pos = cs.offsetByVisibleColumns(-8, 23); assertEquals(9, pos); // repeat last 2 tests with no hidden columns to left of required position @@ -1212,16 +1014,49 @@ public class HiddenColumnsTest // test with one set of hidden columns between start and required position cs.hideColumns(12, 15); - pos = cs.subtractVisibleColumns(8, 17); + pos = cs.offsetByVisibleColumns(-8, 17); assertEquals(5, pos); // test with two sets of hidden columns between start and required position cs.hideColumns(20, 21); - pos = cs.subtractVisibleColumns(8, 23); + pos = cs.offsetByVisibleColumns(-8, 23); assertEquals(9, pos); - } + // test with right (positive) offsets + + // test that without hidden columns, offsetByVisibleColumns returns + // position n to right of provided position + pos = cs.offsetByVisibleColumns(3, 7); + assertEquals(10, pos); + + // test that with hidden columns to left of result column + // behaviour is the same as above + cs.hideColumns(1, 3); + + // test with one set of hidden columns between start and required position + cs.hideColumns(12, 15); + pos = cs.offsetByVisibleColumns(8, 5); + assertEquals(17, pos); + + // test with two sets of hidden columns between start and required position + cs.hideColumns(20, 21); + pos = cs.offsetByVisibleColumns(8, 9); + assertEquals(23, pos); + // repeat last 2 tests with no hidden columns to left of required position + colsel = new ColumnSelection(); + cs.revealAllHiddenColumns(colsel); + + // test with one set of hidden columns between start and required position + cs.hideColumns(12, 15); + pos = cs.offsetByVisibleColumns(8, 5); + assertEquals(17, pos); + + // test with two sets of hidden columns between start and required position + cs.hideColumns(20, 21); + pos = cs.offsetByVisibleColumns(8, 9); + assertEquals(23, pos); + } @Test(groups = "Functional") public void testBoundedIterator() @@ -1284,7 +1119,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()); @@ -1293,7 +1128,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); @@ -1303,12 +1138,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); @@ -1318,7 +1153,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); @@ -1329,7 +1164,7 @@ public class HiddenColumnsTest public void testVisibleBlocksVisBoundsIterator() { HiddenColumns h = new HiddenColumns(); - Iterator regions = h.getVisibleBlocksIterator(0, 30, true); + Iterator regions = h.getVisContigsIterator(0, 31, true); // only 1 visible region spanning 0-30 if nothing is hidden assertTrue(regions.hasNext()); @@ -1342,7 +1177,7 @@ public class HiddenColumnsTest // 2 regions one on either side // second region boundary accounts for hidden columns h.hideColumns(10, 15); - regions = h.getVisibleBlocksIterator(0, 30, true); + regions = h.getVisContigsIterator(0, 31, true); assertTrue(regions.hasNext()); region = regions.next(); @@ -1356,7 +1191,7 @@ public class HiddenColumnsTest // single hidden region at left h = new HiddenColumns(); h.hideColumns(0, 5); - regions = h.getVisibleBlocksIterator(0, 30, true); + regions = h.getVisContigsIterator(0, 31, true); assertTrue(regions.hasNext()); region = regions.next(); @@ -1367,7 +1202,7 @@ public class HiddenColumnsTest // single hidden region at right h = new HiddenColumns(); h.hideColumns(27, 30); - regions = h.getVisibleBlocksIterator(0, 30, true); + regions = h.getVisContigsIterator(0, 31, true); assertTrue(regions.hasNext()); region = regions.next(); @@ -1382,7 +1217,7 @@ public class HiddenColumnsTest h = new HiddenColumns(); h.hideColumns(0, 5); h.hideColumns(23, 25); - regions = h.getVisibleBlocksIterator(0, 30, true); + regions = h.getVisContigsIterator(0, 31, true); assertTrue(regions.hasNext()); region = regions.next(); @@ -1397,7 +1232,7 @@ public class HiddenColumnsTest h = new HiddenColumns(); h.hideColumns(27, 30); h.hideColumns(11, 14); - regions = h.getVisibleBlocksIterator(0, 30, true); + regions = h.getVisContigsIterator(0, 31, true); assertTrue(regions.hasNext()); region = regions.next(); @@ -1415,7 +1250,7 @@ public class HiddenColumnsTest h = new HiddenColumns(); h.hideColumns(27, 35); h.hideColumns(0, 4); - regions = h.getVisibleBlocksIterator(0, 30, true); + regions = h.getVisContigsIterator(0, 31, true); assertTrue(regions.hasNext()); region = regions.next(); @@ -1433,7 +1268,7 @@ public class HiddenColumnsTest h.hideColumns(9, 11); h.hideColumns(22, 26); - regions = h.getVisibleBlocksIterator(0, 30, true); + regions = h.getVisContigsIterator(0, 31, true); assertTrue(regions.hasNext()); region = regions.next(); @@ -1453,4 +1288,31 @@ public class HiddenColumnsTest assertEquals(42, region[1]); assertFalse(regions.hasNext()); } + + /* + * the VisibleColsIterator is tested elsewhere, this just tests that + * it can be retrieved from HiddenColumns + */ + @Test(groups = "Functional") + public void testGetVisibleColsIterator() + { + HiddenColumns h = new HiddenColumns(); + Iterator it = h.getVisibleColsIterator(0, 10); + + assertTrue(it instanceof RangeElementsIterator); + } + + @Test(groups = "Functional") + public void testHashCode() + { + HiddenColumns h = new HiddenColumns(); + h.hideColumns(0, 25); + + int result = h.hashCode(); + assertTrue(result > 0); + + h.hideColumns(30, 50); + assertTrue(h.hashCode() > 0); + assertTrue(result != h.hashCode()); + } }