X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FHiddenColumnsTest.java;h=a31d52712063f6796a73a0fdf27484beb89f13b3;hb=2a66892874abea357a5e5d9ef2f69919453c31d0;hp=92e0f90aa7ff4c67a79dfbf26dd3df25fd691354;hpb=e2c3b3602486cee3f85dd8dfc7856a5ce6701669;p=jalview.git diff --git a/test/jalview/datamodel/HiddenColumnsTest.java b/test/jalview/datamodel/HiddenColumnsTest.java index 92e0f90..a31d527 100644 --- a/test/jalview/datamodel/HiddenColumnsTest.java +++ b/test/jalview/datamodel/HiddenColumnsTest.java @@ -26,28 +26,17 @@ 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.List; 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 */ @@ -79,22 +68,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 @@ -104,92 +93,36 @@ 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.absoluteToVisibleColumn(65)); } - /** - * Test the method that finds the visible column position a given distance - * before another column - */ @Test(groups = { "Functional" }) - public void testFindColumnNToLeft() + public void testVisibleContigsIterator() { HiddenColumns cs = new HiddenColumns(); - // test that without hidden columns, findColumnNToLeft returns - // position n to left of provided position - long pos = cs.subtractVisibleColumns(3, 10); - assertEquals(7, pos); - - // 0 returns same position - pos = cs.subtractVisibleColumns(0, 10); - assertEquals(10, pos); - - // overflow to left returns negative number - pos = cs.subtractVisibleColumns(3, 0); - assertEquals(-3, pos); - - // test that with hidden columns to left of result column - // behaviour is the same as above - cs.hideColumns(1, 3); - - // position n to left of provided position - pos = cs.subtractVisibleColumns(3, 10); - assertEquals(7, pos); - - // 0 returns same position - pos = cs.subtractVisibleColumns(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); - assertEquals(5, pos); - - // test with two sets of hidden columns between start and required position - cs.hideColumns(20, 21); - pos = cs.subtractVisibleColumns(8, 23); - assertEquals(9, pos); - - // repeat last 2 tests with no hidden columns to left of required position - ColumnSelection colsel = new ColumnSelection(); - cs.revealAllHiddenColumns(colsel); - - // test with one set of hidden columns between start and required position - cs.hideColumns(12, 15); - pos = cs.subtractVisibleColumns(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); - assertEquals(9, pos); - - } - - @Test(groups = { "Functional" }) - public void testGetVisibleContigs() - { - HiddenColumns cs = new HiddenColumns(); - - List visible = cs.getVisibleContigs(3, 10); - assertEquals("[3, 9]", Arrays.toString(visible.get(0))); + Iterator visible = cs.getVisContigsIterator(3, 10, false); + int[] region = visible.next(); + assertEquals("[3, 9]", Arrays.toString(region)); + assertFalse(visible.hasNext()); cs.hideColumns(3, 6); cs.hideColumns(8, 9); @@ -198,30 +131,44 @@ public class HiddenColumnsTest // Test both ends visible region // start position is inclusive, end position exclusive - visible = cs.getVisibleContigs(1, 13); - assertEquals("[1, 2]", Arrays.toString(visible.get(0))); - assertEquals("[7, 7]", Arrays.toString(visible.get(1))); - assertEquals("[10, 11]", Arrays.toString(visible.get(2))); + visible = cs.getVisContigsIterator(1, 13, false); + region = visible.next(); + assertEquals("[1, 2]", Arrays.toString(region)); + region = visible.next(); + assertEquals("[7, 7]", Arrays.toString(region)); + region = visible.next(); + assertEquals("[10, 11]", Arrays.toString(region)); + assertFalse(visible.hasNext()); // Test start hidden, end visible - visible = cs.getVisibleContigs(4, 14); - assertEquals("[7, 7]", Arrays.toString(visible.get(0))); - assertEquals("[10, 11]", Arrays.toString(visible.get(1))); - assertEquals("[13, 13]", Arrays.toString(visible.get(2))); + visible = cs.getVisContigsIterator(4, 14, false); + region = visible.next(); + assertEquals("[7, 7]", Arrays.toString(region)); + region = visible.next(); + assertEquals("[10, 11]", Arrays.toString(region)); + region = visible.next(); + assertEquals("[13, 13]", Arrays.toString(region)); + assertFalse(visible.hasNext()); // Test start hidden, end hidden - visible = cs.getVisibleContigs(3, 10); - assertEquals("[7, 7]", Arrays.toString(visible.get(0))); + 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.getVisibleContigs(0, 13); - assertEquals("[0, 2]", Arrays.toString(visible.get(0))); - assertEquals("[7, 7]", Arrays.toString(visible.get(1))); - assertEquals("[10, 11]", Arrays.toString(visible.get(2))); + visible = cs.getVisContigsIterator(0, 13, false); + region = visible.next(); + assertEquals("[0, 2]", Arrays.toString(region)); + region = visible.next(); + assertEquals("[7, 7]", Arrays.toString(region)); + region = visible.next(); + assertEquals("[10, 11]", Arrays.toString(region)); + assertFalse(visible.hasNext()); // Test empty result - visible = cs.getVisibleContigs(4, 6); - assertEquals(0, visible.size()); + visible = cs.getVisContigsIterator(4, 6, false); + assertFalse(visible.hasNext()); } @Test(groups = { "Functional" }) @@ -237,14 +184,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") @@ -301,7 +265,7 @@ public class HiddenColumnsTest * Test the code used to locate the reference sequence ruler origin */ @Test(groups = { "Functional" }) - public void testLocateVisibleBoundsofSequence() + public void testLocateVisibleStartofSequence() { // create random alignment AlignmentGenerator gen = new AlignmentGenerator(false); @@ -314,29 +278,17 @@ public class HiddenColumnsTest assertEquals(2, seq.findIndex(seq.getStart())); // no hidden columns - assertEquals( - Arrays.toString(new int[] - { seq.findIndex(seq.getStart()) - 1, seq.findIndex(seq.getStart()) - 1, - seq.findIndex(seq.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + 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( - Arrays.toString(new int[] - { seq.findIndex(seq.getStart()) - 1, seq.findIndex(seq.getStart()) - 1, - seq.findIndex(seq.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + 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( - Arrays.toString(new int[] - { seq.findIndex(seq.getStart()) - 2, seq.findIndex(seq.getStart()) - 1, - seq.findIndex(seq.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + assertEquals(seq.findIndex(seq.getStart()) - 2,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); // hide columns around most of sequence - leave one residue remaining @@ -346,206 +298,134 @@ public class HiddenColumnsTest cs.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]); - assertEquals( - Arrays.toString( - new int[] - { 1, seq.findIndex(seq.getStart()) - 1, - seq.findIndex(seq.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + 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( - Arrays.toString( - new int[] - { 0, seq.findIndex(seq.getStart()) - 1, - seq.findIndex(seq.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 15); - assertEquals(Arrays - .toString(new int[] - { 0, seq.findIndex(seq.getStart()) - 1, - seq.findIndex(seq.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); SequenceI seq2 = new Sequence("RefSeq2", "-------A-SD-ASD--E---"); cs.revealAllHiddenColumns(colsel); cs.hideColumns(7, 17); - assertEquals( - Arrays.toString( - new int[] - { 0, seq2.findIndex(seq2.getStart()) - 1, - seq2.findIndex(seq2.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq2))); + assertEquals(0,cs.locateVisibleStartOfSequence(seq2)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(3, 17); - assertEquals( - Arrays.toString( - new int[] - { 0, seq2.findIndex(seq2.getStart()) - 1, - seq2.findIndex(seq2.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq2))); + assertEquals(0,cs.locateVisibleStartOfSequence(seq2)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(3, 19); - assertEquals( - Arrays.toString( - new int[] - { 0, seq2.findIndex(seq2.getStart()) - 1, - seq2.findIndex(seq2.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq2))); + assertEquals(0,cs.locateVisibleStartOfSequence(seq2)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 0); - int[] test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 0, 1, 11 }), - Arrays.toString(test)); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 1); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 1, 1, 11 }), - Arrays.toString(test)); + assertEquals(1,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 2); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 0, 1, 11 }), - Arrays.toString(test)); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(1, 1); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 2, 1, 11 }), - Arrays.toString(test)); + assertEquals(2,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(1, 2); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 1, 1, 11 }), - Arrays.toString(test)); + assertEquals(1,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(1, 3); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 1, 1, 11 }), - Arrays.toString(test)); + assertEquals(1,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 2); cs.hideColumns(5, 6); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 0, 1, 11 }), - Arrays.toString(test)); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 2); cs.hideColumns(5, 6); cs.hideColumns(9, 10); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 0, 1, 11 }), - Arrays.toString(test)); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 2); cs.hideColumns(7, 11); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 0, 1, 11 }), - Arrays.toString(test)); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(2, 4); cs.hideColumns(7, 11); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 1, 1, 11 }), - Arrays.toString(test)); + assertEquals(1,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(2, 4); cs.hideColumns(7, 12); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 1, 1, 11 }), - Arrays.toString(test)); + assertEquals(1,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(1, 11); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 0, 1, 11 }), - Arrays.toString(test)); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 12); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 0, 1, 11 }), - Arrays.toString(test)); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 4); cs.hideColumns(6, 12); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 0, 1, 11 }), - Arrays.toString(test)); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 1); cs.hideColumns(3, 12); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 0, 1, 11 }), - Arrays.toString(test)); + assertEquals(0,cs.locateVisibleStartOfSequence(seq)); - // These tests cover different behaviour to original - // locateVisibleBoundsOfSequence - // Previously first values of each were 3,9 and 6 respectively. cs.revealAllHiddenColumns(colsel); cs.hideColumns(3, 14); cs.hideColumns(17, 19); - assertEquals( - Arrays.toString( - new int[] - { 3, seq2.findIndex(seq2.getStart()) - 1, - seq2.findIndex(seq2.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq2))); + assertEquals(3,cs.locateVisibleStartOfSequence(seq2)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(3, 7); cs.hideColumns(9, 14); cs.hideColumns(17, 19); - assertEquals( - Arrays.toString( - new int[] - { 9, seq2.findIndex(seq2.getStart()) - 1, - seq2.findIndex(seq2.getEnd()) - 1 }), - Arrays.toString(cs.locateVisibleBoundsOfSequence(seq2))); + assertEquals(9,cs.locateVisibleStartOfSequence(seq2)); cs.revealAllHiddenColumns(colsel); cs.hideColumns(0, 1); cs.hideColumns(3, 4); cs.hideColumns(6, 8); cs.hideColumns(10, 12); - test = cs.locateVisibleBoundsOfSequence(seq); - assertEquals(Arrays.toString(new int[] { 6, 1, 11 }), - Arrays.toString(test)); + assertEquals(6, cs.locateVisibleStartOfSequence(seq)); } @Test(groups = { "Functional" }) - public void testLocateVisibleBoundsPathologicals() + 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.hideInsertionsFor(al.getSequenceAt(0)); + cs.hideInsertionsFor(al.getSequenceAt(0).getInsertions()); assertEquals("G", "" - + al.getSequenceAt(0).getCharAt(cs.adjustForHiddenColumns(9))); + + 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" }) @@ -631,6 +511,16 @@ public class HiddenColumnsTest regions = cs.iterator(); assertEquals(1, cs.getNumberOfRegions()); assertEquals("[1, 7]", Arrays.toString(regions.next())); + + 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())); } /** @@ -642,6 +532,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); @@ -661,6 +556,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" }) @@ -668,6 +583,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); @@ -701,6 +621,7 @@ public class HiddenColumnsTest assertTrue(cs.isVisible(5)); assertFalse(cs.isVisible(6)); assertFalse(cs.isVisible(7)); + assertTrue(cs.isVisible(8)); } /** @@ -768,40 +689,40 @@ public class HiddenColumnsTest // one hidden range one.set(1); cs = new HiddenColumns(); - cs.hideMarkedBits(one); + cs.hideColumns(one); assertEquals(1, cs.getNumberOfRegions()); one.set(2); cs = new HiddenColumns(); - cs.hideMarkedBits(one); + cs.hideColumns(one); assertEquals(1, cs.getNumberOfRegions()); one.set(3); cs = new HiddenColumns(); - cs.hideMarkedBits(one); + cs.hideColumns(one); assertEquals(1, cs.getNumberOfRegions()); // split one.clear(2); cs = new HiddenColumns(); - cs.hideMarkedBits(one); + cs.hideColumns(one); assertEquals(2, cs.getNumberOfRegions()); - 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.getNumberOfRegions()); - assertEquals(0, cs.adjustForHiddenColumns(0)); - assertEquals(1, cs.adjustForHiddenColumns(1)); - assertEquals(2, cs.adjustForHiddenColumns(2)); - assertEquals(4, cs.adjustForHiddenColumns(3)); + assertEquals(0, cs.visibleToAbsoluteColumn(0)); + assertEquals(1, cs.visibleToAbsoluteColumn(1)); + assertEquals(2, cs.visibleToAbsoluteColumn(2)); + assertEquals(4, cs.visibleToAbsoluteColumn(3)); } @Test(groups = { "Functional" }) @@ -818,7 +739,14 @@ public class HiddenColumnsTest { number.nextLong(), number.nextLong(), number.nextLong() }); toMark.set(n * number.nextInt(10), n * (25 + number.nextInt(25))); HiddenColumns hc = new HiddenColumns(); - hc.hideMarkedBits(toMark); + + if (n == 0) + { + hc.markHiddenRegions(fromMark = new BitSet()); + assertTrue(fromMark.isEmpty()); + } + + hc.hideColumns(toMark); // see if we can recover bitfield hc.markHiddenRegions(fromMark = new BitSet()); @@ -827,49 +755,6 @@ public class HiddenColumnsTest } @Test(groups = { "Functional" }) - public void testFindHiddenRegionPositions() - { - HiddenColumns hc = new HiddenColumns(); - - List positions = hc.findHiddenRegionPositions(0, 20); - assertTrue(positions.isEmpty()); - - hc.hideColumns(3, 7); - hc.hideColumns(10, 10); - hc.hideColumns(14, 15); - - positions = hc.findHiddenRegionPositions(0, 20); - assertEquals(3, positions.size()); - assertEquals(3, positions.get(0).intValue()); - assertEquals(5, positions.get(1).intValue()); - assertEquals(8, positions.get(2).intValue()); - - positions = hc.findHiddenRegionPositions(7, 20); - assertEquals(2, positions.size()); - assertEquals(5, positions.get(0).intValue()); - assertEquals(8, positions.get(1).intValue()); - - positions = hc.findHiddenRegionPositions(11, 13); - assertEquals(0, positions.size()); - - positions = hc.findHiddenRegionPositions(7, 20); - assertEquals(2, positions.size()); - assertEquals(5, positions.get(0).intValue()); - assertEquals(8, positions.get(1).intValue()); - - positions = hc.findHiddenRegionPositions(0, 1); - assertEquals(0, positions.size()); - - positions = hc.findHiddenRegionPositions(17, 20); - assertEquals(0, positions.size()); - - positions = hc.findHiddenRegionPositions(10, 15); - assertEquals(2, positions.size()); - assertEquals(5, positions.get(0).intValue()); - assertEquals(8, positions.get(1).intValue()); - } - - @Test(groups = { "Functional" }) public void testRegionsToString() { HiddenColumns hc = new HiddenColumns(); @@ -886,7 +771,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 }); @@ -912,6 +797,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") @@ -930,6 +822,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]); @@ -947,6 +843,9 @@ public class HiddenColumnsTest result = hc.getRegionWithEdgeAtRes(8); assertEquals(14, result[0]); assertEquals(15, result[1]); + + result = hc.getRegionWithEdgeAtRes(16); + assertNull(result); } @Test(groups = "Functional") @@ -965,6 +864,11 @@ public class HiddenColumnsTest 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; @@ -976,18 +880,22 @@ public class HiddenColumnsTest false); // confirm that original contigs are as expected - List visible = hidden.getVisibleContigs(0, 25); - assertEquals("[0, 14]", Arrays.toString(visible.get(0))); - assertEquals("[18, 24]", Arrays.toString(visible.get(1))); + 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.getVisibleContigs(0, 25); - assertEquals("[0, 10]", Arrays.toString(visible.get(0))); - assertEquals("[14, 24]", Arrays.toString(visible.get(1))); + 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 @@ -1030,18 +938,24 @@ public class HiddenColumnsTest false); // confirm that original contigs are as expected - List visible = hidden.getVisibleContigs(0, 20); - assertEquals("[0, 6]", Arrays.toString(visible.get(0))); - assertEquals("[11, 19]", Arrays.toString(visible.get(1))); + 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.getVisibleContigs(0, 20); - assertEquals("[0, 4]", Arrays.toString(visible.get(0))); - assertEquals("[7, 19]", Arrays.toString(visible.get(1))); + 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 @@ -1074,20 +988,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") @@ -1095,22 +1009,22 @@ 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") @@ -1147,6 +1061,9 @@ public class HiddenColumnsTest h.hideColumns(15, 20); assertEquals(15, h.getHiddenBoundaryRight(7)); assertEquals(15, h.getHiddenBoundaryRight(14)); + + // returns same value if there is no next hidden column + assertEquals(22, h.getHiddenBoundaryRight(22)); } @Test(groups = "Functional") @@ -1222,10 +1139,10 @@ public class HiddenColumnsTest SequenceI seq1 = new Sequence("TEST1", "GAL---MFW-KQESPVICY--HRNDT"); SequenceI seq2 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT"); - h.hideInsertionsFor(seq2); + h.hideInsertionsFor(seq2.getInsertions()); assertTrue(h.equals(h2)); - h.hideInsertionsFor(seq1); + h.hideInsertionsFor(seq1.getInsertions()); h2.hideColumns(3, 5); h2.hideColumns(9, 9); h2.hideColumns(19, 20); @@ -1239,14 +1156,14 @@ public class HiddenColumnsTest HiddenColumns h2 = new HiddenColumns(); BitSet tohide = new BitSet(21); - h.hideMarkedBits(tohide); + h.hideColumns(tohide); assertTrue(h.equals(h2)); // NB in hideMarkedBits, the last bit is not set to hidden tohide.set(3, 6); tohide.set(9); tohide.set(19, 21); - h.hideMarkedBits(tohide); + h.hideColumns(tohide); h2.hideColumns(3, 5); h2.hideColumns(9, 9); @@ -1265,6 +1182,38 @@ public class HiddenColumnsTest AlignmentAnnotation ann = new AlignmentAnnotation("an", "some an", anns); + // null annotation + AlignmentAnnotation nullann = null; + h.makeVisibleAnnotation(nullann); + assertNull(nullann); + + h.makeVisibleAnnotation(1, 2, nullann); + assertNull(nullann); + + // null annotations + AlignmentAnnotation emptyann = new AlignmentAnnotation("an", "some ann", null); + h.makeVisibleAnnotation(emptyann); + assertNull(emptyann.annotations); + + h.makeVisibleAnnotation(3, 4, emptyann); + assertNull(emptyann.annotations); + + // without bounds, does everything + h.makeVisibleAnnotation(ann); + assertEquals(12, ann.annotations.length); + assertNull(ann.annotations[0]); + assertNull(ann.annotations[1]); + assertEquals(1.0f, ann.annotations[2].value); + assertEquals(2.0f, ann.annotations[3].value); + assertEquals(3.0f, ann.annotations[4].value); + assertNull(ann.annotations[5]); + assertNull(ann.annotations[6]); + assertEquals(4.0f, ann.annotations[7].value); + assertEquals(5.0f, ann.annotations[8].value); + assertEquals(6.0f, ann.annotations[9].value); + assertEquals(7.0f, ann.annotations[10].value); + assertEquals(8.0f, ann.annotations[11].value); + // without hidden cols, just truncates h.makeVisibleAnnotation(3, 5, ann); assertEquals(3, ann.annotations.length); @@ -1297,6 +1246,24 @@ public class HiddenColumnsTest assertEquals(2.0f, ann.annotations[0].value); assertEquals(5.0f, ann.annotations[1].value); assertEquals(6.0f, ann.annotations[2].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), new Annotation(9), new Annotation(10), + new Annotation(11), new Annotation(12), new Annotation(13), + new Annotation(14), new Annotation(15) }; + ann = new AlignmentAnnotation("an", "some an", anns); + h = new HiddenColumns(); + h.hideColumns(5, 18); + h.hideColumns(20, 21); + h.makeVisibleAnnotation(1, 21, ann); + assertEquals(5, ann.annotations.length); + assertEquals(1.0f, ann.annotations[1].value); + assertEquals(2.0f, ann.annotations[2].value); + assertEquals(3.0f, ann.annotations[3].value); + assertNull(ann.annotations[0]); + assertNull(ann.annotations[4]); } @Test(groups = "Functional") @@ -1331,13 +1298,66 @@ public class HiddenColumnsTest h.hideColumns(0, 30); result = h.subtractVisibleColumns(31, 0); assertEquals(-31, result); + + HiddenColumns cs = new HiddenColumns(); + + // test that without hidden columns, findColumnNToLeft returns + // position n to left of provided position + long pos = cs.subtractVisibleColumns(3, 10); + assertEquals(7, pos); + + // 0 returns same position + pos = cs.subtractVisibleColumns(0, 10); + assertEquals(10, pos); + + // overflow to left returns negative number + pos = cs.subtractVisibleColumns(3, 0); + assertEquals(-3, pos); + + // test that with hidden columns to left of result column + // behaviour is the same as above + cs.hideColumns(1, 3); + + // position n to left of provided position + pos = cs.subtractVisibleColumns(3, 10); + assertEquals(7, pos); + + // 0 returns same position + pos = cs.subtractVisibleColumns(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); + assertEquals(5, pos); + + // test with two sets of hidden columns between start and required position + cs.hideColumns(20, 21); + pos = cs.subtractVisibleColumns(8, 23); + assertEquals(9, pos); + + // repeat last 2 tests with no hidden columns to left of required position + ColumnSelection colsel = new ColumnSelection(); + cs.revealAllHiddenColumns(colsel); + + // test with one set of hidden columns between start and required position + cs.hideColumns(12, 15); + pos = cs.subtractVisibleColumns(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); + assertEquals(9, pos); + } + @Test(groups = "Functional") public void testBoundedIterator() { HiddenColumns h = new HiddenColumns(); - Iterator it = h.getBoundedIterator(0, 10, false); + Iterator it = h.getBoundedIterator(0, 10); // no hidden columns = nothing to iterate over assertFalse(it.hasNext()); @@ -1346,7 +1366,7 @@ public class HiddenColumnsTest // all regions are returned h.hideColumns(3, 10); h.hideColumns(14, 16); - it = h.getBoundedIterator(0, 20, false); + it = h.getBoundedIterator(0, 20); assertTrue(it.hasNext()); int[] next = it.next(); assertEquals(3, next[0]); @@ -1358,7 +1378,7 @@ public class HiddenColumnsTest // [start,end] overlaps a region // 1 region returned - it = h.getBoundedIterator(5, 7, false); + it = h.getBoundedIterator(5, 7); assertTrue(it.hasNext()); next = it.next(); assertEquals(3, next[0]); @@ -1367,7 +1387,7 @@ public class HiddenColumnsTest // [start,end] fully contains 1 region and start of last // - 2 regions returned - it = h.getBoundedIterator(3, 15, false); + it = h.getBoundedIterator(3, 15); assertTrue(it.hasNext()); next = it.next(); assertEquals(3, next[0]); @@ -1379,7 +1399,7 @@ public class HiddenColumnsTest // [start,end] contains end of first region and whole of last region // - 2 regions returned - it = h.getBoundedIterator(4, 20, false); + it = h.getBoundedIterator(4, 20); assertTrue(it.hasNext()); next = it.next(); assertEquals(3, next[0]); @@ -1394,7 +1414,7 @@ public class HiddenColumnsTest public void testBoundedStartIterator() { HiddenColumns h = new HiddenColumns(); - Iterator it = h.getBoundedStartIterator(0, 10, false); + Iterator it = h.getBoundedStartIterator(0, 10); // no hidden columns = nothing to iterate over assertFalse(it.hasNext()); @@ -1403,7 +1423,7 @@ public class HiddenColumnsTest // all regions are returned h.hideColumns(3, 10); h.hideColumns(14, 16); - it = h.getBoundedStartIterator(0, 20, false); + it = h.getBoundedStartIterator(0, 20); assertTrue(it.hasNext()); int next = it.next(); assertEquals(3, next); @@ -1413,12 +1433,12 @@ public class HiddenColumnsTest // [start,end] does not contain a start of a region // no regions to iterate over - it = h.getBoundedStartIterator(4, 5, false); + it = h.getBoundedStartIterator(4, 5); assertFalse(it.hasNext()); // [start,end] fully contains 1 region and start of last // - 2 regions returned - it = h.getBoundedStartIterator(3, 7, false); + it = h.getBoundedStartIterator(3, 7); assertTrue(it.hasNext()); next = it.next(); assertEquals(3, next); @@ -1428,7 +1448,7 @@ public class HiddenColumnsTest // [start,end] contains whole of last region // - 1 region returned - it = h.getBoundedStartIterator(4, 20, false); + it = h.getBoundedStartIterator(4, 20); assertTrue(it.hasNext()); next = it.next(); assertEquals(6, next); @@ -1436,63 +1456,158 @@ public class HiddenColumnsTest } @Test(groups = "Functional") - public void testVisRegionsIterator() + public void testVisibleBlocksVisBoundsIterator() { HiddenColumns h = new HiddenColumns(); - Iterator it = h.getBoundedVisRegionIterator(0, 15); - - // no hidden columns = single visible contig - assertTrue(it.hasNext()); - assertEquals("[0, 15]", Arrays.toString(it.next())); - - // hidden column region at start + Iterator regions = h.getVisContigsIterator(0, 31, true); + + // only 1 visible region spanning 0-30 if nothing is hidden + assertTrue(regions.hasNext()); + int[] region = regions.next(); + assertEquals(0, region[0]); + assertEquals(30, region[1]); + assertFalse(regions.hasNext()); + + // hide 1 region in middle + // 2 regions one on either side + // second region boundary accounts for hidden columns + h.hideColumns(10, 15); + regions = h.getVisContigsIterator(0, 31, true); + + assertTrue(regions.hasNext()); + region = regions.next(); + assertEquals(0, region[0]); + assertEquals(9, region[1]); + region = regions.next(); + assertEquals(16, region[0]); + assertEquals(36, region[1]); + assertFalse(regions.hasNext()); + + // single hidden region at left + h = new HiddenColumns(); h.hideColumns(0, 5); - it = h.getBoundedVisRegionIterator(0, 15); - assertTrue(it.hasNext()); - assertEquals("[6, 15]", Arrays.toString(it.next())); + regions = h.getVisContigsIterator(0, 31, true); - // hidden column region at end - h = new HiddenColumns(); - h.hideColumns(8, 15); - it = h.getBoundedVisRegionIterator(0, 15); - assertTrue(it.hasNext()); - assertEquals("[0, 7]", Arrays.toString(it.next())); + assertTrue(regions.hasNext()); + region = regions.next(); + assertEquals(6, region[0]); + assertEquals(36, region[1]); + assertFalse(regions.hasNext()); - // hidden column region across whole region + // single hidden region at right h = new HiddenColumns(); - h.hideColumns(0, 20); - it = h.getBoundedVisRegionIterator(0, 15); - assertFalse(it.hasNext()); - - // hidden column region in middle + h.hideColumns(27, 30); + regions = h.getVisContigsIterator(0, 31, true); + + assertTrue(regions.hasNext()); + region = regions.next(); + assertEquals(0, region[0]); + assertEquals(26, region[1]); + region = regions.next(); + assertEquals(31, region[0]); + assertEquals(34, region[1]); + assertFalse(regions.hasNext()); + + // hidden region at left + hidden region in middle h = new HiddenColumns(); - h.hideColumns(1, 14); - it = h.getBoundedVisRegionIterator(0, 15); - assertTrue(it.hasNext()); - assertEquals("[0, 0]", Arrays.toString(it.next())); - assertTrue(it.hasNext()); - assertEquals("[15, 15]", Arrays.toString(it.next())); - - // hidden column region just off either end + h.hideColumns(0, 5); + h.hideColumns(23, 25); + regions = h.getVisContigsIterator(0, 31, true); + + assertTrue(regions.hasNext()); + region = regions.next(); + assertEquals(6, region[0]); + assertEquals(22, region[1]); + region = regions.next(); + assertEquals(26, region[0]); + assertEquals(39, region[1]); + assertFalse(regions.hasNext()); + + // hidden region at right + hidden region in middle h = new HiddenColumns(); - h.hideColumns(3, 14); - it = h.getBoundedVisRegionIterator(4, 13); - assertFalse(it.hasNext()); - - // multiple regions + h.hideColumns(27, 30); + h.hideColumns(11, 14); + regions = h.getVisContigsIterator(0, 31, true); + + assertTrue(regions.hasNext()); + region = regions.next(); + assertEquals(0, region[0]); + assertEquals(10, region[1]); + region = regions.next(); + assertEquals(15, region[0]); + assertEquals(26, region[1]); + region = regions.next(); + assertEquals(31, region[0]); + assertEquals(38, region[1]); + assertFalse(regions.hasNext()); + + // hidden region at left and right h = new HiddenColumns(); + h.hideColumns(27, 35); + h.hideColumns(0, 4); + regions = h.getVisContigsIterator(0, 31, true); + + assertTrue(regions.hasNext()); + region = regions.next(); + assertEquals(5, region[0]); + assertEquals(26, region[1]); + region = regions.next(); + assertEquals(36, region[0]); + assertEquals(44, region[1]); + assertFalse(regions.hasNext()); + + // multiple hidden regions + h = new HiddenColumns(); + h.hideColumns(1, 1); h.hideColumns(3, 5); - h.hideColumns(7, 11); - h.hideColumns(14, 19); - h.hideColumns(24, 25); - h.hideColumns(35, 39); - it = h.getBoundedVisRegionIterator(8, 26); - assertTrue(it.hasNext()); - assertEquals("[12, 13]", Arrays.toString(it.next())); - assertTrue(it.hasNext()); - assertEquals("[20, 23]", Arrays.toString(it.next())); - assertTrue(it.hasNext()); - assertEquals("[26, 26]", Arrays.toString(it.next())); - assertFalse(it.hasNext()); + h.hideColumns(9, 11); + h.hideColumns(22, 26); + + regions = h.getVisContigsIterator(0, 31, true); + + assertTrue(regions.hasNext()); + region = regions.next(); + assertEquals(0, region[0]); + assertEquals(0, region[1]); + region = regions.next(); + assertEquals(2, region[0]); + assertEquals(2, region[1]); + region = regions.next(); + assertEquals(6, region[0]); + assertEquals(8, region[1]); + region = regions.next(); + assertEquals(12, region[0]); + assertEquals(21, region[1]); + region = regions.next(); + assertEquals(27, region[0]); + 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 VisibleColsIterator); + } + + @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()); } }