2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
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.
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.
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.
21 package jalview.datamodel;
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 import static org.testng.AssertJUnit.fail;
29 import jalview.gui.JvOptionPane;
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;
37 import org.testng.annotations.BeforeClass;
38 import org.testng.annotations.Test;
40 public class ColumnSelectionTest
43 @BeforeClass(alwaysRun = true)
44 public void setUpJvOptionPane()
46 JvOptionPane.setInteractiveMode(false);
47 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
50 @Test(groups = { "Functional" })
51 public void testAddElement()
53 ColumnSelection cs = new ColumnSelection();
57 cs.addElement(5); // ignored
58 List<Integer> sel = cs.getSelected();
59 assertEquals("[2, 5, 3]", sel.toString());
63 * Test the remove method - in particular to verify that remove(int i) removes
64 * the element whose value is i, _NOT_ the i'th element.
66 @Test(groups = { "Functional" })
67 public void testRemoveElement()
69 ColumnSelection cs = new ColumnSelection();
73 // removing elements not in the list has no effect
76 List<Integer> sel = cs.getSelected();
77 assertEquals(2, sel.size());
78 assertEquals(new Integer(2), sel.get(0));
79 assertEquals(new Integer(5), sel.get(1));
81 // removing an element in the list removes it
83 // ...and also from the read-only view
84 assertEquals(1, sel.size());
85 sel = cs.getSelected();
86 assertEquals(1, sel.size());
87 assertEquals(new Integer(5), sel.get(0));
91 * Test the method that finds the visible column position of an alignment
92 * column, allowing for hidden columns.
94 @Test(groups = { "Functional" })
95 public void testFindColumnPosition()
97 ColumnSelection cs = new ColumnSelection();
98 assertEquals(5, cs.findColumnPosition(5));
100 // hiding column 6 makes no difference
101 cs.hideColumns(6, 6);
102 assertEquals(5, cs.findColumnPosition(5));
104 // hiding column 4 moves column 5 to column 4
105 cs.hideColumns(4, 4);
106 assertEquals(4, cs.findColumnPosition(5));
108 // hiding column 4 moves column 4 to position 3
109 assertEquals(3, cs.findColumnPosition(4));
111 // hiding columns 1 and 2 moves column 5 to column 2
112 cs.hideColumns(1, 2);
113 assertEquals(2, cs.findColumnPosition(5));
115 // check with > 1 hidden column regions
116 // where some columns are in the hidden regions
117 ColumnSelection cs2 = new ColumnSelection();
118 cs2.hideColumns(5, 10);
119 cs2.hideColumns(20, 27);
120 cs2.hideColumns(40, 44);
122 // hiding columns 5-10 and 20-27 moves column 8 to column 4
123 assertEquals(4, cs2.findColumnPosition(8));
125 // and moves column 24 to 13
126 assertEquals(13, cs2.findColumnPosition(24));
128 // and moves column 28 to 14
129 assertEquals(14, cs2.findColumnPosition(28));
131 // and moves column 40 to 25
132 assertEquals(25, cs2.findColumnPosition(40));
134 // check when hidden columns start at 0 that the visible column
136 ColumnSelection cs3 = new ColumnSelection();
137 cs3.hideColumns(0, 4);
138 assertEquals(0, cs3.findColumnPosition(2));
143 * Test the code used to locate the reference sequence ruler origin
145 @Test(groups = { "Functional" })
146 public void testLocateVisibleBoundsofSequence()
148 ColumnSelection cs = new ColumnSelection();
149 SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
150 assertEquals(2, seq.findIndex(seq.getStart()));
154 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
155 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
156 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
157 seq.findIndex(seq.getEnd()) - 1 }),
158 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
160 // hidden column on gap after end of sequence - should not affect bounds
163 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
164 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
165 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
166 seq.findIndex(seq.getEnd()) - 1 }),
167 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
169 cs.revealAllHiddenColumns();
170 // hidden column on gap before beginning of sequence - should vis bounds by
174 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 2,
175 seq.findIndex(seq.getEnd()) - 2, seq.getStart(),
176 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
177 seq.findIndex(seq.getEnd()) - 1 }),
178 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
180 cs.revealAllHiddenColumns();
181 // hide columns around most of sequence - leave one residue remaining
182 cs.hideColumns(1, 3);
183 cs.hideColumns(6, 11);
185 cs.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]);
187 Arrays.toString(new int[] { 1, 1, 3, 3,
188 seq.findIndex(seq.getStart()) - 1,
189 seq.findIndex(seq.getEnd()) - 1 }),
190 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
191 cs.revealAllHiddenColumns();
193 // hide whole sequence - should just get location of hidden region
194 // containing sequence
195 cs.hideColumns(1, 11);
197 Arrays.toString(new int[] { 0, 1, 0, 0,
198 seq.findIndex(seq.getStart()) - 1,
199 seq.findIndex(seq.getEnd()) - 1 }),
200 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
204 @Test(groups = { "Functional" })
205 public void testLocateVisibleBoundsPathologicals()
207 // test some pathological cases we missed
208 AlignmentI al = new Alignment(new SequenceI[] { new Sequence(
209 "refseqGaptest", "KTDVTI----------NFI-----G----L") });
210 ColumnSelection cs = new ColumnSelection();
211 cs.hideInsertionsFor(al.getSequenceAt(0));
215 + al.getSequenceAt(0).getCharAt(
216 cs.adjustForHiddenColumns(9)));
220 @Test(groups = { "Functional" })
221 public void testHideColumns()
223 ColumnSelection cs = new ColumnSelection();
225 List<int[]> hidden = cs.getHiddenColumns();
226 assertEquals(1, hidden.size());
227 assertEquals("[5, 5]", Arrays.toString(hidden.get(0)));
230 assertEquals(2, hidden.size());
231 // two hidden ranges, in order:
232 assertSame(hidden, cs.getHiddenColumns());
233 assertEquals("[3, 3]", Arrays.toString(hidden.get(0)));
234 assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
236 // hiding column 4 expands [3, 3] to [3, 4]
237 // and merges to [5, 5] to make [3, 5]
239 hidden = cs.getHiddenColumns();
240 assertEquals(1, hidden.size());
241 assertEquals("[3, 5]", Arrays.toString(hidden.get(0)));
243 // clear hidden columns (note they are added to selected)
244 cs.revealAllHiddenColumns();
245 // it is now actually null but getter returns an empty list
246 assertTrue(cs.getHiddenColumns().isEmpty());
248 cs.hideColumns(3, 6);
249 hidden = cs.getHiddenColumns();
250 int[] firstHiddenRange = hidden.get(0);
251 assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
253 // adding a subrange of already hidden should do nothing
254 cs.hideColumns(4, 5);
255 assertEquals(1, hidden.size());
256 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
257 cs.hideColumns(3, 5);
258 assertEquals(1, hidden.size());
259 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
260 cs.hideColumns(4, 6);
261 assertEquals(1, hidden.size());
262 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
263 cs.hideColumns(3, 6);
264 assertEquals(1, hidden.size());
265 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
267 cs.revealAllHiddenColumns();
268 cs.hideColumns(2, 4);
269 hidden = cs.getHiddenColumns();
270 assertEquals(1, hidden.size());
271 assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
273 // extend contiguous with 2 positions overlap
274 cs.hideColumns(3, 5);
275 assertEquals(1, hidden.size());
276 assertEquals("[2, 5]", Arrays.toString(hidden.get(0)));
278 // extend contiguous with 1 position overlap
279 cs.hideColumns(5, 6);
280 assertEquals(1, hidden.size());
281 assertEquals("[2, 6]", Arrays.toString(hidden.get(0)));
283 // extend contiguous with overlap both ends:
284 cs.hideColumns(1, 7);
285 assertEquals(1, hidden.size());
286 assertEquals("[1, 7]", Arrays.toString(hidden.get(0)));
290 * Test the method that hides a specified column including any adjacent
291 * selected columns. This is a convenience method for the case where multiple
292 * column regions are selected and then hidden using menu option View | Hide |
295 @Test(groups = { "Functional" })
296 public void testHideColumns_withSelection()
298 ColumnSelection cs = new ColumnSelection();
299 // select columns 4-6
303 // hide column 5 (and adjacent):
306 List<int[]> hidden = cs.getHiddenColumns();
307 assertEquals(1, hidden.size());
308 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
309 // none now selected:
310 assertTrue(cs.getSelected().isEmpty());
312 // repeat, hiding column 4 (5 and 6)
313 cs = new ColumnSelection();
318 hidden = cs.getHiddenColumns();
319 assertEquals(1, hidden.size());
320 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
321 assertTrue(cs.getSelected().isEmpty());
323 // repeat, hiding column (4, 5 and) 6
324 cs = new ColumnSelection();
329 hidden = cs.getHiddenColumns();
330 assertEquals(1, hidden.size());
331 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
332 assertTrue(cs.getSelected().isEmpty());
334 // repeat, with _only_ adjacent columns selected
335 cs = new ColumnSelection();
339 hidden = cs.getHiddenColumns();
340 assertEquals(1, hidden.size());
341 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
342 assertTrue(cs.getSelected().isEmpty());
346 * Test the method that hides all (possibly disjoint) selected column ranges
348 @Test(groups = { "Functional" })
349 public void testHideSelectedColumns()
351 ColumnSelection cs = new ColumnSelection();
352 int[] sel = { 2, 3, 4, 7, 8, 9, 20, 21, 22 };
357 cs.hideColumns(15, 18);
359 cs.hideSelectedColumns();
360 assertTrue(cs.getSelected().isEmpty());
361 List<int[]> hidden = cs.getHiddenColumns();
362 assertEquals(4, hidden.size());
363 assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
364 assertEquals("[7, 9]", Arrays.toString(hidden.get(1)));
365 assertEquals("[15, 18]", Arrays.toString(hidden.get(2)));
366 assertEquals("[20, 22]", Arrays.toString(hidden.get(3)));
370 * Test the method that gets runs of selected columns ordered by column. If
371 * this fails, HideSelectedColumns may also fail
373 @Test(groups = { "Functional" })
374 public void testGetSelectedRanges()
377 * getSelectedRanges returns ordered columns regardless
378 * of the order in which they are added
380 ColumnSelection cs = new ColumnSelection();
381 int[] sel = { 4, 3, 7, 21, 9, 20, 8, 22, 2 };
387 range = cs.getSelectedRanges();
388 assertEquals(3, range.size());
389 assertEquals("[2, 4]", Arrays.toString(range.get(0)));
390 assertEquals("[7, 9]", Arrays.toString(range.get(1)));
391 assertEquals("[20, 22]", Arrays.toString(range.get(2)));
394 range = cs.getSelectedRanges();
395 assertEquals(3, range.size());
396 assertEquals("[0, 4]", Arrays.toString(range.get(0)));
400 * Test the method that reveals a range of hidden columns given the start
401 * column of the range
403 @Test(groups = { "Functional" })
404 public void testRevealHiddenColumns()
406 ColumnSelection cs = new ColumnSelection();
407 cs.hideColumns(5, 8);
409 cs.revealHiddenColumns(5);
410 // hidden columns list now null but getter returns empty list:
411 assertTrue(cs.getHiddenColumns().isEmpty());
412 // revealed columns are marked as selected (added to selection):
413 assertEquals("[10, 5, 6, 7, 8]", cs.getSelected().toString());
415 // calling with a column other than the range start does nothing:
416 cs = new ColumnSelection();
417 cs.hideColumns(5, 8);
418 List<int[]> hidden = cs.getHiddenColumns();
419 cs.revealHiddenColumns(6);
420 assertSame(hidden, cs.getHiddenColumns());
421 assertTrue(cs.getSelected().isEmpty());
424 @Test(groups = { "Functional" })
425 public void testRevealAllHiddenColumns()
427 ColumnSelection cs = new ColumnSelection();
428 cs.hideColumns(5, 8);
429 cs.hideColumns(2, 3);
432 cs.revealAllHiddenColumns();
435 * revealing hidden columns adds them (in order) to the (unordered)
438 assertTrue(cs.getHiddenColumns().isEmpty());
439 assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", cs.getSelected().toString());
442 @Test(groups = { "Functional" })
443 public void testIsVisible()
445 ColumnSelection cs = new ColumnSelection();
446 cs.hideColumns(2, 4);
447 cs.hideColumns(6, 7);
448 assertTrue(cs.isVisible(0));
449 assertTrue(cs.isVisible(-99));
450 assertTrue(cs.isVisible(1));
451 assertFalse(cs.isVisible(2));
452 assertFalse(cs.isVisible(3));
453 assertFalse(cs.isVisible(4));
454 assertTrue(cs.isVisible(5));
455 assertFalse(cs.isVisible(6));
456 assertFalse(cs.isVisible(7));
459 @Test(groups = { "Functional" })
460 public void testGetVisibleContigs()
462 ColumnSelection cs = new ColumnSelection();
463 cs.hideColumns(3, 6);
464 cs.hideColumns(8, 9);
465 cs.hideColumns(12, 12);
467 // start position is inclusive, end position exclusive:
468 int[] visible = cs.getVisibleContigs(1, 13);
469 assertEquals("[1, 2, 7, 7, 10, 11]", Arrays.toString(visible));
471 visible = cs.getVisibleContigs(4, 14);
472 assertEquals("[7, 7, 10, 11, 13, 13]", Arrays.toString(visible));
474 visible = cs.getVisibleContigs(3, 10);
475 assertEquals("[7, 7]", Arrays.toString(visible));
477 visible = cs.getVisibleContigs(4, 6);
478 assertEquals("[]", Arrays.toString(visible));
481 @Test(groups = { "Functional" })
482 public void testInvertColumnSelection()
484 ColumnSelection cs = new ColumnSelection();
488 cs.hideColumns(3, 3);
489 cs.hideColumns(6, 6);
491 // invert selection from start (inclusive) to end (exclusive)
492 // hidden columns are _not_ changed
493 cs.invertColumnSelection(2, 9);
494 assertEquals("[2, 5, 7]", cs.getSelected().toString());
496 cs.invertColumnSelection(1, 9);
497 assertEquals("[1, 4, 8]", cs.getSelected().toString());
500 @Test(groups = { "Functional" })
501 public void testMaxColumnSelection()
503 ColumnSelection cs = new ColumnSelection();
507 assertEquals(513, cs.getMax());
508 cs.removeElement(513);
509 assertEquals(1, cs.getMax());
511 assertEquals(0, cs.getMax());
514 assertEquals(513, cs.getMax());
518 @Test(groups = { "Functional" })
519 public void testMinColumnSelection()
521 ColumnSelection cs = new ColumnSelection();
525 assertEquals(0, cs.getMin());
527 assertEquals(1, cs.getMin());
529 assertEquals(0, cs.getMin());
532 @Test(groups = { "Functional" })
533 public void testEquals()
535 ColumnSelection cs = new ColumnSelection();
541 cs.hideColumns(5, 9);
543 // same selections added in a different order
544 ColumnSelection cs2 = new ColumnSelection();
549 // with no hidden columns
550 assertFalse(cs.equals(cs2));
551 assertFalse(cs2.equals(cs));
553 // with hidden columns added in a different order
554 cs2.hideColumns(6, 9);
555 cs2.hideColumns(5, 8);
558 assertTrue(cs.equals(cs2));
559 assertTrue(cs.equals(cs));
560 assertTrue(cs2.equals(cs));
561 assertTrue(cs2.equals(cs2));
564 assertFalse(cs.equals(cs2));
565 assertFalse(cs2.equals(cs));
567 cs2.removeElement(12);
568 assertTrue(cs.equals(cs2));
571 assertFalse(cs.equals(cs2));
573 * unhiding a column adds it to selection!
575 cs2.revealHiddenColumns(88);
576 assertFalse(cs.equals(cs2));
578 assertTrue(cs.equals(cs2));
582 * Test the method that returns selected columns, in the order in which they
585 @Test(groups = { "Functional" })
586 public void testGetSelected()
588 ColumnSelection cs = new ColumnSelection();
589 int[] sel = { 4, 3, 7, 21 };
595 List<Integer> selected = cs.getSelected();
596 assertEquals(4, selected.size());
597 assertEquals("[4, 3, 7, 21]", selected.toString());
600 * getSelected returns a read-only view of the list
601 * verify the view follows any changes in it
606 assertEquals("[3, 21, 1]", selected.toString());
610 * Test to verify that the list returned by getSelection cannot be modified
612 @Test(groups = { "Functional" })
613 public void testGetSelected_isReadOnly()
615 ColumnSelection cs = new ColumnSelection();
618 List<Integer> selected = cs.getSelected();
622 fail("expected exception");
623 } catch (UnsupportedOperationException e)
630 fail("expected exception");
631 } catch (UnsupportedOperationException e)
638 fail("expected exception");
639 } catch (UnsupportedOperationException e)
645 Collections.sort(selected);
646 fail("expected exception");
647 } catch (UnsupportedOperationException e)
654 * Test that demonstrates a ConcurrentModificationException is thrown if you
655 * change the selection while iterating over it
658 groups = "Functional",
659 expectedExceptions = { ConcurrentModificationException.class })
660 public void testGetSelected_concurrentModification()
662 ColumnSelection cs = new ColumnSelection();
668 * simulate changing the list under us (e.g. in a separate
669 * thread) while iterating over it -> ConcurrentModificationException
671 List<Integer> selected = cs.getSelected();
672 for (Integer col : selected)
674 if (col.intValue() == 0)
681 @Test(groups = "Functional")
682 public void testMarkColumns()
684 ColumnSelection cs = new ColumnSelection();
685 cs.addElement(5); // this will be cleared
686 BitSet toMark = new BitSet();
692 assertTrue(cs.markColumns(toMark, 3, 8, false, false, false));
693 List<Integer> selected = cs.getSelected();
694 assertEquals(2, selected.size());
695 assertTrue(selected.contains(3));
696 assertTrue(selected.contains(6));
699 @Test(groups = "Functional")
700 public void testMarkColumns_extend()
702 ColumnSelection cs = new ColumnSelection();
705 BitSet toMark = new BitSet();
712 * extending selection of {3, 6} should leave {1, 3, 5, 6} selected
714 assertTrue(cs.markColumns(toMark, 3, 8, false, true, false));
715 List<Integer> selected = cs.getSelected();
716 assertEquals(4, selected.size());
717 assertTrue(selected.contains(1));
718 assertTrue(selected.contains(3));
719 assertTrue(selected.contains(5));
720 assertTrue(selected.contains(6));
723 @Test(groups = "Functional")
724 public void testMarkColumns_invert()
726 ColumnSelection cs = new ColumnSelection();
727 cs.addElement(5); // this will be cleared
728 BitSet toMark = new BitSet();
735 * inverted selection of {3, 6} should select {4, 5, 7, 8}
737 assertTrue(cs.markColumns(toMark, 3, 8, true, false, false));
738 List<Integer> selected = cs.getSelected();
739 assertEquals(4, selected.size());
740 assertTrue(selected.contains(4));
741 assertTrue(selected.contains(5));
742 assertTrue(selected.contains(7));
743 assertTrue(selected.contains(8));
746 @Test(groups = "Functional")
747 public void testMarkColumns_toggle()
749 ColumnSelection cs = new ColumnSelection();
750 cs.addElement(1); // outside change range
753 cs.addElement(10); // outside change range
754 BitSet toMark = new BitSet();
761 * toggling state of {3, 6} should leave {1, 4, 6, 10} selected
763 assertTrue(cs.markColumns(toMark, 3, 8, false, false, true));
764 List<Integer> selected = cs.getSelected();
765 assertEquals(4, selected.size());
766 assertTrue(selected.contains(1));
767 assertTrue(selected.contains(4));
768 assertTrue(selected.contains(6));
769 assertTrue(selected.contains(10));
772 @Test(groups = "Functional")
773 public void testCopyConstructor()
775 ColumnSelection cs = new ColumnSelection();
778 cs.hideColumns(10, 11);
779 cs.hideColumns(5, 7);
780 assertEquals("[5, 7]", Arrays.toString(cs.getHiddenColumns().get(0)));
782 ColumnSelection cs2 = new ColumnSelection(cs);
783 assertTrue(cs2.hasSelectedColumns());
784 assertTrue(cs2.hasHiddenColumns());
785 // order of column selection is preserved
786 assertEquals("[3, 1]", cs2.getSelected().toString());
787 assertEquals(2, cs2.getHiddenColumns().size());
788 // hidden columns are held in column order
789 assertEquals("[5, 7]", Arrays.toString(cs2.getHiddenColumns().get(0)));
790 assertEquals("[10, 11]", Arrays.toString(cs2.getHiddenColumns().get(1)));
794 * Test for the case when a hidden range encloses more one already hidden
797 @Test(groups = { "Functional" })
798 public void testHideColumns_subsumingHidden()
801 * JAL-2370 bug scenario:
802 * two hidden ranges subsumed by a third
804 ColumnSelection cs = new ColumnSelection();
805 cs.hideColumns(49, 59);
806 cs.hideColumns(69, 79);
807 List<int[]> hidden = cs.getHiddenColumns();
808 assertEquals(2, hidden.size());
809 assertEquals("[49, 59]", Arrays.toString(hidden.get(0)));
810 assertEquals("[69, 79]", Arrays.toString(hidden.get(1)));
812 cs.hideColumns(48, 80);
813 hidden = cs.getHiddenColumns();
814 assertEquals(1, hidden.size());
815 assertEquals("[48, 80]", Arrays.toString(hidden.get(0)));
818 * another...joining hidden ranges
820 cs = new ColumnSelection();
821 cs.hideColumns(10, 20);
822 cs.hideColumns(30, 40);
823 cs.hideColumns(50, 60);
824 // hiding 21-49 should merge to one range
825 cs.hideColumns(21, 49);
826 hidden = cs.getHiddenColumns();
827 assertEquals(1, hidden.size());
828 assertEquals("[10, 60]", Arrays.toString(hidden.get(0)));
831 * another...lef overlap, subsumption, right overlap,
832 * no overlap of existing hidden ranges
834 cs = new ColumnSelection();
835 cs.hideColumns(10, 20);
836 cs.hideColumns(10, 20);
837 cs.hideColumns(30, 35);
838 cs.hideColumns(40, 50);
839 cs.hideColumns(60, 70);
841 cs.hideColumns(15, 45);
842 hidden = cs.getHiddenColumns();
843 assertEquals(2, hidden.size());
844 assertEquals("[10, 50]", Arrays.toString(hidden.get(0)));
845 assertEquals("[60, 70]", Arrays.toString(hidden.get(1)));
848 @Test(groups = { "Functional" })
849 public void testStretchGroup_expand()
852 * test that emulates clicking column 4 (selected)
853 * and dragging right to column 5 (all base 0)
855 ColumnSelection cs = new ColumnSelection();
857 SequenceGroup sg = new SequenceGroup();
860 cs.stretchGroup(5, sg, 4, 4);
861 assertEquals(cs.getSelected().size(), 2);
862 assertTrue(cs.contains(4));
863 assertTrue(cs.contains(5));
864 assertEquals(sg.getStartRes(), 4);
865 assertEquals(sg.getEndRes(), 5);
868 * emulate drag right with columns 10-20 already selected
871 for (int i = 10; i <= 20; i++)
875 assertEquals(cs.getSelected().size(), 11);
876 sg = new SequenceGroup();
879 cs.stretchGroup(21, sg, 10, 20);
880 assertEquals(cs.getSelected().size(), 12);
881 assertTrue(cs.contains(10));
882 assertTrue(cs.contains(21));
883 assertEquals(sg.getStartRes(), 10);
884 assertEquals(sg.getEndRes(), 21);
887 @Test(groups = { "Functional" })
888 public void testStretchGroup_shrink()
891 * emulate drag left to 19 with columns 10-20 already selected
893 ColumnSelection cs = new ColumnSelection();
894 for (int i = 10; i <= 20; i++)
898 assertEquals(cs.getSelected().size(), 11);
899 SequenceGroup sg = new SequenceGroup();
902 cs.stretchGroup(19, sg, 10, 20);
903 assertEquals(cs.getSelected().size(), 10);
904 assertTrue(cs.contains(10));
905 assertTrue(cs.contains(19));
906 assertFalse(cs.contains(20));
907 assertEquals(sg.getStartRes(), 10);
908 assertEquals(sg.getEndRes(), 19);