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 import jalview.util.Comparison;
  31
  32 import java.util.Arrays;
  33 import java.util.BitSet;
  34 import java.util.Iterator;
  35 import java.util.Random;
  36
  37 import org.testng.annotations.BeforeClass;
  38 import org.testng.annotations.Test;
  39
  40 public class HiddenColumnsTest
  41 {
  42
  43   @BeforeClass(alwaysRun = true)
  44   public void setUpJvOptionPane()
  45   {
  46     JvOptionPane.setInteractiveMode(false);
  47     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  48   }
  49
  50   /**
  51    * Test the method which counts the number of hidden columns
  52    */
  53   @Test(groups = { "Functional" })
  54   public void testGetSize()
  55   {
  56     HiddenColumns hidden = new HiddenColumns();
  57     assertEquals(0, hidden.getSize());
  58
  59     hidden.hideColumns(3, 5);
  60     assertEquals(3, hidden.getSize());
  61
  62     hidden.hideColumns(8, 8);
  63     assertEquals(4, hidden.getSize());
  64
  65     hidden.hideColumns(9, 14);
  66     assertEquals(10, hidden.getSize());
  67
  68     ColumnSelection cs = new ColumnSelection();
  69     hidden.revealAllHiddenColumns(cs);
  70     assertEquals(0, hidden.getSize());
  71   }
  72
  73   /**
  74    * Test the method that finds the visible column position of an alignment
  75    * column, allowing for hidden columns.
  76    */
  77   @Test(groups = { "Functional" })
  78   public void testFindColumnPosition()
  79   {
  80     HiddenColumns cs = new HiddenColumns();
  81     assertEquals(5, cs.findColumnPosition(5));
  82
  83     // hiding column 6 makes no difference
  84     cs.hideColumns(6, 6);
  85     assertEquals(5, cs.findColumnPosition(5));
  86
  87     // hiding column 4 moves column 5 to column 4
  88     cs.hideColumns(4, 4);
  89     assertEquals(4, cs.findColumnPosition(5));
  90
  91     // hiding column 4 moves column 4 to position 3
  92     assertEquals(3, cs.findColumnPosition(4));
  93
  94     // hiding columns 1 and 2 moves column 5 to column 2
  95     cs.hideColumns(1, 2);
  96     assertEquals(2, cs.findColumnPosition(5));
  97
  98     // check with > 1 hidden column regions
  99     // where some columns are in the hidden regions
 100     HiddenColumns cs2 = new HiddenColumns();
 101     cs2.hideColumns(5, 10);
 102     cs2.hideColumns(20, 27);
 103     cs2.hideColumns(40, 44);
 104
 105     // hiding columns 5-10 and 20-27 moves column 8 to column 4
 106     assertEquals(4, cs2.findColumnPosition(8));
 107
 108     // and moves column 24 to 13
 109     assertEquals(13, cs2.findColumnPosition(24));
 110
 111     // and moves column 28 to 14
 112     assertEquals(14, cs2.findColumnPosition(28));
 113
 114     // and moves column 40 to 25
 115     assertEquals(25, cs2.findColumnPosition(40));
 116
 117     // check when hidden columns start at 0 that the visible column
 118     // is returned as 0
 119     HiddenColumns cs3 = new HiddenColumns();
 120     cs3.hideColumns(0, 4);
 121     assertEquals(0, cs3.findColumnPosition(2));
 122
 123   }
 124
 125   /**
 126    * Test the method that finds the visible column position a given distance
 127    * before another column
 128    */
 129   @Test(groups = { "Functional" })
 130   public void testFindColumnNToLeft()
 131   {
 132     HiddenColumns cs = new HiddenColumns();
 133
 134     // test that without hidden columns, findColumnNToLeft returns
 135     // position n to left of provided position
 136     long pos = cs.subtractVisibleColumns(3, 10);
 137     assertEquals(7, pos);
 138
 139     // 0 returns same position
 140     pos = cs.subtractVisibleColumns(0, 10);
 141     assertEquals(10, pos);
 142
 143     // overflow to left returns negative number
 144     pos = cs.subtractVisibleColumns(3, 0);
 145     assertEquals(-3, pos);
 146
 147     // test that with hidden columns to left of result column
 148     // behaviour is the same as above
 149     cs.hideColumns(1, 3);
 150
 151     // position n to left of provided position
 152     pos = cs.subtractVisibleColumns(3, 10);
 153     assertEquals(7, pos);
 154
 155     // 0 returns same position
 156     pos = cs.subtractVisibleColumns(0, 10);
 157     assertEquals(10, pos);
 158
 159     // test with one set of hidden columns between start and required position
 160     cs.hideColumns(12, 15);
 161     pos = cs.subtractVisibleColumns(8, 17);
 162     assertEquals(5, pos);
 163
 164     // test with two sets of hidden columns between start and required position
 165     cs.hideColumns(20, 21);
 166     pos = cs.subtractVisibleColumns(8, 23);
 167     assertEquals(9, pos);
 168
 169     // repeat last 2 tests with no hidden columns to left of required position
 170     ColumnSelection colsel = new ColumnSelection();
 171     cs.revealAllHiddenColumns(colsel);
 172
 173     // test with one set of hidden columns between start and required position
 174     cs.hideColumns(12, 15);
 175     pos = cs.subtractVisibleColumns(8, 17);
 176     assertEquals(5, pos);
 177
 178     // test with two sets of hidden columns between start and required position
 179     cs.hideColumns(20, 21);
 180     pos = cs.subtractVisibleColumns(8, 23);
 181     assertEquals(9, pos);
 182
 183   }
 184
 185   @Test(groups = { "Functional" })
 186   public void testVisibleContigsIterator()
 187   {
 188     HiddenColumns cs = new HiddenColumns();
 189
 190     Iterator<int[]> visible = cs.getVisContigsIterator(3, 10);
 191     int[] region = visible.next();
 192     assertEquals("[3, 9]", Arrays.toString(region));
 193     assertFalse(visible.hasNext());
 194
 195     cs.hideColumns(3, 6);
 196     cs.hideColumns(8, 9);
 197     cs.hideColumns(12, 12);
 198
 199     // Test both ends visible region
 200
 201     // start position is inclusive, end position exclusive
 202     visible = cs.getVisContigsIterator(1, 13);
 203     region = visible.next();
 204     assertEquals("[1, 2]", Arrays.toString(region));
 205     region = visible.next();
 206     assertEquals("[7, 7]", Arrays.toString(region));
 207     region = visible.next();
 208     assertEquals("[10, 11]", Arrays.toString(region));
 209     assertFalse(visible.hasNext());
 210
 211     // Test start hidden, end visible
 212     visible = cs.getVisContigsIterator(4, 14);
 213     region = visible.next();
 214     assertEquals("[7, 7]", Arrays.toString(region));
 215     region = visible.next();
 216     assertEquals("[10, 11]", Arrays.toString(region));
 217     region = visible.next();
 218     assertEquals("[13, 13]", Arrays.toString(region));
 219     assertFalse(visible.hasNext());
 220
 221     // Test start hidden, end hidden
 222     visible = cs.getVisContigsIterator(3, 10);
 223     region = visible.next();
 224     assertEquals("[7, 7]", Arrays.toString(region));
 225     assertFalse(visible.hasNext());
 226
 227     // Test start visible, end hidden
 228     visible = cs.getVisContigsIterator(0, 13);
 229     region = visible.next();
 230     assertEquals("[0, 2]", Arrays.toString(region));
 231     region = visible.next();
 232     assertEquals("[7, 7]", Arrays.toString(region));
 233     region = visible.next();
 234     assertEquals("[10, 11]", Arrays.toString(region));
 235     assertFalse(visible.hasNext());
 236
 237     // Test empty result
 238     visible = cs.getVisContigsIterator(4, 6);
 239     assertFalse(visible.hasNext());
 240   }
 241
 242   @Test(groups = { "Functional" })
 243   public void testEquals()
 244   {
 245     HiddenColumns cs = new HiddenColumns();
 246     cs.hideColumns(5, 9);
 247
 248     // a different set of hidden columns
 249     HiddenColumns cs2 = new HiddenColumns();
 250
 251     // with no hidden columns
 252     assertFalse(cs.equals(cs2));
 253     assertFalse(cs2.equals(cs));
 254
 255     // with hidden columns added in a different order
 256     cs2.hideColumns(6, 9);
 257     cs2.hideColumns(5, 8);
 258
 259     assertTrue(cs.equals(cs2));
 260     assertTrue(cs.equals(cs));
 261     assertTrue(cs2.equals(cs));
 262     assertTrue(cs2.equals(cs2));
 263   }
 264
 265   @Test(groups = "Functional")
 266   public void testCopyConstructor()
 267   {
 268     HiddenColumns cs = new HiddenColumns();
 269     cs.hideColumns(10, 11);
 270     cs.hideColumns(5, 7);
 271     Iterator<int[]> regions = cs.iterator();
 272     assertEquals("[5, 7]",
 273             Arrays.toString(regions.next()));
 274
 275     HiddenColumns cs2 = new HiddenColumns(cs);
 276     regions = cs2.iterator();
 277     assertTrue(cs2.hasHiddenColumns());
 278     assertEquals(2, cs2.getNumberOfRegions());
 279     // hidden columns are held in column order
 280     assertEquals("[5, 7]",
 281             Arrays.toString(regions.next()));
 282     assertEquals("[10, 11]",
 283             Arrays.toString(regions.next()));
 284   }
 285
 286   @Test(groups = "Functional")
 287   public void testCopyConstructor2()
 288   {
 289     HiddenColumns cs = new HiddenColumns();
 290     cs.hideColumns(10, 11);
 291     cs.hideColumns(5, 7);
 292
 293     HiddenColumns cs2 = new HiddenColumns(cs, 3, 9, 1);
 294     assertTrue(cs2.hasHiddenColumns());
 295     Iterator<int[]> regions = cs2.iterator();
 296
 297     // only [5,7] returned, offset by 1
 298     assertEquals("[4, 6]",
 299             Arrays.toString(regions.next()));
 300     assertEquals(3, cs2.getSize());
 301
 302     cs2 = new HiddenColumns(cs, 8, 15, 4);
 303     regions = cs2.iterator();
 304     assertTrue(cs2.hasHiddenColumns());
 305
 306     // only [10,11] returned, offset by 4
 307     assertEquals("[6, 7]",
 308             Arrays.toString(regions.next()));
 309     assertEquals(2, cs2.getSize());
 310
 311     cs2 = new HiddenColumns(cs, 6, 10, 4);
 312     assertFalse(cs2.hasHiddenColumns());
 313   }
 314
 315   /**
 316    * Test the code used to locate the reference sequence ruler origin
 317    */
 318   @Test(groups = { "Functional" })
 319   public void testLocateVisibleBoundsofSequence()
 320   {
 321     // create random alignment
 322     AlignmentGenerator gen = new AlignmentGenerator(false);
 323     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 324
 325     HiddenColumns cs = al.getHiddenColumns();
 326     ColumnSelection colsel = new ColumnSelection();
 327
 328     SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
 329     assertEquals(2, seq.findIndex(seq.getStart()));
 330
 331     // no hidden columns
 332     assertEquals(seq.findIndex(seq.getStart()) - 1, cs.locateVisibleStartOfSequence(seq));
 333
 334     // hidden column on gap after end of sequence - should not affect bounds
 335     colsel.hideSelectedColumns(13, al.getHiddenColumns());
 336     assertEquals(seq.findIndex(seq.getStart()) - 1,cs.locateVisibleStartOfSequence(seq));
 337
 338     cs.revealAllHiddenColumns(colsel);
 339     // hidden column on gap before beginning of sequence - should vis bounds by
 340     // one
 341     colsel.hideSelectedColumns(0, al.getHiddenColumns());
 342     assertEquals(seq.findIndex(seq.getStart()) - 2,cs.locateVisibleStartOfSequence(seq));
 343
 344     cs.revealAllHiddenColumns(colsel);
 345     // hide columns around most of sequence - leave one residue remaining
 346     cs.hideColumns(1, 3);
 347     cs.hideColumns(6, 11);
 348     assertEquals("-D",
 349             cs.getVisibleSequenceStrings(0, 5, new SequenceI[]
 350     { seq })[0]);
 351
 352     assertEquals(1, cs.locateVisibleStartOfSequence(seq));
 353     cs.revealAllHiddenColumns(colsel);
 354
 355     // hide whole sequence - should just get location of hidden region
 356     // containing sequence
 357     cs.hideColumns(1, 11);
 358     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 359
 360     cs.revealAllHiddenColumns(colsel);
 361     cs.hideColumns(0, 15);
 362     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 363
 364     SequenceI seq2 = new Sequence("RefSeq2", "-------A-SD-ASD--E---");
 365
 366     cs.revealAllHiddenColumns(colsel);
 367     cs.hideColumns(7, 17);
 368     assertEquals(0,cs.locateVisibleStartOfSequence(seq2));
 369
 370     cs.revealAllHiddenColumns(colsel);
 371     cs.hideColumns(3, 17);
 372     assertEquals(0,cs.locateVisibleStartOfSequence(seq2));
 373
 374     cs.revealAllHiddenColumns(colsel);
 375     cs.hideColumns(3, 19);
 376     assertEquals(0,cs.locateVisibleStartOfSequence(seq2));
 377
 378     cs.revealAllHiddenColumns(colsel);
 379     cs.hideColumns(0, 0);
 380     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 381
 382     cs.revealAllHiddenColumns(colsel);
 383     cs.hideColumns(0, 1);
 384     assertEquals(1,cs.locateVisibleStartOfSequence(seq));
 385
 386     cs.revealAllHiddenColumns(colsel);
 387     cs.hideColumns(0, 2);
 388     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 389
 390     cs.revealAllHiddenColumns(colsel);
 391     cs.hideColumns(1, 1);
 392     assertEquals(2,cs.locateVisibleStartOfSequence(seq));
 393
 394     cs.revealAllHiddenColumns(colsel);
 395     cs.hideColumns(1, 2);
 396     assertEquals(1,cs.locateVisibleStartOfSequence(seq));
 397
 398     cs.revealAllHiddenColumns(colsel);
 399     cs.hideColumns(1, 3);
 400     assertEquals(1,cs.locateVisibleStartOfSequence(seq));
 401
 402     cs.revealAllHiddenColumns(colsel);
 403     cs.hideColumns(0, 2);
 404     cs.hideColumns(5, 6);
 405     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 406
 407     cs.revealAllHiddenColumns(colsel);
 408     cs.hideColumns(0, 2);
 409     cs.hideColumns(5, 6);
 410     cs.hideColumns(9, 10);
 411     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 412
 413     cs.revealAllHiddenColumns(colsel);
 414     cs.hideColumns(0, 2);
 415     cs.hideColumns(7, 11);
 416     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 417
 418     cs.revealAllHiddenColumns(colsel);
 419     cs.hideColumns(2, 4);
 420     cs.hideColumns(7, 11);
 421     assertEquals(1,cs.locateVisibleStartOfSequence(seq));
 422
 423     cs.revealAllHiddenColumns(colsel);
 424     cs.hideColumns(2, 4);
 425     cs.hideColumns(7, 12);
 426     assertEquals(1,cs.locateVisibleStartOfSequence(seq));
 427
 428     cs.revealAllHiddenColumns(colsel);
 429     cs.hideColumns(1, 11);
 430     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 431
 432     cs.revealAllHiddenColumns(colsel);
 433     cs.hideColumns(0, 12);
 434     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 435
 436     cs.revealAllHiddenColumns(colsel);
 437     cs.hideColumns(0, 4);
 438     cs.hideColumns(6, 12);
 439     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 440
 441     cs.revealAllHiddenColumns(colsel);
 442     cs.hideColumns(0, 1);
 443     cs.hideColumns(3, 12);
 444     assertEquals(0,cs.locateVisibleStartOfSequence(seq));
 445
 446     cs.revealAllHiddenColumns(colsel);
 447     cs.hideColumns(3, 14);
 448     cs.hideColumns(17, 19);
 449     assertEquals(3,cs.locateVisibleStartOfSequence(seq2));
 450
 451     cs.revealAllHiddenColumns(colsel);
 452     cs.hideColumns(3, 7);
 453     cs.hideColumns(9, 14);
 454     cs.hideColumns(17, 19);
 455     assertEquals(9,cs.locateVisibleStartOfSequence(seq2));
 456
 457     cs.revealAllHiddenColumns(colsel);
 458     cs.hideColumns(0, 1);
 459     cs.hideColumns(3, 4);
 460     cs.hideColumns(6, 8);
 461     cs.hideColumns(10, 12);
 462     assertEquals(6, cs.locateVisibleStartOfSequence(seq));
 463
 464   }
 465
 466   @Test(groups = { "Functional" })
 467   public void testLocateVisibleBoundsPathologicals()
 468   {
 469     // test some pathological cases we missed
 470     AlignmentI al = new Alignment(
 471             new SequenceI[]
 472     { new Sequence("refseqGaptest", "KTDVTI----------NFI-----G----L") });
 473     HiddenColumns cs = new HiddenColumns();
 474     cs.hideInsertionsFor(al.getSequenceAt(0));
 475     assertEquals("G", ""
 476             + al.getSequenceAt(0).getCharAt(cs.adjustForHiddenColumns(9)));
 477   }
 478
 479   @Test(groups = { "Functional" })
 480   public void testHideColumns()
 481   {
 482     // create random alignment
 483     AlignmentGenerator gen = new AlignmentGenerator(false);
 484     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 485
 486     ColumnSelection colsel = new ColumnSelection();
 487     HiddenColumns cs = al.getHiddenColumns();
 488     colsel.hideSelectedColumns(5, al.getHiddenColumns());
 489     Iterator<int[]> regions = cs.iterator();
 490     assertEquals(1, cs.getNumberOfRegions());
 491     assertEquals("[5, 5]", Arrays.toString(regions.next()));
 492
 493     colsel.hideSelectedColumns(3, al.getHiddenColumns());
 494     regions = cs.iterator();
 495     assertEquals(2, cs.getNumberOfRegions());
 496     // two hidden ranges, in order:
 497     assertEquals("[3, 3]", Arrays.toString(regions.next()));
 498     assertEquals("[5, 5]", Arrays.toString(regions.next()));
 499
 500     // hiding column 4 expands [3, 3] to [3, 4]
 501     // and merges to [5, 5] to make [3, 5]
 502     colsel.hideSelectedColumns(4, al.getHiddenColumns());
 503     regions = cs.iterator();
 504     assertEquals(1, cs.getNumberOfRegions());
 505     assertEquals("[3, 5]", Arrays.toString(regions.next()));
 506
 507     // clear hidden columns (note they are added to selected)
 508     cs.revealAllHiddenColumns(colsel);
 509     // it is now actually null but getter returns an empty list
 510     assertEquals(0, cs.getNumberOfRegions());
 511
 512     cs.hideColumns(3, 6);
 513     regions = cs.iterator();
 514     int[] firstHiddenRange = regions.next();
 515     assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
 516
 517     // adding a subrange of already hidden should do nothing
 518     cs.hideColumns(4, 5);
 519     regions = cs.iterator();
 520     assertEquals(1, cs.getNumberOfRegions());
 521     assertEquals("[3, 6]",
 522             Arrays.toString(regions.next()));
 523     cs.hideColumns(3, 5);
 524     regions = cs.iterator();
 525     assertEquals(1, cs.getNumberOfRegions());
 526     assertEquals("[3, 6]",
 527             Arrays.toString(regions.next()));
 528     cs.hideColumns(4, 6);
 529     regions = cs.iterator();
 530     assertEquals(1, cs.getNumberOfRegions());
 531     assertEquals("[3, 6]",
 532             Arrays.toString(regions.next()));
 533     cs.hideColumns(3, 6);
 534     regions = cs.iterator();
 535     assertEquals(1, cs.getNumberOfRegions());
 536     assertEquals("[3, 6]",
 537             Arrays.toString(regions.next()));
 538
 539     cs.revealAllHiddenColumns(colsel);
 540     cs.hideColumns(2, 4);
 541     regions = cs.iterator();
 542     assertEquals(1, cs.getNumberOfRegions());
 543     assertEquals("[2, 4]", Arrays.toString(regions.next()));
 544
 545     // extend contiguous with 2 positions overlap
 546     cs.hideColumns(3, 5);
 547     regions = cs.iterator();
 548     assertEquals(1, cs.getNumberOfRegions());
 549     assertEquals("[2, 5]", Arrays.toString(regions.next()));
 550
 551     // extend contiguous with 1 position overlap
 552     cs.hideColumns(5, 6);
 553     regions = cs.iterator();
 554     assertEquals(1, cs.getNumberOfRegions());
 555     assertEquals("[2, 6]", Arrays.toString(regions.next()));
 556
 557     // extend contiguous with overlap both ends:
 558     cs.hideColumns(1, 7);
 559     regions = cs.iterator();
 560     assertEquals(1, cs.getNumberOfRegions());
 561     assertEquals("[1, 7]", Arrays.toString(regions.next()));
 562   }
 563
 564   /**
 565    * Test the method that reveals a range of hidden columns given the start
 566    * column of the range
 567    */
 568   @Test(groups = { "Functional" })
 569   public void testRevealHiddenColumns()
 570   {
 571     ColumnSelection colsel = new ColumnSelection();
 572     HiddenColumns cs = new HiddenColumns();
 573     cs.hideColumns(5, 8);
 574     colsel.addElement(10);
 575     cs.revealHiddenColumns(5, colsel);
 576
 577     // hiddenColumns now empty
 578     assertEquals(0, cs.getSize());
 579
 580     // revealed columns are marked as selected (added to selection):
 581     assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString());
 582
 583     // calling with a column other than the range start does nothing:
 584     colsel = new ColumnSelection();
 585     cs = new HiddenColumns();
 586     cs.hideColumns(5, 8);
 587
 588     int prevSize = cs.getSize();
 589     cs.revealHiddenColumns(6, colsel);
 590     assertEquals(prevSize, cs.getSize());
 591     assertTrue(colsel.getSelected().isEmpty());
 592   }
 593
 594   @Test(groups = { "Functional" })
 595   public void testRevealAllHiddenColumns()
 596   {
 597     HiddenColumns hidden = new HiddenColumns();
 598     ColumnSelection colsel = new ColumnSelection();
 599     hidden.hideColumns(5, 8);
 600     hidden.hideColumns(2, 3);
 601     colsel.addElement(11);
 602     colsel.addElement(1);
 603     hidden.revealAllHiddenColumns(colsel);
 604
 605     /*
 606      * revealing hidden columns adds them (in order) to the (unordered)
 607      * selection list
 608      */
 609
 610     // hiddenColumns now empty
 611     assertEquals(0, hidden.getSize());
 612
 613     assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]",
 614             colsel.getSelected().toString());
 615   }
 616
 617   @Test(groups = { "Functional" })
 618   public void testIsVisible()
 619   {
 620     HiddenColumns cs = new HiddenColumns();
 621     cs.hideColumns(2, 4);
 622     cs.hideColumns(6, 7);
 623     assertTrue(cs.isVisible(0));
 624     assertTrue(cs.isVisible(-99));
 625     assertTrue(cs.isVisible(1));
 626     assertFalse(cs.isVisible(2));
 627     assertFalse(cs.isVisible(3));
 628     assertFalse(cs.isVisible(4));
 629     assertTrue(cs.isVisible(5));
 630     assertFalse(cs.isVisible(6));
 631     assertFalse(cs.isVisible(7));
 632   }
 633
 634   /**
 635    * Test for the case when a hidden range encloses more one already hidden
 636    * range
 637    */
 638   @Test(groups = { "Functional" })
 639   public void testHideColumns_subsumingHidden()
 640   {
 641     /*
 642      * JAL-2370 bug scenario:
 643      * two hidden ranges subsumed by a third
 644      */
 645     HiddenColumns cs = new HiddenColumns();
 646     cs.hideColumns(49, 59);
 647     cs.hideColumns(69, 79);
 648     Iterator<int[]> regions = cs.iterator();
 649     assertEquals(2, cs.getNumberOfRegions());
 650     assertEquals("[49, 59]", Arrays.toString(regions.next()));
 651     assertEquals("[69, 79]", Arrays.toString(regions.next()));
 652
 653     cs.hideColumns(48, 80);
 654     regions = cs.iterator();
 655     assertEquals(1, cs.getNumberOfRegions());
 656     assertEquals("[48, 80]", Arrays.toString(regions.next()));
 657
 658     /*
 659      * another...joining hidden ranges
 660      */
 661     cs = new HiddenColumns();
 662     cs.hideColumns(10, 20);
 663     cs.hideColumns(30, 40);
 664     cs.hideColumns(50, 60);
 665     // hiding 21-49 should merge to one range
 666     cs.hideColumns(21, 49);
 667     regions = cs.iterator();
 668     assertEquals(1, cs.getNumberOfRegions());
 669     assertEquals("[10, 60]", Arrays.toString(regions.next()));
 670
 671     /*
 672      * another...left overlap, subsumption, right overlap,
 673      * no overlap of existing hidden ranges
 674      */
 675     cs = new HiddenColumns();
 676     cs.hideColumns(10, 20);
 677     cs.hideColumns(10, 20);
 678     cs.hideColumns(30, 35);
 679     cs.hideColumns(40, 50);
 680     cs.hideColumns(60, 70);
 681
 682     cs.hideColumns(15, 45);
 683     regions = cs.iterator();
 684     assertEquals(2, cs.getNumberOfRegions());
 685     assertEquals("[10, 50]", Arrays.toString(regions.next()));
 686     assertEquals("[60, 70]", Arrays.toString(regions.next()));
 687   }
 688
 689   @Test(groups = { "Functional" })
 690   public void testHideBitset()
 691   {
 692     HiddenColumns cs;
 693
 694     BitSet one = new BitSet();
 695
 696     // one hidden range
 697     one.set(1);
 698     cs = new HiddenColumns();
 699     cs.hideMarkedBits(one);
 700     assertEquals(1, cs.getNumberOfRegions());
 701
 702     one.set(2);
 703     cs = new HiddenColumns();
 704     cs.hideMarkedBits(one);
 705     assertEquals(1, cs.getNumberOfRegions());
 706
 707     one.set(3);
 708     cs = new HiddenColumns();
 709     cs.hideMarkedBits(one);
 710     assertEquals(1, cs.getNumberOfRegions());
 711
 712     // split
 713     one.clear(2);
 714     cs = new HiddenColumns();
 715     cs.hideMarkedBits(one);
 716     assertEquals(2, cs.getNumberOfRegions());
 717
 718     assertEquals(0, cs.adjustForHiddenColumns(0));
 719     assertEquals(2, cs.adjustForHiddenColumns(1));
 720     assertEquals(4, cs.adjustForHiddenColumns(2));
 721
 722     // one again
 723     one.clear(1);
 724     cs = new HiddenColumns();
 725     cs.hideMarkedBits(one);
 726
 727     assertEquals(1, cs.getNumberOfRegions());
 728
 729     assertEquals(0, cs.adjustForHiddenColumns(0));
 730     assertEquals(1, cs.adjustForHiddenColumns(1));
 731     assertEquals(2, cs.adjustForHiddenColumns(2));
 732     assertEquals(4, cs.adjustForHiddenColumns(3));
 733   }
 734
 735   @Test(groups = { "Functional" })
 736   public void testMarkHiddenRegions()
 737   {
 738     BitSet toMark, fromMark;
 739     long seed = -3241532;
 740     Random number = new Random(seed);
 741     for (int n = 0; n < 1000; n++)
 742     {
 743       // create a random bitfield
 744       toMark = BitSet
 745               .valueOf(new long[]
 746       { number.nextLong(), number.nextLong(), number.nextLong() });
 747       toMark.set(n * number.nextInt(10), n * (25 + number.nextInt(25)));
 748       HiddenColumns hc = new HiddenColumns();
 749       hc.hideMarkedBits(toMark);
 750
 751       // see if we can recover bitfield
 752       hc.markHiddenRegions(fromMark = new BitSet());
 753       assertEquals(toMark, fromMark);
 754     }
 755   }
 756
 757   @Test(groups = { "Functional" })
 758   public void testRegionsToString()
 759   {
 760     HiddenColumns hc = new HiddenColumns();
 761
 762     String result = hc.regionsToString(",", "--");
 763     assertEquals("", result);
 764
 765     hc.hideColumns(3, 7);
 766     hc.hideColumns(10, 10);
 767     hc.hideColumns(14, 15);
 768
 769     result = hc.regionsToString(",", "--");
 770     assertEquals("3--7,10--10,14--15", result);
 771   }
 772
 773   @Test(groups = "Functional")
 774   public void testGetVisibleStartAndEndIndexTest()
 775   {
 776     Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
 777     AlignmentI align = new Alignment(new SequenceI[] { seq });
 778     HiddenColumns hc = new HiddenColumns();
 779
 780     int[] startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 781     assertEquals(0, startEnd[0]);
 782     assertEquals(25, startEnd[1]);
 783
 784     hc.hideColumns(0, 0);
 785     startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 786     assertEquals(1, startEnd[0]);
 787     assertEquals(25, startEnd[1]);
 788
 789     hc.hideColumns(6, 9);
 790     hc.hideColumns(11, 12);
 791     startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 792     assertEquals(1, startEnd[0]);
 793     assertEquals(25, startEnd[1]);
 794
 795     hc.hideColumns(24, 25);
 796     startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 797     System.out.println(startEnd[0] + " : " + startEnd[1]);
 798     assertEquals(1, startEnd[0]);
 799     assertEquals(23, startEnd[1]);
 800   }
 801
 802   @Test(groups = "Functional")
 803   public void testGetRegionWithEdgeAtRes()
 804   {
 805     HiddenColumns hc = new HiddenColumns();
 806
 807     int[] result = hc.getRegionWithEdgeAtRes(5);
 808     assertNull(result);
 809
 810     hc.hideColumns(3, 7);
 811     hc.hideColumns(10, 10);
 812     hc.hideColumns(14, 15);
 813
 814     result = hc.getRegionWithEdgeAtRes(2);
 815     assertEquals(3, result[0]);
 816     assertEquals(7, result[1]);
 817
 818     result = hc.getRegionWithEdgeAtRes(5);
 819     assertEquals(10, result[0]);
 820     assertEquals(10, result[1]);
 821
 822     result = hc.getRegionWithEdgeAtRes(6);
 823     assertNull(result);
 824
 825     result = hc.getRegionWithEdgeAtRes(0);
 826     assertNull(result);
 827
 828     result = hc.getRegionWithEdgeAtRes(7);
 829     assertEquals(14, result[0]);
 830     assertEquals(15, result[1]);
 831
 832     result = hc.getRegionWithEdgeAtRes(8);
 833     assertEquals(14, result[0]);
 834     assertEquals(15, result[1]);
 835   }
 836
 837   @Test(groups = "Functional")
 838   public void testPropagateInsertions()
 839   {
 840     // create an alignment with no gaps - this will be the profile seq and other
 841     // JPRED seqs
 842     AlignmentGenerator gen = new AlignmentGenerator(false);
 843     AlignmentI al = gen.generate(25, 10, 1234, 0, 0);
 844
 845     // get the profileseq
 846     SequenceI profileseq = al.getSequenceAt(0);
 847     SequenceI gappedseq = new Sequence(profileseq);
 848     gappedseq.insertCharAt(5, al.getGapCharacter());
 849     gappedseq.insertCharAt(6, al.getGapCharacter());
 850     gappedseq.insertCharAt(7, al.getGapCharacter());
 851     gappedseq.insertCharAt(8, al.getGapCharacter());
 852
 853     // create an alignment view with the gapped sequence
 854     SequenceI[] seqs = new SequenceI[1];
 855     seqs[0] = gappedseq;
 856     AlignmentI newal = new Alignment(seqs);
 857     HiddenColumns hidden = new HiddenColumns();
 858     hidden.hideColumns(15, 17);
 859
 860     AlignmentView view = new AlignmentView(newal, hidden, null, true, false,
 861             false);
 862
 863     // confirm that original contigs are as expected
 864     Iterator<int[]> visible = hidden.getVisContigsIterator(0, 25);
 865     int[] region = visible.next();
 866     assertEquals("[0, 14]", Arrays.toString(region));
 867     region = visible.next();
 868     assertEquals("[18, 24]", Arrays.toString(region));
 869
 870     // propagate insertions
 871     HiddenColumns result = HiddenColumns.propagateInsertions(profileseq, al,
 872             view);
 873
 874     // confirm that the contigs have changed to account for the gaps
 875     visible = result.getVisContigsIterator(0, 25);
 876     region = visible.next();
 877     assertEquals("[0, 10]", Arrays.toString(region));
 878     region = visible.next();
 879     assertEquals("[14, 24]", Arrays.toString(region));
 880
 881     // confirm the alignment has been changed so that the other sequences have
 882     // gaps inserted where the columns are hidden
 883     assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[10]));
 884     assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[11]));
 885     assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[12]));
 886     assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[13]));
 887     assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[14]));
 888
 889   }
 890
 891   @Test(groups = "Functional")
 892   public void testPropagateInsertionsOverlap()
 893   {
 894     // test propagateInsertions where gaps and hiddenColumns overlap
 895
 896     // create an alignment with no gaps - this will be the profile seq and other
 897     // JPRED seqs
 898     AlignmentGenerator gen = new AlignmentGenerator(false);
 899     AlignmentI al = gen.generate(20, 10, 1234, 0, 0);
 900
 901     // get the profileseq
 902     SequenceI profileseq = al.getSequenceAt(0);
 903     SequenceI gappedseq = new Sequence(profileseq);
 904     gappedseq.insertCharAt(5, al.getGapCharacter());
 905     gappedseq.insertCharAt(6, al.getGapCharacter());
 906     gappedseq.insertCharAt(7, al.getGapCharacter());
 907     gappedseq.insertCharAt(8, al.getGapCharacter());
 908
 909     // create an alignment view with the gapped sequence
 910     SequenceI[] seqs = new SequenceI[1];
 911     seqs[0] = gappedseq;
 912     AlignmentI newal = new Alignment(seqs);
 913
 914     // hide columns so that some overlap with the gaps
 915     HiddenColumns hidden = new HiddenColumns();
 916     hidden.hideColumns(7, 10);
 917
 918     AlignmentView view = new AlignmentView(newal, hidden, null, true, false,
 919             false);
 920
 921     // confirm that original contigs are as expected
 922     Iterator<int[]> visible = hidden.getVisContigsIterator(0, 20);
 923     int[] region = visible.next();
 924     assertEquals("[0, 6]", Arrays.toString(region));
 925     region = visible.next();
 926     assertEquals("[11, 19]", Arrays.toString(region));
 927     assertFalse(visible.hasNext());
 928
 929     // propagate insertions
 930     HiddenColumns result = HiddenColumns.propagateInsertions(profileseq, al,
 931             view);
 932
 933     // confirm that the contigs have changed to account for the gaps
 934     visible = result.getVisContigsIterator(0, 20);
 935     region = visible.next();
 936     assertEquals("[0, 4]", Arrays.toString(region));
 937     region = visible.next();
 938     assertEquals("[7, 19]", Arrays.toString(region));
 939     assertFalse(visible.hasNext());
 940
 941     // confirm the alignment has been changed so that the other sequences have
 942     // gaps inserted where the columns are hidden
 943     assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[4]));
 944     assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[5]));
 945     assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[6]));
 946     assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[7]));
 947   }
 948
 949   @Test(groups = "Functional")
 950   public void testHasHiddenColumns()
 951   {
 952     HiddenColumns h = new HiddenColumns();
 953
 954     // new HiddenColumns2 has no hidden cols
 955     assertFalse(h.hasHiddenColumns());
 956
 957     // some columns hidden, returns true
 958     h.hideColumns(5, 10);
 959     assertTrue(h.hasHiddenColumns());
 960
 961     // reveal columns, no hidden cols again
 962     ColumnSelection sel = new ColumnSelection();
 963     h.revealAllHiddenColumns(sel);
 964     assertFalse(h.hasHiddenColumns());
 965   }
 966
 967   @Test(groups = "Functional")
 968   public void testHasManyHiddenColumns()
 969   {
 970     HiddenColumns h = new HiddenColumns();
 971
 972     // new HiddenColumns2 has no hidden cols
 973     assertFalse(h.hasManyHiddenColumns());
 974
 975     // one set of columns hidden, returns false
 976     h.hideColumns(5, 10);
 977     assertFalse(h.hasManyHiddenColumns());
 978
 979     // two sets hidden, returns true
 980     h.hideColumns(15, 17);
 981     assertTrue(h.hasManyHiddenColumns());
 982
 983     // back to one block, asserts false
 984     h.hideColumns(11, 14);
 985     assertFalse(h.hasManyHiddenColumns());
 986   }
 987
 988   @Test(groups = "Functional")
 989   public void testAdjustForHiddenColumns()
 990   {
 991     HiddenColumns h = new HiddenColumns();
 992     // returns input value when there are no hidden columns
 993     assertEquals(10, h.adjustForHiddenColumns(10));
 994
 995     h.hideColumns(20, 30);
 996     assertEquals(10, h.adjustForHiddenColumns(10));
 997     assertEquals(20 + 11, h.adjustForHiddenColumns(20));
 998     assertEquals(35 + 11, h.adjustForHiddenColumns(35));
 999
1000     h.hideColumns(5, 7);
1001     assertEquals(10 + 3, h.adjustForHiddenColumns(10));
1002     assertEquals(20 + 14, h.adjustForHiddenColumns(20));
1003     assertEquals(35 + 14, h.adjustForHiddenColumns(35));
1004
1005     ColumnSelection sel = new ColumnSelection();
1006     h.revealAllHiddenColumns(sel);
1007     h.hideColumns(0, 1);
1008     assertEquals(4, h.adjustForHiddenColumns(2));
1009   }
1010
1011   @Test(groups = "Functional")
1012   public void testGetHiddenBoundaryLeft()
1013   {
1014     HiddenColumns h = new HiddenColumns();
1015
1016     // returns same value if no hidden cols
1017     assertEquals(3, h.getHiddenBoundaryLeft(3));
1018
1019     h.hideColumns(5, 10);
1020     assertEquals(10, h.getHiddenBoundaryLeft(15));
1021     assertEquals(3, h.getHiddenBoundaryLeft(3));
1022     assertEquals(7, h.getHiddenBoundaryLeft(7));
1023
1024     h.hideColumns(15, 20);
1025     assertEquals(10, h.getHiddenBoundaryLeft(15));
1026     assertEquals(20, h.getHiddenBoundaryLeft(21));
1027   }
1028
1029   @Test(groups = "Functional")
1030   public void testGetHiddenBoundaryRight()
1031   {
1032     HiddenColumns h = new HiddenColumns();
1033
1034     // returns same value if no hidden cols
1035     assertEquals(3, h.getHiddenBoundaryRight(3));
1036
1037     h.hideColumns(5, 10);
1038     assertEquals(5, h.getHiddenBoundaryRight(3));
1039     assertEquals(15, h.getHiddenBoundaryRight(15));
1040     assertEquals(7, h.getHiddenBoundaryRight(7));
1041
1042     h.hideColumns(15, 20);
1043     assertEquals(15, h.getHiddenBoundaryRight(7));
1044     assertEquals(15, h.getHiddenBoundaryRight(14));
1045   }
1046
1047   @Test(groups = "Functional")
1048   public void testIterator()
1049   {
1050     HiddenColumns h = new HiddenColumns();
1051     Iterator<int[]> result = h.iterator();
1052     assertFalse(result.hasNext());
1053
1054     h.hideColumns(5, 10);
1055     result = h.iterator();
1056     int[] next = result.next();
1057     assertEquals(5, next[0]);
1058     assertEquals(10, next[1]);
1059     assertFalse(result.hasNext());
1060
1061     h.hideColumns(22, 23);
1062     result = h.iterator();
1063     next = result.next();
1064     assertEquals(5, next[0]);
1065     assertEquals(10, next[1]);
1066     next = result.next();
1067     assertEquals(22, next[0]);
1068     assertEquals(23, next[1]);
1069     assertFalse(result.hasNext());
1070
1071     // test for only one hidden region at start of alignment
1072     ColumnSelection sel = new ColumnSelection();
1073     h.revealAllHiddenColumns(sel);
1074     h.hideColumns(0, 1);
1075     result = h.iterator();
1076     next = result.next();
1077     assertEquals(0, next[0]);
1078     assertEquals(1, next[1]);
1079     assertFalse(result.hasNext());
1080   }
1081
1082   @Test(groups = "Functional")
1083   public void testGetVisibleSequenceStrings()
1084   {
1085     HiddenColumns h = new HiddenColumns();
1086     SequenceI seq1 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT");
1087     SequenceI seq2 = new Sequence("TEST2", "VICYHRNDTGA");
1088     SequenceI[] seqs = new SequenceI[2];
1089     seqs[0] = seq1;
1090     seqs[1] = seq2;
1091     String[] result = h.getVisibleSequenceStrings(5, 10, seqs);
1092     assertEquals(2, result.length);
1093     assertEquals("WKQES", result[0]);
1094     assertEquals("RNDTG", result[1]);
1095
1096     h.hideColumns(6, 8);
1097     result = h.getVisibleSequenceStrings(5, 10, seqs);
1098     assertEquals(2, result.length);
1099     assertEquals("WS", result[0]);
1100     assertEquals("RG", result[1]);
1101
1102     SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
1103     ColumnSelection sel = new ColumnSelection();
1104     h.revealAllHiddenColumns(sel);
1105     h.hideColumns(1, 3);
1106     h.hideColumns(6, 11);
1107     assertEquals("-D",
1108             h.getVisibleSequenceStrings(0, 5, new SequenceI[]
1109     { seq })[0]);
1110   }
1111
1112   @Test(groups = "Functional")
1113   public void testHideInsertionsFor()
1114   {
1115     HiddenColumns h = new HiddenColumns();
1116     HiddenColumns h2 = new HiddenColumns();
1117     SequenceI seq1 = new Sequence("TEST1", "GAL---MFW-KQESPVICY--HRNDT");
1118     SequenceI seq2 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT");
1119
1120     h.hideInsertionsFor(seq2);
1121     assertTrue(h.equals(h2));
1122
1123     h.hideInsertionsFor(seq1);
1124     h2.hideColumns(3, 5);
1125     h2.hideColumns(9, 9);
1126     h2.hideColumns(19, 20);
1127     assertTrue(h.equals(h2));
1128   }
1129
1130   @Test(groups = "Functional")
1131   public void testHideMarkedBits()
1132   {
1133     HiddenColumns h = new HiddenColumns();
1134     HiddenColumns h2 = new HiddenColumns();
1135
1136     BitSet tohide = new BitSet(21);
1137     h.hideMarkedBits(tohide);
1138     assertTrue(h.equals(h2));
1139
1140     // NB in hideMarkedBits, the last bit is not set to hidden
1141     tohide.set(3, 6);
1142     tohide.set(9);
1143     tohide.set(19, 21);
1144     h.hideMarkedBits(tohide);
1145
1146     h2.hideColumns(3, 5);
1147     h2.hideColumns(9, 9);
1148     h2.hideColumns(19, 20);
1149     assertTrue(h.equals(h2));
1150   }
1151
1152   @Test(groups = "Functional")
1153   public void testMakeVisibleAnnotation()
1154   {
1155     HiddenColumns h = new HiddenColumns();
1156     Annotation[] anns = new Annotation[] { null, null, new Annotation(1),
1157         new Annotation(2), new Annotation(3), null, null, new Annotation(4),
1158         new Annotation(5), new Annotation(6), new Annotation(7),
1159         new Annotation(8) };
1160     AlignmentAnnotation ann = new AlignmentAnnotation("an", "some an",
1161             anns);
1162
1163     // without hidden cols, just truncates
1164     h.makeVisibleAnnotation(3, 5, ann);
1165     assertEquals(3, ann.annotations.length);
1166     assertEquals(2.0f, ann.annotations[0].value);
1167     assertEquals(3.0f, ann.annotations[1].value);
1168     assertNull(ann.annotations[2]);
1169
1170     anns = new Annotation[] { null, null, new Annotation(1),
1171         new Annotation(2), new Annotation(3), null, null, new Annotation(4),
1172         new Annotation(5), new Annotation(6), new Annotation(7),
1173         new Annotation(8) };
1174     ann = new AlignmentAnnotation("an", "some an", anns);
1175     h.hideColumns(4, 7);
1176     h.makeVisibleAnnotation(1, 9, ann);
1177     assertEquals(5, ann.annotations.length);
1178     assertNull(ann.annotations[0]);
1179     assertEquals(1.0f, ann.annotations[1].value);
1180     assertEquals(2.0f, ann.annotations[2].value);
1181     assertEquals(5.0f, ann.annotations[3].value);
1182     assertEquals(6.0f, ann.annotations[4].value);
1183
1184     anns = new Annotation[] { null, null, new Annotation(1),
1185         new Annotation(2), new Annotation(3), null, null, new Annotation(4),
1186         new Annotation(5), new Annotation(6), new Annotation(7),
1187         new Annotation(8) };
1188     ann = new AlignmentAnnotation("an", "some an", anns);
1189     h.hideColumns(1, 2);
1190     h.makeVisibleAnnotation(1, 9, ann);
1191     assertEquals(3, ann.annotations.length);
1192     assertEquals(2.0f, ann.annotations[0].value);
1193     assertEquals(5.0f, ann.annotations[1].value);
1194     assertEquals(6.0f, ann.annotations[2].value);
1195   }
1196
1197   @Test(groups = "Functional")
1198   public void testSubtractVisibleColumns()
1199   {
1200     HiddenColumns h = new HiddenColumns();
1201     int result = h.subtractVisibleColumns(1, 10);
1202     assertEquals(9, result);
1203
1204     h.hideColumns(7, 9);
1205     result = h.subtractVisibleColumns(4, 10);
1206     assertEquals(3, result);
1207
1208     h.hideColumns(14, 15);
1209     result = h.subtractVisibleColumns(4, 10);
1210     assertEquals(3, result);
1211
1212     result = h.subtractVisibleColumns(10, 17);
1213     assertEquals(2, result);
1214
1215     result = h.subtractVisibleColumns(1, 7);
1216     assertEquals(5, result);
1217
1218     result = h.subtractVisibleColumns(1, 8);
1219     assertEquals(5, result);
1220
1221     result = h.subtractVisibleColumns(3, 15);
1222     assertEquals(10, result);
1223
1224     ColumnSelection sel = new ColumnSelection();
1225     h.revealAllHiddenColumns(sel);
1226     h.hideColumns(0, 30);
1227     result = h.subtractVisibleColumns(31, 0);
1228     assertEquals(-31, result);
1229   }
1230
1231   @Test(groups = "Functional")
1232   public void testBoundedIterator()
1233   {
1234     HiddenColumns h = new HiddenColumns();
1235     Iterator<int[]> it = h.getBoundedIterator(0, 10);
1236
1237     // no hidden columns = nothing to iterate over
1238     assertFalse(it.hasNext());
1239
1240     // [start,end] contains all hidden columns
1241     // all regions are returned
1242     h.hideColumns(3, 10);
1243     h.hideColumns(14, 16);
1244     it = h.getBoundedIterator(0, 20);
1245     assertTrue(it.hasNext());
1246     int[] next = it.next();
1247     assertEquals(3, next[0]);
1248     assertEquals(10, next[1]);
1249     next = it.next();
1250     assertEquals(14, next[0]);
1251     assertEquals(16, next[1]);
1252     assertFalse(it.hasNext());
1253
1254     // [start,end] overlaps a region
1255     // 1 region returned
1256     it = h.getBoundedIterator(5, 7);
1257     assertTrue(it.hasNext());
1258     next = it.next();
1259     assertEquals(3, next[0]);
1260     assertEquals(10, next[1]);
1261     assertFalse(it.hasNext());
1262
1263     // [start,end] fully contains 1 region and start of last
1264     // - 2 regions returned
1265     it = h.getBoundedIterator(3, 15);
1266     assertTrue(it.hasNext());
1267     next = it.next();
1268     assertEquals(3, next[0]);
1269     assertEquals(10, next[1]);
1270     next = it.next();
1271     assertEquals(14, next[0]);
1272     assertEquals(16, next[1]);
1273     assertFalse(it.hasNext());
1274
1275     // [start,end] contains end of first region and whole of last region
1276     // - 2 regions returned
1277     it = h.getBoundedIterator(4, 20);
1278     assertTrue(it.hasNext());
1279     next = it.next();
1280     assertEquals(3, next[0]);
1281     assertEquals(10, next[1]);
1282     next = it.next();
1283     assertEquals(14, next[0]);
1284     assertEquals(16, next[1]);
1285     assertFalse(it.hasNext());
1286   }
1287
1288   @Test(groups = "Functional")
1289   public void testBoundedStartIterator()
1290   {
1291     HiddenColumns h = new HiddenColumns();
1292     Iterator<Integer> it = h.getBoundedStartIterator(0, 10);
1293
1294     // no hidden columns = nothing to iterate over
1295     assertFalse(it.hasNext());
1296
1297     // [start,end] contains all hidden columns
1298     // all regions are returned
1299     h.hideColumns(3, 10);
1300     h.hideColumns(14, 16);
1301     it = h.getBoundedStartIterator(0, 20);
1302     assertTrue(it.hasNext());
1303     int next = it.next();
1304     assertEquals(3, next);
1305     next = it.next();
1306     assertEquals(6, next);
1307     assertFalse(it.hasNext());
1308
1309     // [start,end] does not contain a start of a region
1310     // no regions to iterate over
1311     it = h.getBoundedStartIterator(4, 5);
1312     assertFalse(it.hasNext());
1313
1314     // [start,end] fully contains 1 region and start of last
1315     // - 2 regions returned
1316     it = h.getBoundedStartIterator(3, 7);
1317     assertTrue(it.hasNext());
1318     next = it.next();
1319     assertEquals(3, next);
1320     next = it.next();
1321     assertEquals(6, next);
1322     assertFalse(it.hasNext());
1323
1324     // [start,end] contains whole of last region
1325     // - 1 region returned
1326     it = h.getBoundedStartIterator(4, 20);
1327     assertTrue(it.hasNext());
1328     next = it.next();
1329     assertEquals(6, next);
1330     assertFalse(it.hasNext());
1331   }
1332
1333   @Test(groups = "Functional")
1334   public void testVisibleBlocksVisBoundsIterator()
1335   {
1336     HiddenColumns h = new HiddenColumns();
1337     Iterator<int[]> regions = h.getVisibleBlocksIterator(0, 30, true);
1338
1339     // only 1 visible region spanning 0-30 if nothing is hidden
1340     assertTrue(regions.hasNext());
1341     int[] region = regions.next();
1342     assertEquals(0, region[0]);
1343     assertEquals(30, region[1]);
1344     assertFalse(regions.hasNext());
1345
1346     // hide 1 region in middle
1347     // 2 regions one on either side
1348     // second region boundary accounts for hidden columns
1349     h.hideColumns(10, 15);
1350     regions = h.getVisibleBlocksIterator(0, 30, true);
1351
1352     assertTrue(regions.hasNext());
1353     region = regions.next();
1354     assertEquals(0, region[0]);
1355     assertEquals(9, region[1]);
1356     region = regions.next();
1357     assertEquals(16, region[0]);
1358     assertEquals(36, region[1]);
1359     assertFalse(regions.hasNext());
1360
1361     // single hidden region at left
1362     h = new HiddenColumns();
1363     h.hideColumns(0, 5);
1364     regions = h.getVisibleBlocksIterator(0, 30, true);
1365
1366     assertTrue(regions.hasNext());
1367     region = regions.next();
1368     assertEquals(6, region[0]);
1369     assertEquals(36, region[1]);
1370     assertFalse(regions.hasNext());
1371
1372     // single hidden region at right
1373     h = new HiddenColumns();
1374     h.hideColumns(27, 30);
1375     regions = h.getVisibleBlocksIterator(0, 30, true);
1376
1377     assertTrue(regions.hasNext());
1378     region = regions.next();
1379     assertEquals(0, region[0]);
1380     assertEquals(26, region[1]);
1381     region = regions.next();
1382     assertEquals(31, region[0]);
1383     assertEquals(34, region[1]);
1384     assertFalse(regions.hasNext());
1385
1386     // hidden region at left + hidden region in middle
1387     h = new HiddenColumns();
1388     h.hideColumns(0, 5);
1389     h.hideColumns(23, 25);
1390     regions = h.getVisibleBlocksIterator(0, 30, true);
1391
1392     assertTrue(regions.hasNext());
1393     region = regions.next();
1394     assertEquals(6, region[0]);
1395     assertEquals(22, region[1]);
1396     region = regions.next();
1397     assertEquals(26, region[0]);
1398     assertEquals(39, region[1]);
1399     assertFalse(regions.hasNext());
1400
1401     // hidden region at right + hidden region in middle
1402     h = new HiddenColumns();
1403     h.hideColumns(27, 30);
1404     h.hideColumns(11, 14);
1405     regions = h.getVisibleBlocksIterator(0, 30, true);
1406
1407     assertTrue(regions.hasNext());
1408     region = regions.next();
1409     assertEquals(0, region[0]);
1410     assertEquals(10, region[1]);
1411     region = regions.next();
1412     assertEquals(15, region[0]);
1413     assertEquals(26, region[1]);
1414     region = regions.next();
1415     assertEquals(31, region[0]);
1416     assertEquals(38, region[1]);
1417     assertFalse(regions.hasNext());
1418
1419     // hidden region at left and right
1420     h = new HiddenColumns();
1421     h.hideColumns(27, 35);
1422     h.hideColumns(0, 4);
1423     regions = h.getVisibleBlocksIterator(0, 30, true);
1424
1425     assertTrue(regions.hasNext());
1426     region = regions.next();
1427     assertEquals(5, region[0]);
1428     assertEquals(26, region[1]);
1429     region = regions.next();
1430     assertEquals(36, region[0]);
1431     assertEquals(44, region[1]);
1432     assertFalse(regions.hasNext());
1433
1434     // multiple hidden regions
1435     h = new HiddenColumns();
1436     h.hideColumns(1, 1);
1437     h.hideColumns(3, 5);
1438     h.hideColumns(9, 11);
1439     h.hideColumns(22, 26);
1440
1441     regions = h.getVisibleBlocksIterator(0, 30, true);
1442
1443     assertTrue(regions.hasNext());
1444     region = regions.next();
1445     assertEquals(0, region[0]);
1446     assertEquals(0, region[1]);
1447     region = regions.next();
1448     assertEquals(2, region[0]);
1449     assertEquals(2, region[1]);
1450     region = regions.next();
1451     assertEquals(6, region[0]);
1452     assertEquals(8, region[1]);
1453     region = regions.next();
1454     assertEquals(12, region[0]);
1455     assertEquals(21, region[1]);
1456     region = regions.next();
1457     assertEquals(27, region[0]);
1458     assertEquals(42, region[1]);
1459     assertFalse(regions.hasNext());
1460   }
1461 }