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.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertSame;
  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.List;
  33
  34 import org.testng.annotations.BeforeClass;
  35 import org.testng.annotations.Test;
  36
  37 public class HiddenColumnsTest
  38 {
  39
  40   @BeforeClass(alwaysRun = true)
  41   public void setUpJvOptionPane()
  42   {
  43     JvOptionPane.setInteractiveMode(false);
  44     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  45   }
  46
  47   /**
  48    * Test the method that finds the visible column position of an alignment
  49    * column, allowing for hidden columns.
  50    */
  51   @Test(groups = { "Functional" })
  52   public void testFindColumnPosition()
  53   {
  54     HiddenColumns cs = new HiddenColumns();
  55     assertEquals(5, cs.findColumnPosition(5));
  56
  57     // hiding column 6 makes no difference
  58     cs.hideColumns(6, 6);
  59     assertEquals(5, cs.findColumnPosition(5));
  60
  61     // hiding column 4 moves column 5 to column 4
  62     cs.hideColumns(4, 4);
  63     assertEquals(4, cs.findColumnPosition(5));
  64
  65     // hiding column 4 moves column 4 to position 3
  66     assertEquals(3, cs.findColumnPosition(4));
  67
  68     // hiding columns 1 and 2 moves column 5 to column 2
  69     cs.hideColumns(1, 2);
  70     assertEquals(2, cs.findColumnPosition(5));
  71
  72     // check with > 1 hidden column regions
  73     // where some columns are in the hidden regions
  74     HiddenColumns cs2 = new HiddenColumns();
  75     cs2.hideColumns(5, 10);
  76     cs2.hideColumns(20, 27);
  77     cs2.hideColumns(40, 44);
  78
  79     // hiding columns 5-10 and 20-27 moves column 8 to column 4
  80     assertEquals(4, cs2.findColumnPosition(8));
  81
  82     // and moves column 24 to 13
  83     assertEquals(13, cs2.findColumnPosition(24));
  84
  85     // and moves column 28 to 14
  86     assertEquals(14, cs2.findColumnPosition(28));
  87
  88     // and moves column 40 to 25
  89     assertEquals(25, cs2.findColumnPosition(40));
  90
  91     // check when hidden columns start at 0 that the visible column
  92     // is returned as 0
  93     HiddenColumns cs3 = new HiddenColumns();
  94     cs3.hideColumns(0, 4);
  95     assertEquals(0, cs3.findColumnPosition(2));
  96
  97   }
  98
  99   /**
 100    * Test the method that finds the visible column position a given distance
 101    * before another column
 102    */
 103   @Test(groups = { "Functional" })
 104   public void testFindColumnNToLeft()
 105   {
 106     HiddenColumns cs = new HiddenColumns();
 107
 108     // test that without hidden columns, findColumnNToLeft returns
 109     // position n to left of provided position
 110     int pos = cs.subtractVisibleColumns(3, 10);
 111     assertEquals(7, pos);
 112
 113     // 0 returns same position
 114     pos = cs.subtractVisibleColumns(0, 10);
 115     assertEquals(10, pos);
 116
 117     // overflow to left returns negative number
 118     pos = cs.subtractVisibleColumns(3, 0);
 119     assertEquals(-3, pos);
 120
 121     // test that with hidden columns to left of result column
 122     // behaviour is the same as above
 123     cs.hideColumns(1, 3);
 124
 125     // position n to left of provided position
 126     pos = cs.subtractVisibleColumns(3, 10);
 127     assertEquals(7, pos);
 128
 129     // 0 returns same position
 130     pos = cs.subtractVisibleColumns(0, 10);
 131     assertEquals(10, pos);
 132
 133     // test with one set of hidden columns between start and required position
 134     cs.hideColumns(12, 15);
 135     pos = cs.subtractVisibleColumns(8, 17);
 136     assertEquals(5, pos);
 137
 138     // test with two sets of hidden columns between start and required position
 139     cs.hideColumns(20, 21);
 140     pos = cs.subtractVisibleColumns(8, 23);
 141     assertEquals(9, pos);
 142
 143     // repeat last 2 tests with no hidden columns to left of required position
 144     ColumnSelection colsel = new ColumnSelection();
 145     cs.revealAllHiddenColumns(colsel);
 146
 147     // test with one set of hidden columns between start and required position
 148     cs.hideColumns(12, 15);
 149     pos = cs.subtractVisibleColumns(8, 17);
 150     assertEquals(5, pos);
 151
 152     // test with two sets of hidden columns between start and required position
 153     cs.hideColumns(20, 21);
 154     pos = cs.subtractVisibleColumns(8, 23);
 155     assertEquals(9, pos);
 156
 157   }
 158
 159   @Test(groups = { "Functional" })
 160   public void testGetVisibleContigs()
 161   {
 162     HiddenColumns cs = new HiddenColumns();
 163     cs.hideColumns(3, 6);
 164     cs.hideColumns(8, 9);
 165     cs.hideColumns(12, 12);
 166
 167     // start position is inclusive, end position exclusive:
 168     int[] visible = cs.getVisibleContigs(1, 13);
 169     assertEquals("[1, 2, 7, 7, 10, 11]", Arrays.toString(visible));
 170
 171     visible = cs.getVisibleContigs(4, 14);
 172     assertEquals("[7, 7, 10, 11, 13, 13]", Arrays.toString(visible));
 173
 174     visible = cs.getVisibleContigs(3, 10);
 175     assertEquals("[7, 7]", Arrays.toString(visible));
 176
 177     visible = cs.getVisibleContigs(4, 6);
 178     assertEquals("[]", Arrays.toString(visible));
 179   }
 180
 181   @Test(groups = { "Functional" })
 182   public void testEquals()
 183   {
 184     HiddenColumns cs = new HiddenColumns();
 185     cs.hideColumns(5, 9);
 186
 187     // a different set of hidden columns
 188     HiddenColumns cs2 = new HiddenColumns();
 189
 190     // with no hidden columns
 191     assertFalse(cs.equals(cs2));
 192     assertFalse(cs2.equals(cs));
 193
 194     // with hidden columns added in a different order
 195     cs2.hideColumns(6, 9);
 196     cs2.hideColumns(5, 8);
 197
 198     assertTrue(cs.equals(cs2));
 199     assertTrue(cs.equals(cs));
 200     assertTrue(cs2.equals(cs));
 201     assertTrue(cs2.equals(cs2));
 202   }
 203
 204   @Test(groups = "Functional")
 205   public void testCopyConstructor()
 206   {
 207     HiddenColumns cs = new HiddenColumns();
 208     cs.hideColumns(10, 11);
 209     cs.hideColumns(5, 7);
 210     assertEquals("[5, 7]", Arrays.toString(cs.getListOfCols().get(0)));
 211
 212     HiddenColumns cs2 = new HiddenColumns(cs);
 213     assertTrue(cs2.hasHiddenColumns());
 214     assertEquals(2, cs2.getListOfCols().size());
 215     // hidden columns are held in column order
 216     assertEquals("[5, 7]", Arrays.toString(cs2.getListOfCols().get(0)));
 217     assertEquals("[10, 11]", Arrays.toString(cs2.getListOfCols().get(1)));
 218   }
 219
 220   /**
 221    * Test the code used to locate the reference sequence ruler origin
 222    */
 223   @Test(groups = { "Functional" })
 224   public void testLocateVisibleBoundsofSequence()
 225   {
 226     // create random alignment
 227     AlignmentGenerator gen = new AlignmentGenerator(false);
 228     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 229
 230     HiddenColumns cs = al.getHiddenColumns();
 231     ColumnSelection colsel = new ColumnSelection();
 232
 233     SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
 234     assertEquals(2, seq.findIndex(seq.getStart()));
 235
 236     // no hidden columns
 237     assertEquals(
 238             Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
 239                 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
 240                 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
 241                 seq.findIndex(seq.getEnd()) - 1 }),
 242             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 243
 244     // hidden column on gap after end of sequence - should not affect bounds
 245     colsel.hideSelectedColumns(13, al.getHiddenColumns());
 246     assertEquals(
 247             Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
 248                 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
 249                 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
 250                 seq.findIndex(seq.getEnd()) - 1 }),
 251             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 252
 253     cs.revealAllHiddenColumns(colsel);
 254     // hidden column on gap before beginning of sequence - should vis bounds by
 255     // one
 256     colsel.hideSelectedColumns(0, al.getHiddenColumns());
 257     assertEquals(
 258             Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 2,
 259                 seq.findIndex(seq.getEnd()) - 2, seq.getStart(),
 260                 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
 261                 seq.findIndex(seq.getEnd()) - 1 }),
 262             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 263
 264     cs.revealAllHiddenColumns(colsel);
 265     // hide columns around most of sequence - leave one residue remaining
 266     cs.hideColumns(1, 3);
 267     cs.hideColumns(6, 11);
 268     assertEquals("-D",
 269             cs.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]);
 270     assertEquals(
 271             Arrays.toString(new int[] { 1, 1, 3, 3,
 272                 seq.findIndex(seq.getStart()) - 1,
 273                 seq.findIndex(seq.getEnd()) - 1 }),
 274             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 275     cs.revealAllHiddenColumns(colsel);
 276
 277     // hide whole sequence - should just get location of hidden region
 278     // containing sequence
 279     cs.hideColumns(1, 11);
 280     assertEquals(
 281             Arrays.toString(new int[] { 0, 1, 0, 0,
 282                 seq.findIndex(seq.getStart()) - 1,
 283                 seq.findIndex(seq.getEnd()) - 1 }),
 284             Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
 285
 286   }
 287
 288   @Test(groups = { "Functional" })
 289   public void testLocateVisibleBoundsPathologicals()
 290   {
 291     // test some pathological cases we missed
 292     AlignmentI al = new Alignment(new SequenceI[] { new Sequence(
 293             "refseqGaptest", "KTDVTI----------NFI-----G----L") });
 294     HiddenColumns cs = new HiddenColumns();
 295     cs.hideInsertionsFor(al.getSequenceAt(0));
 296     assertEquals(
 297             "G",
 298             ""
 299                     + al.getSequenceAt(0).getCharAt(
 300                             cs.adjustForHiddenColumns(9)));
 301
 302   }
 303
 304   @Test(groups = { "Functional" })
 305   public void testHideColumns()
 306   {
 307     // create random alignment
 308     AlignmentGenerator gen = new AlignmentGenerator(false);
 309     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 310
 311     ColumnSelection colsel = new ColumnSelection();
 312     HiddenColumns cs = al.getHiddenColumns();
 313     colsel.hideSelectedColumns(5, al.getHiddenColumns());
 314     List<int[]> hidden = cs.getListOfCols();
 315     assertEquals(1, hidden.size());
 316     assertEquals("[5, 5]", Arrays.toString(hidden.get(0)));
 317
 318     colsel.hideSelectedColumns(3, al.getHiddenColumns());
 319     assertEquals(2, hidden.size());
 320     // two hidden ranges, in order:
 321     assertSame(hidden, cs.getListOfCols());
 322     assertEquals("[3, 3]", Arrays.toString(hidden.get(0)));
 323     assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
 324
 325     // hiding column 4 expands [3, 3] to [3, 4]
 326     // and merges to [5, 5] to make [3, 5]
 327     colsel.hideSelectedColumns(4, al.getHiddenColumns());
 328     hidden = cs.getListOfCols();
 329     assertEquals(1, hidden.size());
 330     assertEquals("[3, 5]", Arrays.toString(hidden.get(0)));
 331
 332     // clear hidden columns (note they are added to selected)
 333     cs.revealAllHiddenColumns(colsel);
 334     // it is now actually null but getter returns an empty list
 335     assertTrue(cs.getListOfCols().isEmpty());
 336
 337     cs.hideColumns(3, 6);
 338     hidden = cs.getListOfCols();
 339     int[] firstHiddenRange = hidden.get(0);
 340     assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
 341
 342     // adding a subrange of already hidden should do nothing
 343     cs.hideColumns(4, 5);
 344     assertEquals(1, hidden.size());
 345     assertSame(firstHiddenRange, cs.getListOfCols().get(0));
 346     cs.hideColumns(3, 5);
 347     assertEquals(1, hidden.size());
 348     assertSame(firstHiddenRange, cs.getListOfCols().get(0));
 349     cs.hideColumns(4, 6);
 350     assertEquals(1, hidden.size());
 351     assertSame(firstHiddenRange, cs.getListOfCols().get(0));
 352     cs.hideColumns(3, 6);
 353     assertEquals(1, hidden.size());
 354     assertSame(firstHiddenRange, cs.getListOfCols().get(0));
 355
 356     cs.revealAllHiddenColumns(colsel);
 357     cs.hideColumns(2, 4);
 358     hidden = cs.getListOfCols();
 359     assertEquals(1, hidden.size());
 360     assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
 361
 362     // extend contiguous with 2 positions overlap
 363     cs.hideColumns(3, 5);
 364     assertEquals(1, hidden.size());
 365     assertEquals("[2, 5]", Arrays.toString(hidden.get(0)));
 366
 367     // extend contiguous with 1 position overlap
 368     cs.hideColumns(5, 6);
 369     assertEquals(1, hidden.size());
 370     assertEquals("[2, 6]", Arrays.toString(hidden.get(0)));
 371
 372     // extend contiguous with overlap both ends:
 373     cs.hideColumns(1, 7);
 374     assertEquals(1, hidden.size());
 375     assertEquals("[1, 7]", Arrays.toString(hidden.get(0)));
 376   }
 377
 378   /**
 379    * Test the method that reveals a range of hidden columns given the start
 380    * column of the range
 381    */
 382   @Test(groups = { "Functional" })
 383   public void testRevealHiddenColumns()
 384   {
 385     ColumnSelection colsel = new ColumnSelection();
 386     HiddenColumns cs = new HiddenColumns();
 387     cs.hideColumns(5, 8);
 388     colsel.addElement(10);
 389     cs.revealHiddenColumns(5, colsel);
 390     // hidden columns list now null but getter returns empty list:
 391     assertTrue(cs.getListOfCols().isEmpty());
 392     // revealed columns are marked as selected (added to selection):
 393     assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString());
 394
 395     // calling with a column other than the range start does nothing:
 396     colsel = new ColumnSelection();
 397     cs = new HiddenColumns();
 398     cs.hideColumns(5, 8);
 399     List<int[]> hidden = cs.getListOfCols();
 400     cs.revealHiddenColumns(6, colsel);
 401     assertSame(hidden, cs.getListOfCols());
 402     assertTrue(colsel.getSelected().isEmpty());
 403   }
 404
 405   @Test(groups = { "Functional" })
 406   public void testRevealAllHiddenColumns()
 407   {
 408     HiddenColumns cs = new HiddenColumns();
 409     ColumnSelection colsel = new ColumnSelection();
 410     cs.hideColumns(5, 8);
 411     cs.hideColumns(2, 3);
 412     colsel.addElement(11);
 413     colsel.addElement(1);
 414     cs.revealAllHiddenColumns(colsel);
 415
 416     /*
 417      * revealing hidden columns adds them (in order) to the (unordered)
 418      * selection list
 419      */
 420     assertTrue(cs.getListOfCols().isEmpty());
 421     assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", colsel.getSelected()
 422             .toString());
 423   }
 424
 425   @Test(groups = { "Functional" })
 426   public void testIsVisible()
 427   {
 428     HiddenColumns cs = new HiddenColumns();
 429     cs.hideColumns(2, 4);
 430     cs.hideColumns(6, 7);
 431     assertTrue(cs.isVisible(0));
 432     assertTrue(cs.isVisible(-99));
 433     assertTrue(cs.isVisible(1));
 434     assertFalse(cs.isVisible(2));
 435     assertFalse(cs.isVisible(3));
 436     assertFalse(cs.isVisible(4));
 437     assertTrue(cs.isVisible(5));
 438     assertFalse(cs.isVisible(6));
 439     assertFalse(cs.isVisible(7));
 440   }
 441
 442   /**
 443    * Test for the case when a hidden range encloses more one already hidden
 444    * range
 445    */
 446   @Test(groups = { "Functional" })
 447   public void testHideColumns_subsumingHidden()
 448   {
 449     /*
 450      * JAL-2370 bug scenario:
 451      * two hidden ranges subsumed by a third
 452      */
 453     HiddenColumns cs = new HiddenColumns();
 454     cs.hideColumns(49, 59);
 455     cs.hideColumns(69, 79);
 456     List<int[]> hidden = cs.getListOfCols();
 457     assertEquals(2, hidden.size());
 458     assertEquals("[49, 59]", Arrays.toString(hidden.get(0)));
 459     assertEquals("[69, 79]", Arrays.toString(hidden.get(1)));
 460
 461     cs.hideColumns(48, 80);
 462     hidden = cs.getListOfCols();
 463     assertEquals(1, hidden.size());
 464     assertEquals("[48, 80]", Arrays.toString(hidden.get(0)));
 465
 466     /*
 467      * another...joining hidden ranges
 468      */
 469     cs = new HiddenColumns();
 470     cs.hideColumns(10, 20);
 471     cs.hideColumns(30, 40);
 472     cs.hideColumns(50, 60);
 473     // hiding 21-49 should merge to one range
 474     cs.hideColumns(21, 49);
 475     hidden = cs.getListOfCols();
 476     assertEquals(1, hidden.size());
 477     assertEquals("[10, 60]", Arrays.toString(hidden.get(0)));
 478
 479     /*
 480      * another...left overlap, subsumption, right overlap,
 481      * no overlap of existing hidden ranges
 482      */
 483     cs = new HiddenColumns();
 484     cs.hideColumns(10, 20);
 485     cs.hideColumns(10, 20);
 486     cs.hideColumns(30, 35);
 487     cs.hideColumns(40, 50);
 488     cs.hideColumns(60, 70);
 489
 490     cs.hideColumns(15, 45);
 491     hidden = cs.getListOfCols();
 492     assertEquals(2, hidden.size());
 493     assertEquals("[10, 50]", Arrays.toString(hidden.get(0)));
 494     assertEquals("[60, 70]", Arrays.toString(hidden.get(1)));
 495   }
 496
 497 }