test/jalview/datamodel/HiddenColumnsTest.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.datamodel;
  22
  23 import static org.testng.Assert.assertNull;
  24 import static org.testng.AssertJUnit.assertEquals;
  25 import static org.testng.AssertJUnit.assertFalse;
  26 import static org.testng.AssertJUnit.assertTrue;
  27
  28 import jalview.analysis.AlignmentGenerator;
  29 import jalview.gui.JvOptionPane;
  30
  31 import java.util.Arrays;
  32 import java.util.BitSet;
  33 import java.util.List;
  34 import java.util.Random;
  35
  36 import org.testng.annotations.BeforeClass;
  37 import org.testng.annotations.Test;
  38
  39 public class HiddenColumnsTest
  40 {
  41
  42   @BeforeClass(alwaysRun = true)
  43   public void setUpJvOptionPane()
  44   {
  45     JvOptionPane.setInteractiveMode(false);
  46     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  47   }
  48
  49   /**
  50    * Test the method which counts the number of hidden columns
  51    */
  52   @Test(groups = { "Functional" })
  53   public void testGetSize()
  54   {
  55     HiddenColumns hidden = new HiddenColumns();
  56     assertEquals(0, hidden.getSize());
  57
  58     hidden.hideColumns(3, 5);
  59     assertEquals(3, hidden.getSize());
  60
  61     hidden.hideColumns(8, 8);
  62     assertEquals(4, hidden.getSize());
  63
  64     hidden.hideColumns(9, 14);
  65     assertEquals(10, hidden.getSize());
  66
  67     ColumnSelection cs = new ColumnSelection();
  68     hidden.revealAllHiddenColumns(cs);
  69     assertEquals(0, hidden.getSize());
  70   }
  71
  72   /**
  73    * Test the method that finds the visible column position of an alignment
  74    * column, allowing for hidden columns.
  75    */
  76   @Test(groups = { "Functional" })
  77   public void testFindColumnPosition()
  78   {
  79     HiddenColumns cs = new HiddenColumns();
  80     assertEquals(5, cs.findColumnPosition(5));
  81
  82     // hiding column 6 makes no difference
  83     cs.hideColumns(6, 6);
  84     assertEquals(5, cs.findColumnPosition(5));
  85
  86     // hiding column 4 moves column 5 to column 4
  87     cs.hideColumns(4, 4);
  88     assertEquals(4, cs.findColumnPosition(5));
  89
  90     // hiding column 4 moves column 4 to position 3
  91     assertEquals(3, cs.findColumnPosition(4));
  92
  93     // hiding columns 1 and 2 moves column 5 to column 2
  94     cs.hideColumns(1, 2);
  95     assertEquals(2, cs.findColumnPosition(5));
  96
  97     // check with > 1 hidden column regions
  98     // where some columns are in the hidden regions
  99     HiddenColumns cs2 = new HiddenColumns();
 100     cs2.hideColumns(5, 10);
 101     cs2.hideColumns(20, 27);
 102     cs2.hideColumns(40, 44);
 103
 104     // hiding columns 5-10 and 20-27 moves column 8 to column 4
 105     assertEquals(4, cs2.findColumnPosition(8));
 106
 107     // and moves column 24 to 13
 108     assertEquals(13, cs2.findColumnPosition(24));
 109
 110     // and moves column 28 to 14
 111     assertEquals(14, cs2.findColumnPosition(28));
 112
 113     // and moves column 40 to 25
 114     assertEquals(25, cs2.findColumnPosition(40));
 115
 116     // check when hidden columns start at 0 that the visible column
 117     // is returned as 0
 118     HiddenColumns cs3 = new HiddenColumns();
 119     cs3.hideColumns(0, 4);
 120     assertEquals(0, cs3.findColumnPosition(2));
 121
 122   }
 123
 124   /**
 125    * Test the method that finds the visible column position a given distance
 126    * before another column
 127    */
 128   @Test(groups = { "Functional" })
 129   public void testFindColumnNToLeft()
 130   {
 131     HiddenColumns cs = new HiddenColumns();
 132
 133     // test that without hidden columns, findColumnNToLeft returns
 134     // position n to left of provided position
 135     int pos = cs.subtractVisibleColumns(3, 10);
 136     assertEquals(7, pos);
 137
 138     // 0 returns same position
 139     pos = cs.subtractVisibleColumns(0, 10);
 140     assertEquals(10, pos);
 141
 142     // overflow to left returns negative number
 143     pos = cs.subtractVisibleColumns(3, 0);
 144     assertEquals(-3, pos);
 145
 146     // test that with hidden columns to left of result column
 147     // behaviour is the same as above
 148     cs.hideColumns(1, 3);
 149
 150     // position n to left of provided position
 151     pos = cs.subtractVisibleColumns(3, 10);
 152     assertEquals(7, pos);
 153
 154     // 0 returns same position
 155     pos = cs.subtractVisibleColumns(0, 10);
 156     assertEquals(10, pos);
 157
 158     // test with one set of hidden columns between start and required position
 159     cs.hideColumns(12, 15);
 160     pos = cs.subtractVisibleColumns(8, 17);
 161     assertEquals(5, pos);
 162
 163     // test with two sets of hidden columns between start and required position
 164     cs.hideColumns(20, 21);
 165     pos = cs.subtractVisibleColumns(8, 23);
 166     assertEquals(9, pos);
 167
 168     // repeat last 2 tests with no hidden columns to left of required position
 169     ColumnSelection colsel = new ColumnSelection();
 170     cs.revealAllHiddenColumns(colsel);
 171
 172     // test with one set of hidden columns between start and required position
 173     cs.hideColumns(12, 15);
 174     pos = cs.subtractVisibleColumns(8, 17);
 175     assertEquals(5, pos);
 176
 177     // test with two sets of hidden columns between start and required position
 178     cs.hideColumns(20, 21);
 179     pos = cs.subtractVisibleColumns(8, 23);
 180     assertEquals(9, pos);
 181
 182   }
 183
 184   @Test(groups = { "Functional" })
 185   public void testGetVisibleContigs()
 186   {
 187     HiddenColumns cs = new HiddenColumns();
 188     cs.hideColumns(3, 6);
 189     cs.hideColumns(8, 9);
 190     cs.hideColumns(12, 12);
 191
 192     // start position is inclusive, end position exclusive:
 193     int[] visible = cs.getVisibleContigs(1, 13);
 194     assertEquals("[1, 2, 7, 7, 10, 11]", Arrays.toString(visible));
 195
 196     visible = cs.getVisibleContigs(4, 14);
 197     assertEquals("[7, 7, 10, 11, 13, 13]", Arrays.toString(visible));
 198
 199     visible = cs.getVisibleContigs(3, 10);
 200     assertEquals("[7, 7]", Arrays.toString(visible));
 201
 202     visible = cs.getVisibleContigs(4, 6);
 203     assertEquals("[]", Arrays.toString(visible));
 204   }
 205
 206   @Test(groups = { "Functional" })
 207   public void testEquals()
 208   {
 209     HiddenColumns cs = new HiddenColumns();
 210     cs.hideColumns(5, 9);
 211
 212     // a different set of hidden columns
 213     HiddenColumns cs2 = new HiddenColumns();
 214
 215     // with no hidden columns
 216     assertFalse(cs.equals(cs2));
 217     assertFalse(cs2.equals(cs));
 218
 219     // with hidden columns added in a different order
 220     cs2.hideColumns(6, 9);
 221     cs2.hideColumns(5, 8);
 222
 223     assertTrue(cs.equals(cs2));
 224     assertTrue(cs.equals(cs));
 225     assertTrue(cs2.equals(cs));
 226     assertTrue(cs2.equals(cs2));
 227   }
 228
 229   @Test(groups = "Functional")
 230   public void testCopyConstructor()
 231   {
 232     HiddenColumns cs = new HiddenColumns();
 233     cs.hideColumns(10, 11);
 234     cs.hideColumns(5, 7);
 235     assertEquals("[5, 7]",
 236             Arrays.toString(cs.getHiddenColumnsCopyAsList().get(0)));
 237
 238     HiddenColumns cs2 = new HiddenColumns(cs);
 239     assertTrue(cs2.hasHiddenColumns());
 240     assertEquals(2, cs2.getHiddenColumnsCopyAsList().size());
 241     // hidden columns are held in column order
 242     assertEquals("[5, 7]",
 243             Arrays.toString(cs2.getHiddenColumnsCopyAsList().get(0)));
 244     assertEquals("[10, 11]",
 245             Arrays.toString(cs2.getHiddenColumnsCopyAsList().get(1)));
 246   }
 247
 248   /**
 249    * Test the code used to locate the reference sequence ruler origin
 250    */
 251   @Test(groups = { "Functional" })
 252   public void testLocateVisibleBoundsofSequence()
 253   {
 254     // create random alignment
 255     AlignmentGenerator gen = new AlignmentGenerator(false);
 256     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 257
 258     HiddenColumns cs = al.getHiddenColumns();
 259     ColumnSelection colsel = new ColumnSelection();
 260
 261     SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
 262     assertEquals(2, seq.findIndex(seq.getStart()));
 263
 264     // no hidden columns
 265     assertEquals(
 266             Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
 267                 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
 268                 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
 269                 seq.findIndex(seq.getEnd()) - 1 }),
 270             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 271
 272     // hidden column on gap after end of sequence - should not affect bounds
 273     colsel.hideSelectedColumns(13, al.getHiddenColumns());
 274     assertEquals(
 275             Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
 276                 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
 277                 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
 278                 seq.findIndex(seq.getEnd()) - 1 }),
 279             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 280
 281     cs.revealAllHiddenColumns(colsel);
 282     // hidden column on gap before beginning of sequence - should vis bounds by
 283     // one
 284     colsel.hideSelectedColumns(0, al.getHiddenColumns());
 285     assertEquals(
 286             Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 2,
 287                 seq.findIndex(seq.getEnd()) - 2, seq.getStart(),
 288                 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
 289                 seq.findIndex(seq.getEnd()) - 1 }),
 290             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 291
 292     cs.revealAllHiddenColumns(colsel);
 293     // hide columns around most of sequence - leave one residue remaining
 294     cs.hideColumns(1, 3);
 295     cs.hideColumns(6, 11);
 296     assertEquals("-D",
 297             cs.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]);
 298     assertEquals(
 299             Arrays.toString(new int[] { 1, 1, 3, 3,
 300                 seq.findIndex(seq.getStart()) - 1,
 301                 seq.findIndex(seq.getEnd()) - 1 }),
 302             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 303     cs.revealAllHiddenColumns(colsel);
 304
 305     // hide whole sequence - should just get location of hidden region
 306     // containing sequence
 307     cs.hideColumns(1, 11);
 308     assertEquals(
 309             Arrays.toString(new int[] { 0, 1, 0, 0,
 310                 seq.findIndex(seq.getStart()) - 1,
 311                 seq.findIndex(seq.getEnd()) - 1 }),
 312             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 313
 314   }
 315
 316   @Test(groups = { "Functional" })
 317   public void testLocateVisibleBoundsPathologicals()
 318   {
 319     // test some pathological cases we missed
 320     AlignmentI al = new Alignment(new SequenceI[] { new Sequence(
 321             "refseqGaptest", "KTDVTI----------NFI-----G----L") });
 322     HiddenColumns cs = new HiddenColumns();
 323     cs.hideInsertionsFor(al.getSequenceAt(0));
 324     assertEquals(
 325             "G",
 326             ""
 327                     + al.getSequenceAt(0).getCharAt(
 328                             cs.adjustForHiddenColumns(9)));
 329
 330   }
 331
 332   @Test(groups = { "Functional" })
 333   public void testHideColumns()
 334   {
 335     // create random alignment
 336     AlignmentGenerator gen = new AlignmentGenerator(false);
 337     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 338
 339     ColumnSelection colsel = new ColumnSelection();
 340     HiddenColumns cs = al.getHiddenColumns();
 341     colsel.hideSelectedColumns(5, al.getHiddenColumns());
 342     List<int[]> hidden = cs.getHiddenColumnsCopyAsList();
 343     assertEquals(1, hidden.size());
 344     assertEquals("[5, 5]", Arrays.toString(hidden.get(0)));
 345
 346     colsel.hideSelectedColumns(3, al.getHiddenColumns());
 347     hidden = cs.getHiddenColumnsCopyAsList();
 348     assertEquals(2, hidden.size());
 349     // two hidden ranges, in order:
 350     assertEquals(hidden.size(), cs.getHiddenColumnsCopyAsList().size());
 351     assertEquals("[3, 3]", Arrays.toString(hidden.get(0)));
 352     assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
 353
 354     // hiding column 4 expands [3, 3] to [3, 4]
 355     // and merges to [5, 5] to make [3, 5]
 356     colsel.hideSelectedColumns(4, al.getHiddenColumns());
 357     hidden = cs.getHiddenColumnsCopyAsList();
 358     assertEquals(1, hidden.size());
 359     assertEquals("[3, 5]", Arrays.toString(hidden.get(0)));
 360
 361     // clear hidden columns (note they are added to selected)
 362     cs.revealAllHiddenColumns(colsel);
 363     // it is now actually null but getter returns an empty list
 364     assertTrue(cs.getHiddenColumnsCopyAsList().isEmpty());
 365
 366     cs.hideColumns(3, 6);
 367     hidden = cs.getHiddenColumnsCopyAsList();
 368     int[] firstHiddenRange = hidden.get(0);
 369     assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
 370
 371     // adding a subrange of already hidden should do nothing
 372     cs.hideColumns(4, 5);
 373     hidden = cs.getHiddenColumnsCopyAsList();
 374     assertEquals(1, hidden.size());
 375     assertEquals("[3, 6]",
 376             Arrays.toString(cs.getHiddenColumnsCopyAsList().get(0)));
 377     cs.hideColumns(3, 5);
 378     hidden = cs.getHiddenColumnsCopyAsList();
 379     assertEquals(1, hidden.size());
 380     assertEquals("[3, 6]",
 381             Arrays.toString(cs.getHiddenColumnsCopyAsList().get(0)));
 382     cs.hideColumns(4, 6);
 383     hidden = cs.getHiddenColumnsCopyAsList();
 384     assertEquals(1, hidden.size());
 385     assertEquals("[3, 6]",
 386             Arrays.toString(cs.getHiddenColumnsCopyAsList().get(0)));
 387     cs.hideColumns(3, 6);
 388     hidden = cs.getHiddenColumnsCopyAsList();
 389     assertEquals(1, hidden.size());
 390     assertEquals("[3, 6]",
 391             Arrays.toString(cs.getHiddenColumnsCopyAsList().get(0)));
 392
 393     cs.revealAllHiddenColumns(colsel);
 394     cs.hideColumns(2, 4);
 395     hidden = cs.getHiddenColumnsCopyAsList();
 396     assertEquals(1, hidden.size());
 397     assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
 398
 399     // extend contiguous with 2 positions overlap
 400     cs.hideColumns(3, 5);
 401     hidden = cs.getHiddenColumnsCopyAsList();
 402     assertEquals(1, hidden.size());
 403     assertEquals("[2, 5]", Arrays.toString(hidden.get(0)));
 404
 405     // extend contiguous with 1 position overlap
 406     cs.hideColumns(5, 6);
 407     hidden = cs.getHiddenColumnsCopyAsList();
 408     assertEquals(1, hidden.size());
 409     assertEquals("[2, 6]", Arrays.toString(hidden.get(0)));
 410
 411     // extend contiguous with overlap both ends:
 412     cs.hideColumns(1, 7);
 413     hidden = cs.getHiddenColumnsCopyAsList();
 414     assertEquals(1, hidden.size());
 415     assertEquals("[1, 7]", Arrays.toString(hidden.get(0)));
 416   }
 417
 418   /**
 419    * Test the method that reveals a range of hidden columns given the start
 420    * column of the range
 421    */
 422   @Test(groups = { "Functional" })
 423   public void testRevealHiddenColumns()
 424   {
 425     ColumnSelection colsel = new ColumnSelection();
 426     HiddenColumns cs = new HiddenColumns();
 427     cs.hideColumns(5, 8);
 428     colsel.addElement(10);
 429     cs.revealHiddenColumns(5, colsel);
 430     // hidden columns list now null but getter returns empty list:
 431     assertTrue(cs.getHiddenColumnsCopyAsList().isEmpty());
 432     // revealed columns are marked as selected (added to selection):
 433     assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString());
 434
 435     // calling with a column other than the range start does nothing:
 436     colsel = new ColumnSelection();
 437     cs = new HiddenColumns();
 438     cs.hideColumns(5, 8);
 439     List<int[]> hidden = cs.getHiddenColumnsCopyAsList();
 440     cs.revealHiddenColumns(6, colsel);
 441     assertEquals(hidden.size(), cs.getHiddenColumnsCopyAsList().size());
 442     assertTrue(colsel.getSelected().isEmpty());
 443   }
 444
 445   @Test(groups = { "Functional" })
 446   public void testRevealAllHiddenColumns()
 447   {
 448     HiddenColumns cs = new HiddenColumns();
 449     ColumnSelection colsel = new ColumnSelection();
 450     cs.hideColumns(5, 8);
 451     cs.hideColumns(2, 3);
 452     colsel.addElement(11);
 453     colsel.addElement(1);
 454     cs.revealAllHiddenColumns(colsel);
 455
 456     /*
 457      * revealing hidden columns adds them (in order) to the (unordered)
 458      * selection list
 459      */
 460     assertTrue(cs.getHiddenColumnsCopyAsList().isEmpty());
 461     assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", colsel.getSelected()
 462             .toString());
 463   }
 464
 465   @Test(groups = { "Functional" })
 466   public void testIsVisible()
 467   {
 468     HiddenColumns cs = new HiddenColumns();
 469     cs.hideColumns(2, 4);
 470     cs.hideColumns(6, 7);
 471     assertTrue(cs.isVisible(0));
 472     assertTrue(cs.isVisible(-99));
 473     assertTrue(cs.isVisible(1));
 474     assertFalse(cs.isVisible(2));
 475     assertFalse(cs.isVisible(3));
 476     assertFalse(cs.isVisible(4));
 477     assertTrue(cs.isVisible(5));
 478     assertFalse(cs.isVisible(6));
 479     assertFalse(cs.isVisible(7));
 480   }
 481
 482   /**
 483    * Test for the case when a hidden range encloses more one already hidden
 484    * range
 485    */
 486   @Test(groups = { "Functional" })
 487   public void testHideColumns_subsumingHidden()
 488   {
 489     /*
 490      * JAL-2370 bug scenario:
 491      * two hidden ranges subsumed by a third
 492      */
 493     HiddenColumns cs = new HiddenColumns();
 494     cs.hideColumns(49, 59);
 495     cs.hideColumns(69, 79);
 496     List<int[]> hidden = cs.getHiddenColumnsCopyAsList();
 497     assertEquals(2, hidden.size());
 498     assertEquals("[49, 59]", Arrays.toString(hidden.get(0)));
 499     assertEquals("[69, 79]", Arrays.toString(hidden.get(1)));
 500
 501     cs.hideColumns(48, 80);
 502     hidden = cs.getHiddenColumnsCopyAsList();
 503     assertEquals(1, hidden.size());
 504     assertEquals("[48, 80]", Arrays.toString(hidden.get(0)));
 505
 506     /*
 507      * another...joining hidden ranges
 508      */
 509     cs = new HiddenColumns();
 510     cs.hideColumns(10, 20);
 511     cs.hideColumns(30, 40);
 512     cs.hideColumns(50, 60);
 513     // hiding 21-49 should merge to one range
 514     cs.hideColumns(21, 49);
 515     hidden = cs.getHiddenColumnsCopyAsList();
 516     assertEquals(1, hidden.size());
 517     assertEquals("[10, 60]", Arrays.toString(hidden.get(0)));
 518
 519     /*
 520      * another...left overlap, subsumption, right overlap,
 521      * no overlap of existing hidden ranges
 522      */
 523     cs = new HiddenColumns();
 524     cs.hideColumns(10, 20);
 525     cs.hideColumns(10, 20);
 526     cs.hideColumns(30, 35);
 527     cs.hideColumns(40, 50);
 528     cs.hideColumns(60, 70);
 529
 530     cs.hideColumns(15, 45);
 531     hidden = cs.getHiddenColumnsCopyAsList();
 532     assertEquals(2, hidden.size());
 533     assertEquals("[10, 50]", Arrays.toString(hidden.get(0)));
 534     assertEquals("[60, 70]", Arrays.toString(hidden.get(1)));
 535   }
 536
 537   @Test(groups = { "Functional" })
 538   public void testHideBitset()
 539   {
 540     HiddenColumns cs;
 541
 542     BitSet one = new BitSet();
 543
 544     // one hidden range
 545     one.set(1);
 546     cs = new HiddenColumns();
 547     cs.hideMarkedBits(one);
 548     assertEquals(1, cs.getHiddenColumnsCopyAsList().size());
 549
 550     one.set(2);
 551     cs = new HiddenColumns();
 552     cs.hideMarkedBits(one);
 553     assertEquals(1, cs.getHiddenColumnsCopyAsList().size());
 554
 555     one.set(3);
 556     cs = new HiddenColumns();
 557     cs.hideMarkedBits(one);
 558     assertEquals(1, cs.getHiddenColumnsCopyAsList().size());
 559
 560     // split
 561     one.clear(2);
 562     cs = new HiddenColumns();
 563     cs.hideMarkedBits(one);
 564     assertEquals(2, cs.getHiddenColumnsCopyAsList().size());
 565
 566     assertEquals(0, cs.adjustForHiddenColumns(0));
 567     assertEquals(2, cs.adjustForHiddenColumns(1));
 568     assertEquals(4, cs.adjustForHiddenColumns(2));
 569
 570     // one again
 571     one.clear(1);
 572     cs = new HiddenColumns();
 573     cs.hideMarkedBits(one);
 574
 575     assertEquals(1, cs.getHiddenColumnsCopyAsList().size());
 576
 577     assertEquals(0, cs.adjustForHiddenColumns(0));
 578     assertEquals(1, cs.adjustForHiddenColumns(1));
 579     assertEquals(2, cs.adjustForHiddenColumns(2));
 580     assertEquals(4, cs.adjustForHiddenColumns(3));
 581   }
 582
 583   @Test(groups = { "Functional" })
 584   public void testGetBitset()
 585   {
 586     BitSet toMark, fromMark;
 587     long seed = -3241532;
 588     Random number = new Random(seed);
 589     for (int n = 0; n < 1000; n++)
 590     {
 591       // create a random bitfield
 592       toMark = BitSet.valueOf(new long[] { number.nextLong(),
 593           number.nextLong(), number.nextLong() });
 594       toMark.set(n * number.nextInt(10), n * (25 + number.nextInt(25)));
 595       HiddenColumns hc = new HiddenColumns();
 596       hc.hideMarkedBits(toMark);
 597
 598       // see if we can recover bitfield
 599       hc.markHiddenRegions(fromMark = new BitSet());
 600       assertEquals(toMark, fromMark);
 601     }
 602   }
 603
 604   @Test(groups = { "Functional" })
 605   public void testFindHiddenRegionPositions()
 606   {
 607     HiddenColumns hc = new HiddenColumns();
 608
 609     List<Integer> positions = hc.findHiddenRegionPositions();
 610     assertTrue(positions.isEmpty());
 611
 612     hc.hideColumns(3, 7);
 613     hc.hideColumns(10, 10);
 614     hc.hideColumns(14, 15);
 615
 616     positions = hc.findHiddenRegionPositions();
 617     assertEquals(3, positions.size());
 618     assertEquals(3, positions.get(0).intValue());
 619     assertEquals(5, positions.get(1).intValue());
 620     assertEquals(8, positions.get(2).intValue());
 621   }
 622
 623   @Test(groups = { "Functional" })
 624   public void testRegionsToString()
 625   {
 626     HiddenColumns hc = new HiddenColumns();
 627
 628     String result = hc.regionsToString(",", "--");
 629     assertEquals("", result);
 630
 631     hc.hideColumns(3, 7);
 632     hc.hideColumns(10, 10);
 633     hc.hideColumns(14, 15);
 634
 635     result = hc.regionsToString(",", "--");
 636     assertEquals("3--7,10--10,14--15", result);
 637   }
 638
 639   @Test(groups = "Functional")
 640   public void getVisibleStartAndEndIndexTest()
 641   {
 642     Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
 643     AlignmentI align = new Alignment(new SequenceI[] { seq });
 644     HiddenColumns hc = new HiddenColumns();
 645
 646     int[] startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 647     assertEquals(0, startEnd[0]);
 648     assertEquals(25, startEnd[1]);
 649
 650     hc.hideColumns(0, 0);
 651     startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 652     assertEquals(1, startEnd[0]);
 653     assertEquals(25, startEnd[1]);
 654
 655     hc.hideColumns(6, 9);
 656     hc.hideColumns(11, 12);
 657     startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 658     assertEquals(1, startEnd[0]);
 659     assertEquals(25, startEnd[1]);
 660
 661     hc.hideColumns(24, 25);
 662     startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 663     System.out.println(startEnd[0] + " : " + startEnd[1]);
 664     assertEquals(1, startEnd[0]);
 665     assertEquals(23, startEnd[1]);
 666   }
 667
 668   @Test(groups = "Functional")
 669   public void testGetRegionWithEdgeAtRes()
 670   {
 671     HiddenColumns hc = new HiddenColumns();
 672
 673     int[] result = hc.getRegionWithEdgeAtRes(5);
 674     assertNull(result);
 675
 676     hc.hideColumns(3, 7);
 677     hc.hideColumns(10, 10);
 678     hc.hideColumns(14, 15);
 679
 680     result = hc.getRegionWithEdgeAtRes(3);
 681     assertEquals(3, result[0]);
 682     assertEquals(7, result[1]);
 683
 684     result = hc.getRegionWithEdgeAtRes(5);
 685     assertEquals(10, result[0]);
 686     assertEquals(10, result[1]);
 687
 688     result = hc.getRegionWithEdgeAtRes(6);
 689     assertNull(result);
 690   }
 691
 692 }