/*
 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
 * Copyright (C) $$Year-Rel$$ The Jalview Authors
 * 
 * This file is part of Jalview.
 * 
 * Jalview is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License 
 * as published by the Free Software Foundation, either version 3
 * of the License, or (at your option) any later version.
 *  
 * Jalview is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty 
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
 * PURPOSE.  See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
 * The Jalview Authors are detailed in the 'AUTHORS' file.
 */
package jalview.datamodel;

import static org.testng.Assert.assertNull;
import static org.testng.AssertJUnit.assertEquals;
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;
import java.util.Iterator;
import java.util.Random;

import org.testng.annotations.Test;

public class HiddenColumnsTest
{
  /**
   * Test the method which counts the number of hidden columns
   */
  @Test(groups = { "Functional" })
  public void testGetSize()
  {
    HiddenColumns hidden = new HiddenColumns();
    assertEquals(0, hidden.getSize());

    hidden.hideColumns(3, 5);
    assertEquals(3, hidden.getSize());

    hidden.hideColumns(8, 8);
    assertEquals(4, hidden.getSize());

    hidden.hideColumns(9, 14);
    assertEquals(10, hidden.getSize());

    ColumnSelection cs = new ColumnSelection();
    hidden.revealAllHiddenColumns(cs);
    assertEquals(0, hidden.getSize());
  }

  /**
   * Test the method that finds the visible column position of an alignment
   * column, allowing for hidden columns.
   */
  @Test(groups = { "Functional" })
  public void testFindColumnPosition()
  {
    HiddenColumns cs = new HiddenColumns();
    assertEquals(5, cs.findColumnPosition(5));

    // hiding column 6 makes no difference
    cs.hideColumns(6, 6);
    assertEquals(5, cs.findColumnPosition(5));

    // hiding column 4 moves column 5 to column 4
    cs.hideColumns(4, 4);
    assertEquals(4, cs.findColumnPosition(5));

    // hiding column 4 moves column 4 to position 3
    assertEquals(3, cs.findColumnPosition(4));

    // hiding columns 1 and 2 moves column 5 to column 2
    cs.hideColumns(1, 2);
    assertEquals(2, cs.findColumnPosition(5));

    // check with > 1 hidden column regions
    // where some columns are in the hidden regions
    HiddenColumns cs2 = new HiddenColumns();
    cs2.hideColumns(5, 10);
    cs2.hideColumns(20, 27);
    cs2.hideColumns(40, 44);

    // hiding columns 5-10 and 20-27 moves column 8 to column 4
    assertEquals(4, cs2.findColumnPosition(8));

    // and moves column 24 to 13
    assertEquals(13, cs2.findColumnPosition(24));

    // and moves column 28 to 14
    assertEquals(14, cs2.findColumnPosition(28));

    // and moves column 40 to 25
    assertEquals(25, cs2.findColumnPosition(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));

    // check that column after the last hidden region doesn't crash
    assertEquals(46, cs2.findColumnPosition(65));
  }

  @Test(groups = { "Functional" })
  public void testVisibleContigsIterator()
  {
    HiddenColumns cs = new HiddenColumns();

    Iterator<int[]> 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);
    cs.hideColumns(12, 12);

    // Test both ends visible region

    // start position is inclusive, end position exclusive
    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.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.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, 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.getVisContigsIterator(4, 6, false);
    assertFalse(visible.hasNext());
  }

  @Test(groups = { "Functional" })
  public void testEquals()
  {
    HiddenColumns cs = new HiddenColumns();
    cs.hideColumns(5, 9);

    // a different set of hidden columns
    HiddenColumns cs2 = new HiddenColumns();

    // with no hidden columns
    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")
  public void testCopyConstructor()
  {
    HiddenColumns cs = new HiddenColumns();
    cs.hideColumns(10, 11);
    cs.hideColumns(5, 7);
    Iterator<int[]> regions = cs.iterator();
    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()));
  }

  @Test(groups = "Functional")
  public void testCopyConstructor2()
  {
    HiddenColumns cs = new HiddenColumns();
    cs.hideColumns(10, 11);
    cs.hideColumns(5, 7);

    HiddenColumns cs2 = new HiddenColumns(cs, 3, 9, 1);
    assertTrue(cs2.hasHiddenColumns());
    Iterator<int[]> regions = cs2.iterator();

    // only [5,7] returned, offset by 1
    assertEquals("[4, 6]",
            Arrays.toString(regions.next()));
    assertEquals(3, cs2.getSize());

    cs2 = new HiddenColumns(cs, 8, 15, 4);
    regions = cs2.iterator();
    assertTrue(cs2.hasHiddenColumns());

    // only [10,11] returned, offset by 4
    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 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.hideInsertionsFor(al.getSequenceAt(0));
    assertEquals("G", ""
            + al.getSequenceAt(0).getCharAt(cs.adjustForHiddenColumns(9)));

    // KM: no idea what this is meant to be testing... seems to be an unfinished
    // test
  }

  @Test(groups = { "Functional" })
  public void testHideColumns()
  {
    // create random alignment
    AlignmentGenerator gen = new AlignmentGenerator(false);
    AlignmentI al = gen.generate(50, 20, 123, 5, 5);

    ColumnSelection colsel = new ColumnSelection();
    HiddenColumns cs = al.getHiddenColumns();
    colsel.hideSelectedColumns(5, al.getHiddenColumns());
    Iterator<int[]> regions = cs.iterator();
    assertEquals(1, cs.getNumberOfRegions());
    assertEquals("[5, 5]", Arrays.toString(regions.next()));

    colsel.hideSelectedColumns(3, al.getHiddenColumns());
    regions = cs.iterator();
    assertEquals(2, cs.getNumberOfRegions());
    // two hidden ranges, in order:
    assertEquals("[3, 3]", Arrays.toString(regions.next()));
    assertEquals("[5, 5]", Arrays.toString(regions.next()));

    // hiding column 4 expands [3, 3] to [3, 4]
    // and merges to [5, 5] to make [3, 5]
    colsel.hideSelectedColumns(4, al.getHiddenColumns());
    regions = cs.iterator();
    assertEquals(1, cs.getNumberOfRegions());
    assertEquals("[3, 5]", Arrays.toString(regions.next()));

    // 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());

    cs.hideColumns(3, 6);
    regions = cs.iterator();
    int[] firstHiddenRange = regions.next();
    assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));

    // 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()));
    cs.hideColumns(3, 5);
    regions = cs.iterator();
    assertEquals(1, cs.getNumberOfRegions());
    assertEquals("[3, 6]",
            Arrays.toString(regions.next()));
    cs.hideColumns(4, 6);
    regions = cs.iterator();
    assertEquals(1, cs.getNumberOfRegions());
    assertEquals("[3, 6]",
            Arrays.toString(regions.next()));
    cs.hideColumns(3, 6);
    regions = cs.iterator();
    assertEquals(1, cs.getNumberOfRegions());
    assertEquals("[3, 6]",
            Arrays.toString(regions.next()));

    cs.revealAllHiddenColumns(colsel);
    cs.hideColumns(2, 4);
    regions = cs.iterator();
    assertEquals(1, cs.getNumberOfRegions());
    assertEquals("[2, 4]", Arrays.toString(regions.next()));

    // extend contiguous with 2 positions overlap
    cs.hideColumns(3, 5);
    regions = cs.iterator();
    assertEquals(1, cs.getNumberOfRegions());
    assertEquals("[2, 5]", Arrays.toString(regions.next()));

    // extend contiguous with 1 position overlap
    cs.hideColumns(5, 6);
    regions = cs.iterator();
    assertEquals(1, cs.getNumberOfRegions());
    assertEquals("[2, 6]", Arrays.toString(regions.next()));

    // extend contiguous with overlap both ends:
    cs.hideColumns(1, 7);
    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()));
  }

  /**
   * Test the method that reveals a range of hidden columns given the start
   * column of the range
   */
  @Test(groups = { "Functional" })
  public void testRevealHiddenColumns()
  {
    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);

    // hiddenColumns now empty
    assertEquals(0, cs.getSize());

    // revealed columns are marked as selected (added to selection):
    assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString());

    // calling with a column other than the range start does nothing:
    colsel = new ColumnSelection();
    cs = new HiddenColumns();
    cs.hideColumns(5, 8);

    int prevSize = cs.getSize();
    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" })
  public void testRevealAllHiddenColumns()
  {
    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);
    colsel.addElement(1);
    hidden.revealAllHiddenColumns(colsel);

    /*
     * revealing hidden columns adds them (in order) to the (unordered)
     * selection list
     */

    // hiddenColumns now empty
    assertEquals(0, hidden.getSize());

    assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]",
            colsel.getSelected().toString());
  }

  @Test(groups = { "Functional" })
  public void testIsVisible()
  {
    HiddenColumns cs = new HiddenColumns();
    cs.hideColumns(2, 4);
    cs.hideColumns(6, 7);
    assertTrue(cs.isVisible(0));
    assertTrue(cs.isVisible(-99));
    assertTrue(cs.isVisible(1));
    assertFalse(cs.isVisible(2));
    assertFalse(cs.isVisible(3));
    assertFalse(cs.isVisible(4));
    assertTrue(cs.isVisible(5));
    assertFalse(cs.isVisible(6));
    assertFalse(cs.isVisible(7));
  }

  /**
   * Test for the case when a hidden range encloses more one already hidden
   * range
   */
  @Test(groups = { "Functional" })
  public void testHideColumns_subsumingHidden()
  {
    /*
     * JAL-2370 bug scenario:
     * two hidden ranges subsumed by a third
     */
    HiddenColumns cs = new HiddenColumns();
    cs.hideColumns(49, 59);
    cs.hideColumns(69, 79);
    Iterator<int[]> regions = cs.iterator();
    assertEquals(2, cs.getNumberOfRegions());
    assertEquals("[49, 59]", Arrays.toString(regions.next()));
    assertEquals("[69, 79]", Arrays.toString(regions.next()));

    cs.hideColumns(48, 80);
    regions = cs.iterator();
    assertEquals(1, cs.getNumberOfRegions());
    assertEquals("[48, 80]", Arrays.toString(regions.next()));

    /*
     * another...joining hidden ranges
     */
    cs = new HiddenColumns();
    cs.hideColumns(10, 20);
    cs.hideColumns(30, 40);
    cs.hideColumns(50, 60);
    // hiding 21-49 should merge to one range
    cs.hideColumns(21, 49);
    regions = cs.iterator();
    assertEquals(1, cs.getNumberOfRegions());
    assertEquals("[10, 60]", Arrays.toString(regions.next()));

    /*
     * another...left overlap, subsumption, right overlap,
     * no overlap of existing hidden ranges
     */
    cs = new HiddenColumns();
    cs.hideColumns(10, 20);
    cs.hideColumns(10, 20);
    cs.hideColumns(30, 35);
    cs.hideColumns(40, 50);
    cs.hideColumns(60, 70);

    cs.hideColumns(15, 45);
    regions = cs.iterator();
    assertEquals(2, cs.getNumberOfRegions());
    assertEquals("[10, 50]", Arrays.toString(regions.next()));
    assertEquals("[60, 70]", Arrays.toString(regions.next()));
  }

  @Test(groups = { "Functional" })
  public void testHideBitset()
  {
    HiddenColumns cs;

    BitSet one = new BitSet();

    // one hidden range
    one.set(1);
    cs = new HiddenColumns();
    cs.hideMarkedBits(one);
    assertEquals(1, cs.getNumberOfRegions());

    one.set(2);
    cs = new HiddenColumns();
    cs.hideMarkedBits(one);
    assertEquals(1, cs.getNumberOfRegions());

    one.set(3);
    cs = new HiddenColumns();
    cs.hideMarkedBits(one);
    assertEquals(1, cs.getNumberOfRegions());

    // split
    one.clear(2);
    cs = new HiddenColumns();
    cs.hideMarkedBits(one);
    assertEquals(2, cs.getNumberOfRegions());

    assertEquals(0, cs.adjustForHiddenColumns(0));
    assertEquals(2, cs.adjustForHiddenColumns(1));
    assertEquals(4, cs.adjustForHiddenColumns(2));

    // one again
    one.clear(1);
    cs = new HiddenColumns();
    cs.hideMarkedBits(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));
  }

  @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();

      if (n == 0)
      {
        hc.markHiddenRegions(fromMark = new BitSet());
        assertTrue(fromMark.isEmpty());
      }

      hc.hideMarkedBits(toMark);

      // see if we can recover bitfield
      hc.markHiddenRegions(fromMark = new BitSet());
      assertEquals(toMark, fromMark);
    }
  }

  @Test(groups = { "Functional" })
  public void testRegionsToString()
  {
    HiddenColumns hc = new HiddenColumns();

    String result = hc.regionsToString(",", "--");
    assertEquals("", result);

    hc.hideColumns(3, 7);
    hc.hideColumns(10, 10);
    hc.hideColumns(14, 15);

    result = hc.regionsToString(",", "--");
    assertEquals("3--7,10--10,14--15", result);
  }

  @Test(groups = "Functional")
  public void testGetVisibleStartAndEndIndexTest()
  {
    Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
    AlignmentI align = new Alignment(new SequenceI[] { seq });
    HiddenColumns hc = new HiddenColumns();

    int[] startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
    assertEquals(0, startEnd[0]);
    assertEquals(25, startEnd[1]);

    hc.hideColumns(0, 0);
    startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
    assertEquals(1, startEnd[0]);
    assertEquals(25, startEnd[1]);

    hc.hideColumns(6, 9);
    hc.hideColumns(11, 12);
    startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
    assertEquals(1, startEnd[0]);
    assertEquals(25, startEnd[1]);

    hc.hideColumns(24, 25);
    startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
    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")
  public void testGetRegionWithEdgeAtRes()
  {
    HiddenColumns hc = new HiddenColumns();

    int[] result = hc.getRegionWithEdgeAtRes(5);
    assertNull(result);

    hc.hideColumns(3, 7);
    hc.hideColumns(10, 10);
    hc.hideColumns(14, 15);

    result = hc.getRegionWithEdgeAtRes(2);
    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]);

    result = hc.getRegionWithEdgeAtRes(6);
    assertNull(result);

    result = hc.getRegionWithEdgeAtRes(0);
    assertNull(result);

    result = hc.getRegionWithEdgeAtRes(7);
    assertEquals(14, result[0]);
    assertEquals(15, result[1]);

    result = hc.getRegionWithEdgeAtRes(8);
    assertEquals(14, result[0]);
    assertEquals(15, result[1]);

    result = hc.getRegionWithEdgeAtRes(16);
    assertNull(result);
  }

  @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<int[]> 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<int[]> 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();

    // new HiddenColumns2 has no hidden cols
    assertFalse(h.hasHiddenColumns());

    // some columns hidden, returns true
    h.hideColumns(5, 10);
    assertTrue(h.hasHiddenColumns());

    // reveal columns, no hidden cols again
    ColumnSelection sel = new ColumnSelection();
    h.revealAllHiddenColumns(sel);
    assertFalse(h.hasHiddenColumns());
  }

  @Test(groups = "Functional")
  public void testHasManyHiddenColumns()
  {
    HiddenColumns h = new HiddenColumns();

    // new HiddenColumns2 has no hidden cols
    assertFalse(h.hasManyHiddenColumns());

    // one set of columns hidden, returns false
    h.hideColumns(5, 10);
    assertFalse(h.hasManyHiddenColumns());

    // two sets hidden, returns true
    h.hideColumns(15, 17);
    assertTrue(h.hasManyHiddenColumns());

    // back to one block, asserts false
    h.hideColumns(11, 14);
    assertFalse(h.hasManyHiddenColumns());
  }

  @Test(groups = "Functional")
  public void testAdjustForHiddenColumns()
  {
    HiddenColumns h = new HiddenColumns();
    // returns input value when there are no hidden columns
    assertEquals(10, h.adjustForHiddenColumns(10));

    h.hideColumns(20, 30);
    assertEquals(10, h.adjustForHiddenColumns(10));
    assertEquals(20 + 11, h.adjustForHiddenColumns(20));
    assertEquals(35 + 11, h.adjustForHiddenColumns(35));

    h.hideColumns(5, 7);
    assertEquals(10 + 3, h.adjustForHiddenColumns(10));
    assertEquals(20 + 14, h.adjustForHiddenColumns(20));
    assertEquals(35 + 14, h.adjustForHiddenColumns(35));

    ColumnSelection sel = new ColumnSelection();
    h.revealAllHiddenColumns(sel);
    h.hideColumns(0, 1);
    assertEquals(4, h.adjustForHiddenColumns(2));
  }

  @Test(groups = "Functional")
  public void testGetHiddenBoundaryLeft()
  {
    HiddenColumns h = new HiddenColumns();

    // returns same value if no hidden cols
    assertEquals(3, h.getHiddenBoundaryLeft(3));

    h.hideColumns(5, 10);
    assertEquals(10, h.getHiddenBoundaryLeft(15));
    assertEquals(3, h.getHiddenBoundaryLeft(3));
    assertEquals(7, h.getHiddenBoundaryLeft(7));

    h.hideColumns(15, 20);
    assertEquals(10, h.getHiddenBoundaryLeft(15));
    assertEquals(20, h.getHiddenBoundaryLeft(21));
  }

  @Test(groups = "Functional")
  public void testGetHiddenBoundaryRight()
  {
    HiddenColumns h = new HiddenColumns();

    // returns same value if no hidden cols
    assertEquals(3, h.getHiddenBoundaryRight(3));

    h.hideColumns(5, 10);
    assertEquals(5, h.getHiddenBoundaryRight(3));
    assertEquals(15, h.getHiddenBoundaryRight(15));
    assertEquals(7, h.getHiddenBoundaryRight(7));

    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")
  public void testIterator()
  {
    HiddenColumns h = new HiddenColumns();
    Iterator<int[]> result = h.iterator();
    assertFalse(result.hasNext());

    h.hideColumns(5, 10);
    result = h.iterator();
    int[] next = result.next();
    assertEquals(5, next[0]);
    assertEquals(10, next[1]);
    assertFalse(result.hasNext());

    h.hideColumns(22, 23);
    result = h.iterator();
    next = result.next();
    assertEquals(5, next[0]);
    assertEquals(10, next[1]);
    next = result.next();
    assertEquals(22, next[0]);
    assertEquals(23, next[1]);
    assertFalse(result.hasNext());

    // test for only one hidden region at start of alignment
    ColumnSelection sel = new ColumnSelection();
    h.revealAllHiddenColumns(sel);
    h.hideColumns(0, 1);
    result = h.iterator();
    next = result.next();
    assertEquals(0, next[0]);
    assertEquals(1, next[1]);
    assertFalse(result.hasNext());
  }

  @Test(groups = "Functional")
  public void testGetVisibleSequenceStrings()
  {
    HiddenColumns h = new HiddenColumns();
    SequenceI seq1 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT");
    SequenceI seq2 = new Sequence("TEST2", "VICYHRNDTGA");
    SequenceI[] seqs = new SequenceI[2];
    seqs[0] = seq1;
    seqs[1] = seq2;
    String[] result = h.getVisibleSequenceStrings(5, 10, seqs);
    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);
    h.hideColumns(1, 3);
    h.hideColumns(6, 11);
    assertEquals("-D",
            h.getVisibleSequenceStrings(0, 5, new SequenceI[]
    { seq })[0]);
  }

  @Test(groups = "Functional")
  public void testHideInsertionsFor()
  {
    HiddenColumns h = new HiddenColumns();
    HiddenColumns h2 = new HiddenColumns();
    SequenceI seq1 = new Sequence("TEST1", "GAL---MFW-KQESPVICY--HRNDT");
    SequenceI seq2 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT");

    h.hideInsertionsFor(seq2);
    assertTrue(h.equals(h2));

    h.hideInsertionsFor(seq1);
    h2.hideColumns(3, 5);
    h2.hideColumns(9, 9);
    h2.hideColumns(19, 20);
    assertTrue(h.equals(h2));
  }

  @Test(groups = "Functional")
  public void testHideMarkedBits()
  {
    HiddenColumns h = new HiddenColumns();
    HiddenColumns h2 = new HiddenColumns();

    BitSet tohide = new BitSet(21);
    h.hideMarkedBits(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);

    h2.hideColumns(3, 5);
    h2.hideColumns(9, 9);
    h2.hideColumns(19, 20);
    assertTrue(h.equals(h2));
  }

  @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);

    // 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);
    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);

    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")
  public void testSubtractVisibleColumns()
  {
    HiddenColumns h = new HiddenColumns();
    int result = h.subtractVisibleColumns(1, 10);
    assertEquals(9, result);

    h.hideColumns(7, 9);
    result = h.subtractVisibleColumns(4, 10);
    assertEquals(3, result);

    h.hideColumns(14, 15);
    result = h.subtractVisibleColumns(4, 10);
    assertEquals(3, result);

    result = h.subtractVisibleColumns(10, 17);
    assertEquals(2, result);

    result = h.subtractVisibleColumns(1, 7);
    assertEquals(5, result);

    result = h.subtractVisibleColumns(1, 8);
    assertEquals(5, result);

    result = h.subtractVisibleColumns(3, 15);
    assertEquals(10, result);

    ColumnSelection sel = new ColumnSelection();
    h.revealAllHiddenColumns(sel);
    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<int[]> it = h.getBoundedIterator(0, 10);

    // no hidden columns = nothing to iterate over
    assertFalse(it.hasNext());

    // [start,end] contains all hidden columns
    // all regions are returned
    h.hideColumns(3, 10);
    h.hideColumns(14, 16);
    it = h.getBoundedIterator(0, 20);
    assertTrue(it.hasNext());
    int[] next = it.next();
    assertEquals(3, next[0]);
    assertEquals(10, next[1]);
    next = it.next();
    assertEquals(14, next[0]);
    assertEquals(16, next[1]);
    assertFalse(it.hasNext());

    // [start,end] overlaps a region
    // 1 region returned
    it = h.getBoundedIterator(5, 7);
    assertTrue(it.hasNext());
    next = it.next();
    assertEquals(3, next[0]);
    assertEquals(10, next[1]);
    assertFalse(it.hasNext());

    // [start,end] fully contains 1 region and start of last
    // - 2 regions returned
    it = h.getBoundedIterator(3, 15);
    assertTrue(it.hasNext());
    next = it.next();
    assertEquals(3, next[0]);
    assertEquals(10, next[1]);
    next = it.next();
    assertEquals(14, next[0]);
    assertEquals(16, next[1]);
    assertFalse(it.hasNext());

    // [start,end] contains end of first region and whole of last region
    // - 2 regions returned
    it = h.getBoundedIterator(4, 20);
    assertTrue(it.hasNext());
    next = it.next();
    assertEquals(3, next[0]);
    assertEquals(10, next[1]);
    next = it.next();
    assertEquals(14, next[0]);
    assertEquals(16, next[1]);
    assertFalse(it.hasNext());
  }

  @Test(groups = "Functional")
  public void testBoundedStartIterator()
  {
    HiddenColumns h = new HiddenColumns();
    Iterator<Integer> it = h.getBoundedStartIterator(0, 10);

    // no hidden columns = nothing to iterate over
    assertFalse(it.hasNext());

    // [start,end] contains all hidden columns
    // all regions are returned
    h.hideColumns(3, 10);
    h.hideColumns(14, 16);
    it = h.getBoundedStartIterator(0, 20);
    assertTrue(it.hasNext());
    int next = it.next();
    assertEquals(3, next);
    next = it.next();
    assertEquals(6, next);
    assertFalse(it.hasNext());

    // [start,end] does not contain a start of a region
    // no regions to iterate over
    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);
    assertTrue(it.hasNext());
    next = it.next();
    assertEquals(3, next);
    next = it.next();
    assertEquals(6, next);
    assertFalse(it.hasNext());

    // [start,end] contains whole of last region
    // - 1 region returned
    it = h.getBoundedStartIterator(4, 20);
    assertTrue(it.hasNext());
    next = it.next();
    assertEquals(6, next);
    assertFalse(it.hasNext());
  }

  @Test(groups = "Functional")
  public void testVisibleBlocksVisBoundsIterator()
  {
    HiddenColumns h = new HiddenColumns();
    Iterator<int[]> 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);
    regions = h.getVisContigsIterator(0, 31, true);

    assertTrue(regions.hasNext());
    region = regions.next();
    assertEquals(6, region[0]);
    assertEquals(36, region[1]);
    assertFalse(regions.hasNext());

    // single hidden region at right
    h = new HiddenColumns();
    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(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(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(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<Integer> 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());
  }
}