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.assertSame;
  27 import static org.testng.AssertJUnit.assertTrue;
  28
  29 import jalview.analysis.AlignmentGenerator;
  30 import jalview.gui.JvOptionPane;
  31
  32 import java.util.Arrays;
  33 import java.util.BitSet;
  34 import java.util.List;
  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     int 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 testGetVisibleContigs()
 187   {
 188     HiddenColumns cs = new HiddenColumns();
 189     cs.hideColumns(3, 6);
 190     cs.hideColumns(8, 9);
 191     cs.hideColumns(12, 12);
 192
 193     // start position is inclusive, end position exclusive:
 194     int[] visible = cs.getVisibleContigs(1, 13);
 195     assertEquals("[1, 2, 7, 7, 10, 11]", Arrays.toString(visible));
 196
 197     visible = cs.getVisibleContigs(4, 14);
 198     assertEquals("[7, 7, 10, 11, 13, 13]", Arrays.toString(visible));
 199
 200     visible = cs.getVisibleContigs(3, 10);
 201     assertEquals("[7, 7]", Arrays.toString(visible));
 202
 203     visible = cs.getVisibleContigs(4, 6);
 204     assertEquals("[]", Arrays.toString(visible));
 205   }
 206
 207   @Test(groups = { "Functional" })
 208   public void testEquals()
 209   {
 210     HiddenColumns cs = new HiddenColumns();
 211     cs.hideColumns(5, 9);
 212
 213     // a different set of hidden columns
 214     HiddenColumns cs2 = new HiddenColumns();
 215
 216     // with no hidden columns
 217     assertFalse(cs.equals(cs2));
 218     assertFalse(cs2.equals(cs));
 219
 220     // with hidden columns added in a different order
 221     cs2.hideColumns(6, 9);
 222     cs2.hideColumns(5, 8);
 223
 224     assertTrue(cs.equals(cs2));
 225     assertTrue(cs.equals(cs));
 226     assertTrue(cs2.equals(cs));
 227     assertTrue(cs2.equals(cs2));
 228   }
 229
 230   @Test(groups = "Functional")
 231   public void testCopyConstructor()
 232   {
 233     HiddenColumns cs = new HiddenColumns();
 234     cs.hideColumns(10, 11);
 235     cs.hideColumns(5, 7);
 236     assertEquals("[5, 7]", Arrays.toString(cs.getHiddenRegions().get(0)));
 237
 238     HiddenColumns cs2 = new HiddenColumns(cs);
 239     assertTrue(cs2.hasHiddenColumns());
 240     assertEquals(2, cs2.getHiddenRegions().size());
 241     // hidden columns are held in column order
 242     assertEquals("[5, 7]", Arrays.toString(cs2.getHiddenRegions().get(0)));
 243     assertEquals("[10, 11]", Arrays.toString(cs2.getHiddenRegions().get(1)));
 244   }
 245
 246   /**
 247    * Test the code used to locate the reference sequence ruler origin
 248    */
 249   @Test(groups = { "Functional" })
 250   public void testLocateVisibleBoundsofSequence()
 251   {
 252     // create random alignment
 253     AlignmentGenerator gen = new AlignmentGenerator(false);
 254     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 255
 256     HiddenColumns cs = al.getHiddenColumns();
 257     ColumnSelection colsel = new ColumnSelection();
 258
 259     SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
 260     assertEquals(2, seq.findIndex(seq.getStart()));
 261
 262     // no hidden columns
 263     assertEquals(
 264             Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
 265                 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
 266                 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
 267                 seq.findIndex(seq.getEnd()) - 1 }),
 268             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 269
 270     // hidden column on gap after end of sequence - should not affect bounds
 271     colsel.hideSelectedColumns(13, al.getHiddenColumns());
 272     assertEquals(
 273             Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
 274                 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
 275                 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
 276                 seq.findIndex(seq.getEnd()) - 1 }),
 277             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 278
 279     cs.revealAllHiddenColumns(colsel);
 280     // hidden column on gap before beginning of sequence - should vis bounds by
 281     // one
 282     colsel.hideSelectedColumns(0, al.getHiddenColumns());
 283     assertEquals(
 284             Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 2,
 285                 seq.findIndex(seq.getEnd()) - 2, seq.getStart(),
 286                 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
 287                 seq.findIndex(seq.getEnd()) - 1 }),
 288             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 289
 290     cs.revealAllHiddenColumns(colsel);
 291     // hide columns around most of sequence - leave one residue remaining
 292     cs.hideColumns(1, 3);
 293     cs.hideColumns(6, 11);
 294     assertEquals("-D",
 295             cs.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]);
 296     assertEquals(
 297             Arrays.toString(new int[] { 1, 1, 3, 3,
 298                 seq.findIndex(seq.getStart()) - 1,
 299                 seq.findIndex(seq.getEnd()) - 1 }),
 300             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 301     cs.revealAllHiddenColumns(colsel);
 302
 303     // hide whole sequence - should just get location of hidden region
 304     // containing sequence
 305     cs.hideColumns(1, 11);
 306     assertEquals(
 307             Arrays.toString(new int[] { 0, 1, 0, 0,
 308                 seq.findIndex(seq.getStart()) - 1,
 309                 seq.findIndex(seq.getEnd()) - 1 }),
 310             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 311
 312   }
 313
 314   @Test(groups = { "Functional" })
 315   public void testLocateVisibleBoundsPathologicals()
 316   {
 317     // test some pathological cases we missed
 318     AlignmentI al = new Alignment(new SequenceI[] { new Sequence(
 319             "refseqGaptest", "KTDVTI----------NFI-----G----L") });
 320     HiddenColumns cs = new HiddenColumns();
 321     cs.hideInsertionsFor(al.getSequenceAt(0));
 322     assertEquals(
 323             "G",
 324             ""
 325                     + al.getSequenceAt(0).getCharAt(
 326                             cs.adjustForHiddenColumns(9)));
 327
 328   }
 329
 330   @Test(groups = { "Functional" })
 331   public void testHideColumns()
 332   {
 333     // create random alignment
 334     AlignmentGenerator gen = new AlignmentGenerator(false);
 335     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 336
 337     ColumnSelection colsel = new ColumnSelection();
 338     HiddenColumns cs = al.getHiddenColumns();
 339     colsel.hideSelectedColumns(5, al.getHiddenColumns());
 340     List<int[]> hidden = cs.getHiddenRegions();
 341     assertEquals(1, hidden.size());
 342     assertEquals("[5, 5]", Arrays.toString(hidden.get(0)));
 343
 344     colsel.hideSelectedColumns(3, al.getHiddenColumns());
 345     assertEquals(2, hidden.size());
 346     // two hidden ranges, in order:
 347     assertSame(hidden, cs.getHiddenRegions());
 348     assertEquals("[3, 3]", Arrays.toString(hidden.get(0)));
 349     assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
 350
 351     // hiding column 4 expands [3, 3] to [3, 4]
 352     // and merges to [5, 5] to make [3, 5]
 353     colsel.hideSelectedColumns(4, al.getHiddenColumns());
 354     hidden = cs.getHiddenRegions();
 355     assertEquals(1, hidden.size());
 356     assertEquals("[3, 5]", Arrays.toString(hidden.get(0)));
 357
 358     // clear hidden columns (note they are added to selected)
 359     cs.revealAllHiddenColumns(colsel);
 360     // it is now actually null but getter returns an empty list
 361     assertTrue(cs.getHiddenRegions().isEmpty());
 362
 363     cs.hideColumns(3, 6);
 364     hidden = cs.getHiddenRegions();
 365     int[] firstHiddenRange = hidden.get(0);
 366     assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
 367
 368     // adding a subrange of already hidden should do nothing
 369     cs.hideColumns(4, 5);
 370     assertEquals(1, hidden.size());
 371     assertSame(firstHiddenRange, cs.getHiddenRegions().get(0));
 372     cs.hideColumns(3, 5);
 373     assertEquals(1, hidden.size());
 374     assertSame(firstHiddenRange, cs.getHiddenRegions().get(0));
 375     cs.hideColumns(4, 6);
 376     assertEquals(1, hidden.size());
 377     assertSame(firstHiddenRange, cs.getHiddenRegions().get(0));
 378     cs.hideColumns(3, 6);
 379     assertEquals(1, hidden.size());
 380     assertSame(firstHiddenRange, cs.getHiddenRegions().get(0));
 381
 382     cs.revealAllHiddenColumns(colsel);
 383     cs.hideColumns(2, 4);
 384     hidden = cs.getHiddenRegions();
 385     assertEquals(1, hidden.size());
 386     assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
 387
 388     // extend contiguous with 2 positions overlap
 389     cs.hideColumns(3, 5);
 390     assertEquals(1, hidden.size());
 391     assertEquals("[2, 5]", Arrays.toString(hidden.get(0)));
 392
 393     // extend contiguous with 1 position overlap
 394     cs.hideColumns(5, 6);
 395     assertEquals(1, hidden.size());
 396     assertEquals("[2, 6]", Arrays.toString(hidden.get(0)));
 397
 398     // extend contiguous with overlap both ends:
 399     cs.hideColumns(1, 7);
 400     assertEquals(1, hidden.size());
 401     assertEquals("[1, 7]", Arrays.toString(hidden.get(0)));
 402   }
 403
 404   /**
 405    * Test the method that reveals a range of hidden columns given the start
 406    * column of the range
 407    */
 408   @Test(groups = { "Functional" })
 409   public void testRevealHiddenColumns()
 410   {
 411     ColumnSelection colsel = new ColumnSelection();
 412     HiddenColumns cs = new HiddenColumns();
 413     cs.hideColumns(5, 8);
 414     colsel.addElement(10);
 415     cs.revealHiddenColumns(5, colsel);
 416     // hidden columns list now null but getter returns empty list:
 417     assertTrue(cs.getHiddenRegions().isEmpty());
 418     // revealed columns are marked as selected (added to selection):
 419     assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString());
 420
 421     // calling with a column other than the range start does nothing:
 422     colsel = new ColumnSelection();
 423     cs = new HiddenColumns();
 424     cs.hideColumns(5, 8);
 425     List<int[]> hidden = cs.getHiddenRegions();
 426     cs.revealHiddenColumns(6, colsel);
 427     assertSame(hidden, cs.getHiddenRegions());
 428     assertTrue(colsel.getSelected().isEmpty());
 429   }
 430
 431   @Test(groups = { "Functional" })
 432   public void testRevealAllHiddenColumns()
 433   {
 434     HiddenColumns cs = new HiddenColumns();
 435     ColumnSelection colsel = new ColumnSelection();
 436     cs.hideColumns(5, 8);
 437     cs.hideColumns(2, 3);
 438     colsel.addElement(11);
 439     colsel.addElement(1);
 440     cs.revealAllHiddenColumns(colsel);
 441
 442     /*
 443      * revealing hidden columns adds them (in order) to the (unordered)
 444      * selection list
 445      */
 446     assertTrue(cs.getHiddenRegions().isEmpty());
 447     assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", colsel.getSelected()
 448             .toString());
 449   }
 450
 451   @Test(groups = { "Functional" })
 452   public void testIsVisible()
 453   {
 454     HiddenColumns cs = new HiddenColumns();
 455     cs.hideColumns(2, 4);
 456     cs.hideColumns(6, 7);
 457     assertTrue(cs.isVisible(0));
 458     assertTrue(cs.isVisible(-99));
 459     assertTrue(cs.isVisible(1));
 460     assertFalse(cs.isVisible(2));
 461     assertFalse(cs.isVisible(3));
 462     assertFalse(cs.isVisible(4));
 463     assertTrue(cs.isVisible(5));
 464     assertFalse(cs.isVisible(6));
 465     assertFalse(cs.isVisible(7));
 466   }
 467
 468   /**
 469    * Test for the case when a hidden range encloses more one already hidden
 470    * range
 471    */
 472   @Test(groups = { "Functional" })
 473   public void testHideColumns_subsumingHidden()
 474   {
 475     /*
 476      * JAL-2370 bug scenario:
 477      * two hidden ranges subsumed by a third
 478      */
 479     HiddenColumns cs = new HiddenColumns();
 480     cs.hideColumns(49, 59);
 481     cs.hideColumns(69, 79);
 482     List<int[]> hidden = cs.getHiddenRegions();
 483     assertEquals(2, hidden.size());
 484     assertEquals("[49, 59]", Arrays.toString(hidden.get(0)));
 485     assertEquals("[69, 79]", Arrays.toString(hidden.get(1)));
 486
 487     cs.hideColumns(48, 80);
 488     hidden = cs.getHiddenRegions();
 489     assertEquals(1, hidden.size());
 490     assertEquals("[48, 80]", Arrays.toString(hidden.get(0)));
 491
 492     /*
 493      * another...joining hidden ranges
 494      */
 495     cs = new HiddenColumns();
 496     cs.hideColumns(10, 20);
 497     cs.hideColumns(30, 40);
 498     cs.hideColumns(50, 60);
 499     // hiding 21-49 should merge to one range
 500     cs.hideColumns(21, 49);
 501     hidden = cs.getHiddenRegions();
 502     assertEquals(1, hidden.size());
 503     assertEquals("[10, 60]", Arrays.toString(hidden.get(0)));
 504
 505     /*
 506      * another...left overlap, subsumption, right overlap,
 507      * no overlap of existing hidden ranges
 508      */
 509     cs = new HiddenColumns();
 510     cs.hideColumns(10, 20);
 511     cs.hideColumns(10, 20);
 512     cs.hideColumns(30, 35);
 513     cs.hideColumns(40, 50);
 514     cs.hideColumns(60, 70);
 515
 516     cs.hideColumns(15, 45);
 517     hidden = cs.getHiddenRegions();
 518     assertEquals(2, hidden.size());
 519     assertEquals("[10, 50]", Arrays.toString(hidden.get(0)));
 520     assertEquals("[60, 70]", Arrays.toString(hidden.get(1)));
 521   }
 522
 523   @Test(groups = { "Functional" })
 524   public void testHideBitset()
 525   {
 526     HiddenColumns cs;
 527
 528     BitSet one = new BitSet();
 529
 530     // one hidden range
 531     one.set(1);
 532     cs = new HiddenColumns();
 533     cs.hideMarkedBits(one);
 534     assertEquals(1, cs.getHiddenRegions().size());
 535
 536     one.set(2);
 537     cs = new HiddenColumns();
 538     cs.hideMarkedBits(one);
 539     assertEquals(1, cs.getHiddenRegions().size());
 540
 541     one.set(3);
 542     cs = new HiddenColumns();
 543     cs.hideMarkedBits(one);
 544     assertEquals(1, cs.getHiddenRegions().size());
 545
 546     // split
 547     one.clear(2);
 548     cs = new HiddenColumns();
 549     cs.hideMarkedBits(one);
 550     assertEquals(2, cs.getHiddenRegions().size());
 551
 552     assertEquals(0, cs.adjustForHiddenColumns(0));
 553     assertEquals(2, cs.adjustForHiddenColumns(1));
 554     assertEquals(4, cs.adjustForHiddenColumns(2));
 555
 556     // one again
 557     one.clear(1);
 558     cs = new HiddenColumns();
 559     cs.hideMarkedBits(one);
 560
 561     assertEquals(1, cs.getHiddenRegions().size());
 562
 563     assertEquals(0, cs.adjustForHiddenColumns(0));
 564     assertEquals(1, cs.adjustForHiddenColumns(1));
 565     assertEquals(2, cs.adjustForHiddenColumns(2));
 566     assertEquals(4, cs.adjustForHiddenColumns(3));
 567   }
 568
 569   @Test(groups = { "Functional" })
 570   public void testGetBitset()
 571   {
 572     BitSet toMark, fromMark;
 573     long seed = -3241532;
 574     Random number = new Random(seed);
 575     for (int n = 0; n < 1000; n++)
 576     {
 577       // create a random bitfield
 578       toMark = BitSet.valueOf(new long[] { number.nextLong(),
 579           number.nextLong(), number.nextLong() });
 580       toMark.set(n * number.nextInt(10), n * (25 + number.nextInt(25)));
 581       HiddenColumns hc = new HiddenColumns();
 582       hc.hideMarkedBits(toMark);
 583
 584       // see if we can recover bitfield
 585       hc.markHiddenRegions(fromMark = new BitSet());
 586       assertEquals(toMark, fromMark);
 587     }
 588   }
 589
 590   @Test(groups = { "Functional" })
 591   public void testFindHiddenRegionPositions()
 592   {
 593     HiddenColumns hc = new HiddenColumns();
 594
 595     List<Integer> positions = hc.findHiddenRegionPositions();
 596     assertTrue(positions.isEmpty());
 597
 598     hc.hideColumns(3, 7);
 599     hc.hideColumns(10, 10);
 600     hc.hideColumns(14, 15);
 601
 602     positions = hc.findHiddenRegionPositions();
 603     assertEquals(3, positions.size());
 604     assertEquals(3, positions.get(0).intValue());
 605     assertEquals(5, positions.get(1).intValue());
 606     assertEquals(8, positions.get(2).intValue());
 607   }
 608
 609   @Test(groups = { "Functional" })
 610   public void testRegionsToString()
 611   {
 612     HiddenColumns hc = new HiddenColumns();
 613
 614     String result = hc.regionsToString(",", "--");
 615     assertEquals("", result);
 616
 617     hc.hideColumns(3, 7);
 618     hc.hideColumns(10, 10);
 619     hc.hideColumns(14, 15);
 620
 621     result = hc.regionsToString(",", "--");
 622     assertEquals("3--7,10--10,14--15", result);
 623   }
 624
 625   @Test(groups = "Functional")
 626   public void getVisibleStartAndEndIndexTest()
 627   {
 628     Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
 629     AlignmentI align = new Alignment(new SequenceI[] { seq });
 630     HiddenColumns hc = new HiddenColumns();
 631
 632     int[] startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 633     assertEquals(0, startEnd[0]);
 634     assertEquals(25, startEnd[1]);
 635
 636     hc.hideColumns(0, 0);
 637     startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 638     assertEquals(1, startEnd[0]);
 639     assertEquals(25, startEnd[1]);
 640
 641     hc.hideColumns(6, 9);
 642     hc.hideColumns(11, 12);
 643     startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 644     assertEquals(1, startEnd[0]);
 645     assertEquals(25, startEnd[1]);
 646
 647     hc.hideColumns(24, 25);
 648     startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
 649     System.out.println(startEnd[0] + " : " + startEnd[1]);
 650     assertEquals(1, startEnd[0]);
 651     assertEquals(23, startEnd[1]);
 652   }
 653
 654   @Test(groups = "Functional")
 655   public void testGetRegionWithEdgeAtRes()
 656   {
 657     HiddenColumns hc = new HiddenColumns();
 658
 659     int[] result = hc.getRegionWithEdgeAtRes(5);
 660     assertNull(result);
 661
 662     hc.hideColumns(3, 7);
 663     hc.hideColumns(10, 10);
 664     hc.hideColumns(14, 15);
 665
 666     result = hc.getRegionWithEdgeAtRes(3);
 667     assertEquals(3, result[0]);
 668     assertEquals(7, result[1]);
 669
 670     result = hc.getRegionWithEdgeAtRes(5);
 671     assertEquals(10, result[0]);
 672     assertEquals(10, result[1]);
 673
 674     result = hc.getRegionWithEdgeAtRes(6);
 675     assertNull(result);
 676   }
 677
 678 }