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 columns 1 and 2 moves column 5 to column 2
109 cs.hideColumns(1, 2);
110 assertEquals(2, cs.findColumnPosition(5));
114 * Test the code used to locate the reference sequence ruler origin
116 @Test(groups = { "Functional" })
117 public void testLocateVisibleBoundsofSequence()
119 ColumnSelection cs = new ColumnSelection();
120 SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
121 assertEquals(2, seq.findIndex(seq.getStart()));
125 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
126 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
127 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
128 seq.findIndex(seq.getEnd()) - 1 }),
129 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
131 // hidden column on gap after end of sequence - should not affect bounds
134 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
135 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
136 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
137 seq.findIndex(seq.getEnd()) - 1 }),
138 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
140 cs.revealAllHiddenColumns();
141 // hidden column on gap before beginning of sequence - should vis bounds by
145 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 2,
146 seq.findIndex(seq.getEnd()) - 2, seq.getStart(),
147 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
148 seq.findIndex(seq.getEnd()) - 1 }),
149 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
151 cs.revealAllHiddenColumns();
152 // hide columns around most of sequence - leave one residue remaining
153 cs.hideColumns(1, 3);
154 cs.hideColumns(6, 11);
156 cs.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]);
158 Arrays.toString(new int[] { 1, 1, 3, 3,
159 seq.findIndex(seq.getStart()) - 1,
160 seq.findIndex(seq.getEnd()) - 1 }),
161 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
162 cs.revealAllHiddenColumns();
164 // hide whole sequence - should just get location of hidden region
165 // containing sequence
166 cs.hideColumns(1, 11);
168 Arrays.toString(new int[] { 0, 1, 0, 0,
169 seq.findIndex(seq.getStart()) - 1,
170 seq.findIndex(seq.getEnd()) - 1 }),
171 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
175 @Test(groups = { "Functional" })
176 public void testLocateVisibleBoundsPathologicals()
178 // test some pathological cases we missed
179 AlignmentI al = new Alignment(new SequenceI[] { new Sequence(
180 "refseqGaptest", "KTDVTI----------NFI-----G----L") });
181 ColumnSelection cs = new ColumnSelection();
182 cs.hideInsertionsFor(al.getSequenceAt(0));
186 + al.getSequenceAt(0).getCharAt(
187 cs.adjustForHiddenColumns(9)));
191 @Test(groups = { "Functional" })
192 public void testHideColumns()
194 ColumnSelection cs = new ColumnSelection();
196 List<int[]> hidden = cs.getHiddenColumns();
197 assertEquals(1, hidden.size());
198 assertEquals("[5, 5]", Arrays.toString(hidden.get(0)));
201 assertEquals(2, hidden.size());
202 // two hidden ranges, in order:
203 assertSame(hidden, cs.getHiddenColumns());
204 assertEquals("[3, 3]", Arrays.toString(hidden.get(0)));
205 assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
207 // hiding column 4 expands [3, 3] to [3, 4]
208 // and merges to [5, 5] to make [3, 5]
210 hidden = cs.getHiddenColumns();
211 assertEquals(1, hidden.size());
212 assertEquals("[3, 5]", Arrays.toString(hidden.get(0)));
214 // clear hidden columns (note they are added to selected)
215 cs.revealAllHiddenColumns();
216 // it is now actually null but getter returns an empty list
217 assertTrue(cs.getHiddenColumns().isEmpty());
219 cs.hideColumns(3, 6);
220 hidden = cs.getHiddenColumns();
221 int[] firstHiddenRange = hidden.get(0);
222 assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
224 // adding a subrange of already hidden should do nothing
225 cs.hideColumns(4, 5);
226 assertEquals(1, hidden.size());
227 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
228 cs.hideColumns(3, 5);
229 assertEquals(1, hidden.size());
230 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
231 cs.hideColumns(4, 6);
232 assertEquals(1, hidden.size());
233 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
234 cs.hideColumns(3, 6);
235 assertEquals(1, hidden.size());
236 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
238 cs.revealAllHiddenColumns();
239 cs.hideColumns(2, 4);
240 hidden = cs.getHiddenColumns();
241 assertEquals(1, hidden.size());
242 assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
244 // extend contiguous with 2 positions overlap
245 cs.hideColumns(3, 5);
246 assertEquals(1, hidden.size());
247 assertEquals("[2, 5]", Arrays.toString(hidden.get(0)));
249 // extend contiguous with 1 position overlap
250 cs.hideColumns(5, 6);
251 assertEquals(1, hidden.size());
252 assertEquals("[2, 6]", Arrays.toString(hidden.get(0)));
254 // extend contiguous with overlap both ends:
255 cs.hideColumns(1, 7);
256 assertEquals(1, hidden.size());
257 assertEquals("[1, 7]", Arrays.toString(hidden.get(0)));
261 * Test the method that hides a specified column including any adjacent
262 * selected columns. This is a convenience method for the case where multiple
263 * column regions are selected and then hidden using menu option View | Hide |
266 @Test(groups = { "Functional" })
267 public void testHideColumns_withSelection()
269 ColumnSelection cs = new ColumnSelection();
270 // select columns 4-6
274 // hide column 5 (and adjacent):
277 List<int[]> hidden = cs.getHiddenColumns();
278 assertEquals(1, hidden.size());
279 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
280 // none now selected:
281 assertTrue(cs.getSelected().isEmpty());
283 // repeat, hiding column 4 (5 and 6)
284 cs = new ColumnSelection();
289 hidden = cs.getHiddenColumns();
290 assertEquals(1, hidden.size());
291 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
292 assertTrue(cs.getSelected().isEmpty());
294 // repeat, hiding column (4, 5 and) 6
295 cs = new ColumnSelection();
300 hidden = cs.getHiddenColumns();
301 assertEquals(1, hidden.size());
302 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
303 assertTrue(cs.getSelected().isEmpty());
305 // repeat, with _only_ adjacent columns selected
306 cs = new ColumnSelection();
310 hidden = cs.getHiddenColumns();
311 assertEquals(1, hidden.size());
312 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
313 assertTrue(cs.getSelected().isEmpty());
317 * Test the method that hides all (possibly disjoint) selected column ranges
319 @Test(groups = { "Functional" })
320 public void testHideSelectedColumns()
322 ColumnSelection cs = new ColumnSelection();
323 int[] sel = { 2, 3, 4, 7, 8, 9, 20, 21, 22 };
328 cs.hideColumns(15, 18);
330 cs.hideSelectedColumns();
331 assertTrue(cs.getSelected().isEmpty());
332 List<int[]> hidden = cs.getHiddenColumns();
333 assertEquals(4, hidden.size());
334 assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
335 assertEquals("[7, 9]", Arrays.toString(hidden.get(1)));
336 assertEquals("[15, 18]", Arrays.toString(hidden.get(2)));
337 assertEquals("[20, 22]", Arrays.toString(hidden.get(3)));
341 * Test the method that gets runs of selected columns ordered by column. If
342 * this fails, HideSelectedColumns may also fail
344 @Test(groups = { "Functional" })
345 public void testGetSelectedRanges()
348 * getSelectedRanges returns ordered columns regardless
349 * of the order in which they are added
351 ColumnSelection cs = new ColumnSelection();
352 int[] sel = { 4, 3, 7, 21, 9, 20, 8, 22, 2 };
358 range = cs.getSelectedRanges();
359 assertEquals(3, range.size());
360 assertEquals("[2, 4]", Arrays.toString(range.get(0)));
361 assertEquals("[7, 9]", Arrays.toString(range.get(1)));
362 assertEquals("[20, 22]", Arrays.toString(range.get(2)));
365 range = cs.getSelectedRanges();
366 assertEquals(3, range.size());
367 assertEquals("[0, 4]", Arrays.toString(range.get(0)));
371 * Test the method that reveals a range of hidden columns given the start
372 * column of the range
374 @Test(groups = { "Functional" })
375 public void testRevealHiddenColumns()
377 ColumnSelection cs = new ColumnSelection();
378 cs.hideColumns(5, 8);
380 cs.revealHiddenColumns(5);
381 // hidden columns list now null but getter returns empty list:
382 assertTrue(cs.getHiddenColumns().isEmpty());
383 // revealed columns are marked as selected (added to selection):
384 assertEquals("[10, 5, 6, 7, 8]", cs.getSelected().toString());
386 // calling with a column other than the range start does nothing:
387 cs = new ColumnSelection();
388 cs.hideColumns(5, 8);
389 List<int[]> hidden = cs.getHiddenColumns();
390 cs.revealHiddenColumns(6);
391 assertSame(hidden, cs.getHiddenColumns());
392 assertTrue(cs.getSelected().isEmpty());
395 @Test(groups = { "Functional" })
396 public void testRevealAllHiddenColumns()
398 ColumnSelection cs = new ColumnSelection();
399 cs.hideColumns(5, 8);
400 cs.hideColumns(2, 3);
403 cs.revealAllHiddenColumns();
406 * revealing hidden columns adds them (in order) to the (unordered)
409 assertTrue(cs.getHiddenColumns().isEmpty());
410 assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", cs.getSelected().toString());
413 @Test(groups = { "Functional" })
414 public void testIsVisible()
416 ColumnSelection cs = new ColumnSelection();
417 cs.hideColumns(2, 4);
418 cs.hideColumns(6, 7);
419 assertTrue(cs.isVisible(0));
420 assertTrue(cs.isVisible(-99));
421 assertTrue(cs.isVisible(1));
422 assertFalse(cs.isVisible(2));
423 assertFalse(cs.isVisible(3));
424 assertFalse(cs.isVisible(4));
425 assertTrue(cs.isVisible(5));
426 assertFalse(cs.isVisible(6));
427 assertFalse(cs.isVisible(7));
430 @Test(groups = { "Functional" })
431 public void testGetVisibleContigs()
433 ColumnSelection cs = new ColumnSelection();
434 cs.hideColumns(3, 6);
435 cs.hideColumns(8, 9);
436 cs.hideColumns(12, 12);
438 // start position is inclusive, end position exclusive:
439 int[] visible = cs.getVisibleContigs(1, 13);
440 assertEquals("[1, 2, 7, 7, 10, 11]", Arrays.toString(visible));
442 visible = cs.getVisibleContigs(4, 14);
443 assertEquals("[7, 7, 10, 11, 13, 13]", Arrays.toString(visible));
445 visible = cs.getVisibleContigs(3, 10);
446 assertEquals("[7, 7]", Arrays.toString(visible));
448 visible = cs.getVisibleContigs(4, 6);
449 assertEquals("[]", Arrays.toString(visible));
452 @Test(groups = { "Functional" })
453 public void testInvertColumnSelection()
455 ColumnSelection cs = new ColumnSelection();
459 cs.hideColumns(3, 3);
460 cs.hideColumns(6, 6);
462 // invert selection from start (inclusive) to end (exclusive)
463 // hidden columns are _not_ changed
464 cs.invertColumnSelection(2, 9);
465 assertEquals("[2, 5, 7]", cs.getSelected().toString());
467 cs.invertColumnSelection(1, 9);
468 assertEquals("[1, 4, 8]", cs.getSelected().toString());
471 @Test(groups = { "Functional" })
472 public void testMaxColumnSelection()
474 ColumnSelection cs = new ColumnSelection();
478 assertEquals(513, cs.getMax());
479 cs.removeElement(513);
480 assertEquals(1, cs.getMax());
482 assertEquals(0, cs.getMax());
485 assertEquals(513, cs.getMax());
489 @Test(groups = { "Functional" })
490 public void testMinColumnSelection()
492 ColumnSelection cs = new ColumnSelection();
496 assertEquals(0, cs.getMin());
498 assertEquals(1, cs.getMin());
500 assertEquals(0, cs.getMin());
503 @Test(groups = { "Functional" })
504 public void testEquals()
506 ColumnSelection cs = new ColumnSelection();
512 cs.hideColumns(5, 9);
514 // same selections added in a different order
515 ColumnSelection cs2 = new ColumnSelection();
520 // with no hidden columns
521 assertFalse(cs.equals(cs2));
522 assertFalse(cs2.equals(cs));
524 // with hidden columns added in a different order
525 cs2.hideColumns(6, 9);
526 cs2.hideColumns(5, 8);
529 assertTrue(cs.equals(cs2));
530 assertTrue(cs.equals(cs));
531 assertTrue(cs2.equals(cs));
532 assertTrue(cs2.equals(cs2));
535 assertFalse(cs.equals(cs2));
536 assertFalse(cs2.equals(cs));
538 cs2.removeElement(12);
539 assertTrue(cs.equals(cs2));
542 assertFalse(cs.equals(cs2));
544 * unhiding a column adds it to selection!
546 cs2.revealHiddenColumns(88);
547 assertFalse(cs.equals(cs2));
549 assertTrue(cs.equals(cs2));
553 * Test the method that returns selected columns, in the order in which they
556 @Test(groups = { "Functional" })
557 public void testGetSelected()
559 ColumnSelection cs = new ColumnSelection();
560 int[] sel = { 4, 3, 7, 21 };
566 List<Integer> selected = cs.getSelected();
567 assertEquals(4, selected.size());
568 assertEquals("[4, 3, 7, 21]", selected.toString());
571 * getSelected returns a read-only view of the list
572 * verify the view follows any changes in it
577 assertEquals("[3, 21, 1]", selected.toString());
581 * Test to verify that the list returned by getSelection cannot be modified
583 @Test(groups = { "Functional" })
584 public void testGetSelected_isReadOnly()
586 ColumnSelection cs = new ColumnSelection();
589 List<Integer> selected = cs.getSelected();
593 fail("expected exception");
594 } catch (UnsupportedOperationException e)
601 fail("expected exception");
602 } catch (UnsupportedOperationException e)
609 fail("expected exception");
610 } catch (UnsupportedOperationException e)
616 Collections.sort(selected);
617 fail("expected exception");
618 } catch (UnsupportedOperationException e)
625 * Test that demonstrates a ConcurrentModificationException is thrown if you
626 * change the selection while iterating over it
629 groups = "Functional",
630 expectedExceptions = { ConcurrentModificationException.class })
631 public void testGetSelected_concurrentModification()
633 ColumnSelection cs = new ColumnSelection();
639 * simulate changing the list under us (e.g. in a separate
640 * thread) while iterating over it -> ConcurrentModificationException
642 List<Integer> selected = cs.getSelected();
643 for (Integer col : selected)
645 if (col.intValue() == 0)
652 @Test(groups = "Functional")
653 public void testMarkColumns()
655 ColumnSelection cs = new ColumnSelection();
656 cs.addElement(5); // this will be cleared
657 BitSet toMark = new BitSet();
663 assertTrue(cs.markColumns(toMark, 3, 8, false, false, false));
664 List<Integer> selected = cs.getSelected();
665 assertEquals(2, selected.size());
666 assertTrue(selected.contains(3));
667 assertTrue(selected.contains(6));
670 @Test(groups = "Functional")
671 public void testMarkColumns_extend()
673 ColumnSelection cs = new ColumnSelection();
676 BitSet toMark = new BitSet();
683 * extending selection of {3, 6} should leave {1, 3, 5, 6} selected
685 assertTrue(cs.markColumns(toMark, 3, 8, false, true, false));
686 List<Integer> selected = cs.getSelected();
687 assertEquals(4, selected.size());
688 assertTrue(selected.contains(1));
689 assertTrue(selected.contains(3));
690 assertTrue(selected.contains(5));
691 assertTrue(selected.contains(6));
694 @Test(groups = "Functional")
695 public void testMarkColumns_invert()
697 ColumnSelection cs = new ColumnSelection();
698 cs.addElement(5); // this will be cleared
699 BitSet toMark = new BitSet();
706 * inverted selection of {3, 6} should select {4, 5, 7, 8}
708 assertTrue(cs.markColumns(toMark, 3, 8, true, false, false));
709 List<Integer> selected = cs.getSelected();
710 assertEquals(4, selected.size());
711 assertTrue(selected.contains(4));
712 assertTrue(selected.contains(5));
713 assertTrue(selected.contains(7));
714 assertTrue(selected.contains(8));
717 @Test(groups = "Functional")
718 public void testMarkColumns_toggle()
720 ColumnSelection cs = new ColumnSelection();
721 cs.addElement(1); // outside change range
724 cs.addElement(10); // outside change range
725 BitSet toMark = new BitSet();
732 * toggling state of {3, 6} should leave {1, 4, 6, 10} selected
734 assertTrue(cs.markColumns(toMark, 3, 8, false, false, true));
735 List<Integer> selected = cs.getSelected();
736 assertEquals(4, selected.size());
737 assertTrue(selected.contains(1));
738 assertTrue(selected.contains(4));
739 assertTrue(selected.contains(6));
740 assertTrue(selected.contains(10));
743 @Test(groups = "Functional")
744 public void testCopyConstructor()
746 ColumnSelection cs = new ColumnSelection();
749 cs.hideColumns(10, 11);
750 cs.hideColumns(5, 7);
751 assertEquals("[5, 7]", Arrays.toString(cs.getHiddenColumns().get(0)));
753 ColumnSelection cs2 = new ColumnSelection(cs);
754 assertTrue(cs2.hasSelectedColumns());
755 assertTrue(cs2.hasHiddenColumns());
756 // order of column selection is preserved
757 assertEquals("[3, 1]", cs2.getSelected().toString());
758 assertEquals(2, cs2.getHiddenColumns().size());
759 // hidden columns are held in column order
760 assertEquals("[5, 7]", Arrays.toString(cs2.getHiddenColumns().get(0)));
761 assertEquals("[10, 11]", Arrays.toString(cs2.getHiddenColumns().get(1)));
765 * Test for the case when a hidden range encloses more one already hidden
768 @Test(groups = { "Functional" })
769 public void testHideColumns_subsumingHidden()
772 * JAL-2370 bug scenario:
773 * two hidden ranges subsumed by a third
775 ColumnSelection cs = new ColumnSelection();
776 cs.hideColumns(49, 59);
777 cs.hideColumns(69, 79);
778 List<int[]> hidden = cs.getHiddenColumns();
779 assertEquals(2, hidden.size());
780 assertEquals("[49, 59]", Arrays.toString(hidden.get(0)));
781 assertEquals("[69, 79]", Arrays.toString(hidden.get(1)));
783 cs.hideColumns(48, 80);
784 hidden = cs.getHiddenColumns();
785 assertEquals(1, hidden.size());
786 assertEquals("[48, 80]", Arrays.toString(hidden.get(0)));
789 * another...joining hidden ranges
791 cs = new ColumnSelection();
792 cs.hideColumns(10, 20);
793 cs.hideColumns(30, 40);
794 cs.hideColumns(50, 60);
795 // hiding 21-49 should merge to one range
796 cs.hideColumns(21, 49);
797 hidden = cs.getHiddenColumns();
798 assertEquals(1, hidden.size());
799 assertEquals("[10, 60]", Arrays.toString(hidden.get(0)));
802 * another...lef overlap, subsumption, right overlap,
803 * no overlap of existing hidden ranges
805 cs = new ColumnSelection();
806 cs.hideColumns(10, 20);
807 cs.hideColumns(10, 20);
808 cs.hideColumns(30, 35);
809 cs.hideColumns(40, 50);
810 cs.hideColumns(60, 70);
812 cs.hideColumns(15, 45);
813 hidden = cs.getHiddenColumns();
814 assertEquals(2, hidden.size());
815 assertEquals("[10, 50]", Arrays.toString(hidden.get(0)));
816 assertEquals("[60, 70]", Arrays.toString(hidden.get(1)));
819 @Test(groups = { "Functional" })
820 public void testStretchGroup_expand()
823 * test that emulates clicking column 4 (selected)
824 * and dragging right to column 5 (all base 0)
826 ColumnSelection cs = new ColumnSelection();
828 SequenceGroup sg = new SequenceGroup();
831 cs.stretchGroup(5, sg, 4, 4);
832 assertEquals(cs.getSelected().size(), 2);
833 assertTrue(cs.contains(4));
834 assertTrue(cs.contains(5));
835 assertEquals(sg.getStartRes(), 4);
836 assertEquals(sg.getEndRes(), 5);
839 * emulate drag right with columns 10-20 already selected
842 for (int i = 10; i <= 20; i++)
846 assertEquals(cs.getSelected().size(), 11);
847 sg = new SequenceGroup();
850 cs.stretchGroup(21, sg, 10, 20);
851 assertEquals(cs.getSelected().size(), 12);
852 assertTrue(cs.contains(10));
853 assertTrue(cs.contains(21));
854 assertEquals(sg.getStartRes(), 10);
855 assertEquals(sg.getEndRes(), 21);
858 @Test(groups = { "Functional" })
859 public void testStretchGroup_shrink()
862 * emulate drag left to 19 with columns 10-20 already selected
864 ColumnSelection cs = new ColumnSelection();
865 for (int i = 10; i <= 20; i++)
869 assertEquals(cs.getSelected().size(), 11);
870 SequenceGroup sg = new SequenceGroup();
873 cs.stretchGroup(19, sg, 10, 20);
874 assertEquals(cs.getSelected().size(), 10);
875 assertTrue(cs.contains(10));
876 assertTrue(cs.contains(19));
877 assertFalse(cs.contains(20));
878 assertEquals(sg.getStartRes(), 10);
879 assertEquals(sg.getEndRes(), 19);