test/jalview/datamodel/ColumnSelectionTest.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.assertTrue;
  26 import static org.testng.AssertJUnit.fail;
  27
  28 import jalview.analysis.AlignmentGenerator;
  29 import jalview.gui.JvOptionPane;
  30
  31 import java.util.Arrays;
  32 import java.util.BitSet;
  33 import java.util.Collections;
  34 import java.util.ConcurrentModificationException;
  35 import java.util.List;
  36
  37 import org.testng.annotations.BeforeClass;
  38 import org.testng.annotations.Test;
  39
  40 public class ColumnSelectionTest
  41 {
  42
  43   @BeforeClass(alwaysRun = true)
  44   public void setUpJvOptionPane()
  45   {
  46     JvOptionPane.setInteractiveMode(false);
  47     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  48   }
  49
  50   @Test(groups = { "Functional" })
  51   public void testAddElement()
  52   {
  53     ColumnSelection cs = new ColumnSelection();
  54     cs.addElement(2);
  55     cs.addElement(5);
  56     cs.addElement(3);
  57     cs.addElement(5); // ignored
  58     List<Integer> sel = cs.getSelected();
  59     assertEquals("[2, 5, 3]", sel.toString());
  60   }
  61
  62   @Test(groups = { "Functional" })
  63   public void testSetElementsFrom()
  64   {
  65     ColumnSelection fromcs = new ColumnSelection();
  66     ColumnSelection tocs = new ColumnSelection();
  67     HiddenColumns hidden = new HiddenColumns();
  68
  69     fromcs.addElement(2);
  70     fromcs.addElement(3);
  71     fromcs.addElement(5);
  72
  73     tocs.setElementsFrom(fromcs, hidden);
  74     assertTrue(tocs.equals(fromcs));
  75
  76     hidden.hideColumns(4, 6);
  77     tocs.setElementsFrom(fromcs, hidden);
  78
  79     // expect cols 2 and 3 to be selected but not 5
  80     ColumnSelection expectcs = new ColumnSelection();
  81     expectcs.addElement(2);
  82     expectcs.addElement(3);
  83     assertTrue(tocs.equals(expectcs));
  84   }
  85
  86   /**
  87    * Test the remove method - in particular to verify that remove(int i) removes
  88    * the element whose value is i, _NOT_ the i'th element.
  89    */
  90   @Test(groups = { "Functional" })
  91   public void testRemoveElement()
  92   {
  93     ColumnSelection cs = new ColumnSelection();
  94     cs.addElement(2);
  95     cs.addElement(5);
  96
  97     // removing elements not in the list has no effect
  98     cs.removeElement(0);
  99     cs.removeElement(1);
 100     List<Integer> sel = cs.getSelected();
 101     assertEquals(2, sel.size());
 102     assertEquals(new Integer(2), sel.get(0));
 103     assertEquals(new Integer(5), sel.get(1));
 104
 105     // removing an element in the list removes it
 106     cs.removeElement(2);
 107     // ...and also from the read-only view
 108     assertEquals(1, sel.size());
 109     sel = cs.getSelected();
 110     assertEquals(1, sel.size());
 111     assertEquals(new Integer(5), sel.get(0));
 112   }
 113
 114   /**
 115    * Test the method that hides a specified column including any adjacent
 116    * selected columns. This is a convenience method for the case where multiple
 117    * column regions are selected and then hidden using menu option View | Hide |
 118    * Selected Columns.
 119    */
 120   @Test(groups = { "Functional" })
 121   public void testHideColumns_withSelection()
 122   {
 123     // create random alignment
 124     AlignmentGenerator gen = new AlignmentGenerator(false);
 125     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 126
 127     ColumnSelection cs = new ColumnSelection();
 128     // select columns 4-6
 129     cs.addElement(4);
 130     cs.addElement(5);
 131     cs.addElement(6);
 132     // hide column 5 (and adjacent):
 133     cs.hideSelectedColumns(5, al.getHiddenColumns());
 134     // 4,5,6 now hidden:
 135     List<int[]> hidden = al.getHiddenColumns().getHiddenRegions();
 136     assertEquals(1, hidden.size());
 137     assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
 138     // none now selected:
 139     assertTrue(cs.getSelected().isEmpty());
 140
 141     // repeat, hiding column 4 (5 and 6)
 142     al = gen.generate(50, 20, 123, 5, 5);
 143     cs = new ColumnSelection();
 144     cs.addElement(4);
 145     cs.addElement(5);
 146     cs.addElement(6);
 147     cs.hideSelectedColumns(4, al.getHiddenColumns());
 148     hidden = al.getHiddenColumns().getHiddenRegions();
 149     assertEquals(1, hidden.size());
 150     assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
 151     assertTrue(cs.getSelected().isEmpty());
 152
 153     // repeat, hiding column (4, 5 and) 6
 154     al = gen.generate(50, 20, 123, 5, 5);
 155     cs = new ColumnSelection();
 156     cs.addElement(4);
 157     cs.addElement(5);
 158     cs.addElement(6);
 159     cs.hideSelectedColumns(6, al.getHiddenColumns());
 160     hidden = al.getHiddenColumns().getHiddenRegions();
 161     assertEquals(1, hidden.size());
 162     assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
 163     assertTrue(cs.getSelected().isEmpty());
 164
 165     // repeat, with _only_ adjacent columns selected
 166     al = gen.generate(50, 20, 123, 5, 5);
 167     cs = new ColumnSelection();
 168     cs.addElement(4);
 169     cs.addElement(6);
 170     cs.hideSelectedColumns(5, al.getHiddenColumns());
 171     hidden = al.getHiddenColumns().getHiddenRegions();
 172     assertEquals(1, hidden.size());
 173     assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
 174     assertTrue(cs.getSelected().isEmpty());
 175   }
 176
 177   /**
 178    * Test the method that hides all (possibly disjoint) selected column ranges
 179    */
 180   @Test(groups = { "Functional" })
 181   public void testHideSelectedColumns()
 182   {
 183     // create random alignment
 184     AlignmentGenerator gen = new AlignmentGenerator(false);
 185     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 186
 187     ColumnSelection cs = new ColumnSelection();
 188     int[] sel = { 2, 3, 4, 7, 8, 9, 20, 21, 22 };
 189     for (int col : sel)
 190     {
 191       cs.addElement(col);
 192     }
 193
 194     HiddenColumns cols = al.getHiddenColumns();
 195     cols.hideColumns(15, 18);
 196
 197     cs.hideSelectedColumns(al);
 198     assertTrue(cs.getSelected().isEmpty());
 199     List<int[]> hidden = cols.getHiddenRegions();
 200     assertEquals(4, hidden.size());
 201     assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
 202     assertEquals("[7, 9]", Arrays.toString(hidden.get(1)));
 203     assertEquals("[15, 18]", Arrays.toString(hidden.get(2)));
 204     assertEquals("[20, 22]", Arrays.toString(hidden.get(3)));
 205   }
 206
 207   /**
 208    * Test the method that gets runs of selected columns ordered by column. If
 209    * this fails, HideSelectedColumns may also fail
 210    */
 211   @Test(groups = { "Functional" })
 212   public void testGetSelectedRanges()
 213   {
 214     /*
 215      * getSelectedRanges returns ordered columns regardless
 216      * of the order in which they are added
 217      */
 218     ColumnSelection cs = new ColumnSelection();
 219     int[] sel = { 4, 3, 7, 21, 9, 20, 8, 22, 2 };
 220     for (int col : sel)
 221     {
 222       cs.addElement(col);
 223     }
 224     List<int[]> range;
 225     range = cs.getSelectedRanges();
 226     assertEquals(3, range.size());
 227     assertEquals("[2, 4]", Arrays.toString(range.get(0)));
 228     assertEquals("[7, 9]", Arrays.toString(range.get(1)));
 229     assertEquals("[20, 22]", Arrays.toString(range.get(2)));
 230     cs.addElement(0);
 231     cs.addElement(1);
 232     range = cs.getSelectedRanges();
 233     assertEquals(3, range.size());
 234     assertEquals("[0, 4]", Arrays.toString(range.get(0)));
 235   }
 236
 237   @Test(groups = { "Functional" })
 238   public void testInvertColumnSelection()
 239   {
 240     // create random alignment
 241     AlignmentGenerator gen = new AlignmentGenerator(false);
 242     AlignmentI al = gen.generate(50, 20, 123, 5, 5);
 243
 244     ColumnSelection cs = new ColumnSelection();
 245     cs.addElement(4);
 246     cs.addElement(6);
 247     cs.addElement(8);
 248
 249     HiddenColumns cols = al.getHiddenColumns();
 250     cols.hideColumns(3, 3);
 251     cols.hideColumns(6, 6);
 252
 253     // invert selection from start (inclusive) to end (exclusive)
 254     cs.invertColumnSelection(2, 9, al);
 255     assertEquals("[2, 5, 7]", cs.getSelected().toString());
 256
 257     cs.invertColumnSelection(1, 9, al);
 258     assertEquals("[1, 4, 8]", cs.getSelected().toString());
 259   }
 260
 261   @Test(groups = { "Functional" })
 262   public void testMaxColumnSelection()
 263   {
 264     ColumnSelection cs = new ColumnSelection();
 265     cs.addElement(0);
 266     cs.addElement(513);
 267     cs.addElement(1);
 268     assertEquals(513, cs.getMax());
 269     cs.removeElement(513);
 270     assertEquals(1, cs.getMax());
 271     cs.removeElement(1);
 272     assertEquals(0, cs.getMax());
 273     cs.addElement(512);
 274     cs.addElement(513);
 275     assertEquals(513, cs.getMax());
 276
 277   }
 278
 279   @Test(groups = { "Functional" })
 280   public void testMinColumnSelection()
 281   {
 282     ColumnSelection cs = new ColumnSelection();
 283     cs.addElement(0);
 284     cs.addElement(513);
 285     cs.addElement(1);
 286     assertEquals(0, cs.getMin());
 287     cs.removeElement(0);
 288     assertEquals(1, cs.getMin());
 289     cs.addElement(0);
 290     assertEquals(0, cs.getMin());
 291   }
 292
 293   @Test(groups = { "Functional" })
 294   public void testEquals()
 295   {
 296     ColumnSelection cs = new ColumnSelection();
 297     cs.addElement(0);
 298     cs.addElement(513);
 299     cs.addElement(1);
 300
 301     // same selections added in a different order
 302     ColumnSelection cs2 = new ColumnSelection();
 303     cs2.addElement(1);
 304     cs2.addElement(513);
 305     cs2.addElement(0);
 306
 307     assertTrue(cs.equals(cs2));
 308     assertTrue(cs.equals(cs));
 309     assertTrue(cs2.equals(cs));
 310     assertTrue(cs2.equals(cs2));
 311
 312     cs2.addElement(12);
 313     assertFalse(cs.equals(cs2));
 314     assertFalse(cs2.equals(cs));
 315
 316     cs2.removeElement(12);
 317     assertTrue(cs.equals(cs2));
 318   }
 319
 320   /*
 321       cs2.hideSelectedColumns(88);
 322       assertFalse(cs.equals(cs2));
 323       /*
 324        * unhiding a column adds it to selection!
 325        */
 326   /*    cs2.revealHiddenColumns(88);
 327       assertFalse(cs.equals(cs2));
 328       cs.addElement(88);
 329       assertTrue(cs.equals(cs2));
 330     */
 331
 332   /**
 333    * Test the method that returns selected columns, in the order in which they
 334    * were added
 335    */
 336   @Test(groups = { "Functional" })
 337   public void testGetSelected()
 338   {
 339     ColumnSelection cs = new ColumnSelection();
 340     int[] sel = { 4, 3, 7, 21 };
 341     for (int col : sel)
 342     {
 343       cs.addElement(col);
 344     }
 345
 346     List<Integer> selected = cs.getSelected();
 347     assertEquals(4, selected.size());
 348     assertEquals("[4, 3, 7, 21]", selected.toString());
 349
 350     /*
 351      * getSelected returns a read-only view of the list
 352      * verify the view follows any changes in it
 353      */
 354     cs.removeElement(7);
 355     cs.addElement(1);
 356     cs.removeElement(4);
 357     assertEquals("[3, 21, 1]", selected.toString());
 358   }
 359
 360   /**
 361    * Test to verify that the list returned by getSelection cannot be modified
 362    */
 363   @Test(groups = { "Functional" })
 364   public void testGetSelected_isReadOnly()
 365   {
 366     ColumnSelection cs = new ColumnSelection();
 367     cs.addElement(3);
 368
 369     List<Integer> selected = cs.getSelected();
 370     try
 371     {
 372       selected.clear();
 373       fail("expected exception");
 374     } catch (UnsupportedOperationException e)
 375     {
 376       // expected
 377     }
 378     try
 379     {
 380       selected.add(1);
 381       fail("expected exception");
 382     } catch (UnsupportedOperationException e)
 383     {
 384       // expected
 385     }
 386     try
 387     {
 388       selected.remove(3);
 389       fail("expected exception");
 390     } catch (UnsupportedOperationException e)
 391     {
 392       // expected
 393     }
 394     try
 395     {
 396       Collections.sort(selected);
 397       fail("expected exception");
 398     } catch (UnsupportedOperationException e)
 399     {
 400       // expected
 401     }
 402   }
 403
 404   /**
 405    * Test that demonstrates a ConcurrentModificationException is thrown if you
 406    * change the selection while iterating over it
 407    */
 408   @Test(
 409     groups = "Functional",
 410     expectedExceptions = { ConcurrentModificationException.class })
 411   public void testGetSelected_concurrentModification()
 412   {
 413     ColumnSelection cs = new ColumnSelection();
 414     cs.addElement(0);
 415     cs.addElement(1);
 416     cs.addElement(2);
 417
 418     /*
 419      * simulate changing the list under us (e.g. in a separate
 420      * thread) while iterating over it -> ConcurrentModificationException
 421      */
 422     List<Integer> selected = cs.getSelected();
 423     for (Integer col : selected)
 424     {
 425       if (col.intValue() == 0)
 426       {
 427         cs.removeElement(1);
 428       }
 429     }
 430   }
 431
 432   @Test(groups = "Functional")
 433   public void testMarkColumns()
 434   {
 435     ColumnSelection cs = new ColumnSelection();
 436     cs.addElement(5); // this will be cleared
 437     BitSet toMark = new BitSet();
 438     toMark.set(1);
 439     toMark.set(3);
 440     toMark.set(6);
 441     toMark.set(9);
 442
 443     assertTrue(cs.markColumns(toMark, 3, 8, false, false, false));
 444     List<Integer> selected = cs.getSelected();
 445     assertEquals(2, selected.size());
 446     assertTrue(selected.contains(3));
 447     assertTrue(selected.contains(6));
 448   }
 449
 450   @Test(groups = "Functional")
 451   public void testMarkColumns_extend()
 452   {
 453     ColumnSelection cs = new ColumnSelection();
 454     cs.addElement(1);
 455     cs.addElement(5);
 456     BitSet toMark = new BitSet();
 457     toMark.set(1);
 458     toMark.set(3);
 459     toMark.set(6);
 460     toMark.set(9);
 461
 462     /*
 463      * extending selection of {3, 6} should leave {1, 3, 5, 6} selected
 464      */
 465     assertTrue(cs.markColumns(toMark, 3, 8, false, true, false));
 466     List<Integer> selected = cs.getSelected();
 467     assertEquals(4, selected.size());
 468     assertTrue(selected.contains(1));
 469     assertTrue(selected.contains(3));
 470     assertTrue(selected.contains(5));
 471     assertTrue(selected.contains(6));
 472   }
 473
 474   @Test(groups = "Functional")
 475   public void testMarkColumns_invert()
 476   {
 477     ColumnSelection cs = new ColumnSelection();
 478     cs.addElement(5); // this will be cleared
 479     BitSet toMark = new BitSet();
 480     toMark.set(1);
 481     toMark.set(3);
 482     toMark.set(6);
 483     toMark.set(9);
 484
 485     /*
 486      * inverted selection of {3, 6} should select {4, 5, 7, 8}
 487      */
 488     assertTrue(cs.markColumns(toMark, 3, 8, true, false, false));
 489     List<Integer> selected = cs.getSelected();
 490     assertEquals(4, selected.size());
 491     assertTrue(selected.contains(4));
 492     assertTrue(selected.contains(5));
 493     assertTrue(selected.contains(7));
 494     assertTrue(selected.contains(8));
 495   }
 496
 497   @Test(groups = "Functional")
 498   public void testMarkColumns_toggle()
 499   {
 500     ColumnSelection cs = new ColumnSelection();
 501     cs.addElement(1); // outside change range
 502     cs.addElement(3);
 503     cs.addElement(4);
 504     cs.addElement(10); // outside change range
 505     BitSet toMark = new BitSet();
 506     toMark.set(1);
 507     toMark.set(3);
 508     toMark.set(6);
 509     toMark.set(9);
 510
 511     /*
 512      * toggling state of {3, 6} should leave {1, 4, 6, 10} selected
 513      */
 514     assertTrue(cs.markColumns(toMark, 3, 8, false, false, true));
 515     List<Integer> selected = cs.getSelected();
 516     assertEquals(4, selected.size());
 517     assertTrue(selected.contains(1));
 518     assertTrue(selected.contains(4));
 519     assertTrue(selected.contains(6));
 520     assertTrue(selected.contains(10));
 521   }
 522
 523   @Test(groups = "Functional")
 524   public void testCopyConstructor()
 525   {
 526     ColumnSelection cs = new ColumnSelection();
 527     cs.addElement(3);
 528     cs.addElement(1);
 529
 530     ColumnSelection cs2 = new ColumnSelection(cs);
 531     assertTrue(cs2.hasSelectedColumns());
 532
 533     // order of column selection is preserved
 534     assertEquals("[3, 1]", cs2.getSelected().toString());
 535   }
 536
 537
 538   @Test(groups = { "Functional" })
 539   public void testStretchGroup_expand()
 540   {
 541     /*
 542      * test that emulates clicking column 4 (selected)
 543      * and dragging right to column 5 (all base 0)
 544      */
 545     ColumnSelection cs = new ColumnSelection();
 546     cs.addElement(4);
 547     SequenceGroup sg = new SequenceGroup();
 548     sg.setStartRes(4);
 549     sg.setEndRes(4);
 550     cs.stretchGroup(5, sg, 4, 4);
 551     assertEquals(cs.getSelected().size(), 2);
 552     assertTrue(cs.contains(4));
 553     assertTrue(cs.contains(5));
 554     assertEquals(sg.getStartRes(), 4);
 555     assertEquals(sg.getEndRes(), 5);
 556
 557     /*
 558      * emulate drag right with columns 10-20 already selected
 559      */
 560     cs.clear();
 561     for (int i = 10; i <= 20; i++)
 562     {
 563       cs.addElement(i);
 564     }
 565     assertEquals(cs.getSelected().size(), 11);
 566     sg = new SequenceGroup();
 567     sg.setStartRes(10);
 568     sg.setEndRes(20);
 569     cs.stretchGroup(21, sg, 10, 20);
 570     assertEquals(cs.getSelected().size(), 12);
 571     assertTrue(cs.contains(10));
 572     assertTrue(cs.contains(21));
 573     assertEquals(sg.getStartRes(), 10);
 574     assertEquals(sg.getEndRes(), 21);
 575   }
 576
 577   @Test(groups = { "Functional" })
 578   public void testStretchGroup_shrink()
 579   {
 580     /*
 581      * emulate drag left to 19 with columns 10-20 already selected
 582      */
 583     ColumnSelection cs = new ColumnSelection();
 584     for (int i = 10; i <= 20; i++)
 585     {
 586       cs.addElement(i);
 587     }
 588     assertEquals(cs.getSelected().size(), 11);
 589     SequenceGroup sg = new SequenceGroup();
 590     sg.setStartRes(10);
 591     sg.setEndRes(20);
 592     cs.stretchGroup(19, sg, 10, 20);
 593     assertEquals(cs.getSelected().size(), 10);
 594     assertTrue(cs.contains(10));
 595     assertTrue(cs.contains(19));
 596     assertFalse(cs.contains(20));
 597     assertEquals(sg.getStartRes(), 10);
 598     assertEquals(sg.getEndRes(), 19);
 599   }
 600 }