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;
28 import java.util.Arrays;
29 import java.util.List;
31 import org.testng.annotations.Test;
33 public class ColumnSelectionTest
36 @Test(groups = { "Functional" })
37 public void testAddElement()
39 ColumnSelection cs = new ColumnSelection();
43 cs.addElement(5); // ignored
44 List<Integer> sel = cs.getSelected();
45 assertEquals("[2, 5, 3]", sel.toString());
49 * Test the remove method - in particular to verify that remove(int i) removes
50 * the element whose value is i, _NOT_ the i'th element.
52 @Test(groups = { "Functional" })
53 public void testRemoveElement()
55 ColumnSelection cs = new ColumnSelection();
59 // removing elements not in the list has no effect
62 List<Integer> sel = cs.getSelected();
63 assertEquals(2, sel.size());
64 assertEquals(new Integer(2), sel.get(0));
65 assertEquals(new Integer(5), sel.get(1));
67 // removing an element in the list removes it
69 assertEquals(1, sel.size());
70 assertEquals(new Integer(5), sel.get(0));
74 * Test the method that finds the visible column position of an alignment
75 * column, allowing for hidden columns.
77 @Test(groups = { "Functional" })
78 public void testFindColumnPosition()
80 ColumnSelection cs = new ColumnSelection();
81 assertEquals(5, cs.findColumnPosition(5));
83 // hiding column 6 makes no difference
85 assertEquals(5, cs.findColumnPosition(5));
87 // hiding column 4 moves column 5 to column 4
89 assertEquals(4, cs.findColumnPosition(5));
91 // hiding columns 1 and 2 moves column 5 to column 2
93 assertEquals(2, cs.findColumnPosition(5));
96 @Test(groups = { "Functional" })
97 public void testHideColumns()
99 ColumnSelection cs = new ColumnSelection();
101 List<int[]> hidden = cs.getHiddenColumns();
102 assertEquals(1, hidden.size());
103 assertEquals("[5, 5]", Arrays.toString(hidden.get(0)));
106 assertEquals(2, hidden.size());
107 // two hidden ranges, in order:
108 assertSame(hidden, cs.getHiddenColumns());
109 assertEquals("[3, 3]", Arrays.toString(hidden.get(0)));
110 assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
112 // hiding column 4 expands [3, 3] to [3, 4]
113 // not fancy enough to coalesce this into [3, 5] though
115 hidden = cs.getHiddenColumns();
116 assertEquals(2, hidden.size());
117 assertEquals("[3, 4]", Arrays.toString(hidden.get(0)));
118 assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
120 // clear hidden columns (note they are added to selected)
121 cs.revealAllHiddenColumns();
122 // it is now actually null but getter returns an empty list
123 assertTrue(cs.getHiddenColumns().isEmpty());
125 cs.hideColumns(3, 6);
126 hidden = cs.getHiddenColumns();
127 int[] firstHiddenRange = hidden.get(0);
128 assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
130 // adding a subrange of already hidden should do nothing
131 cs.hideColumns(4, 5);
132 assertEquals(1, hidden.size());
133 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
134 cs.hideColumns(3, 5);
135 assertEquals(1, hidden.size());
136 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
137 cs.hideColumns(4, 6);
138 assertEquals(1, hidden.size());
139 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
140 cs.hideColumns(3, 6);
141 assertEquals(1, hidden.size());
142 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
144 cs.revealAllHiddenColumns();
145 cs.hideColumns(2, 4);
146 hidden = cs.getHiddenColumns();
147 assertEquals(1, hidden.size());
148 assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
150 // extend contiguous with 2 positions overlap
151 cs.hideColumns(3, 5);
152 assertEquals(1, hidden.size());
153 assertEquals("[2, 5]", Arrays.toString(hidden.get(0)));
155 // extend contiguous with 1 position overlap
156 cs.hideColumns(5, 6);
157 assertEquals(1, hidden.size());
158 assertEquals("[2, 6]", Arrays.toString(hidden.get(0)));
160 // extend contiguous with overlap both ends:
161 cs.hideColumns(1, 7);
162 assertEquals(1, hidden.size());
163 assertEquals("[1, 7]", Arrays.toString(hidden.get(0)));
167 * Test the method that hides a specified column including any adjacent
168 * selected columns. This is a convenience method for the case where multiple
169 * column regions are selected and then hidden using menu option View | Hide |
172 @Test(groups = { "Functional" })
173 public void testHideColumns_withSelection()
175 ColumnSelection cs = new ColumnSelection();
176 // select columns 4-6
180 // hide column 5 (and adjacent):
183 List<int[]> hidden = cs.getHiddenColumns();
184 assertEquals(1, hidden.size());
185 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
186 // none now selected:
187 assertTrue(cs.getSelected().isEmpty());
189 // repeat, hiding column 4 (5 and 6)
190 cs = new ColumnSelection();
195 hidden = cs.getHiddenColumns();
196 assertEquals(1, hidden.size());
197 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
198 assertTrue(cs.getSelected().isEmpty());
200 // repeat, hiding column (4, 5 and) 6
201 cs = new ColumnSelection();
206 hidden = cs.getHiddenColumns();
207 assertEquals(1, hidden.size());
208 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
209 assertTrue(cs.getSelected().isEmpty());
211 // repeat, with _only_ adjacent columns selected
212 cs = new ColumnSelection();
216 hidden = cs.getHiddenColumns();
217 assertEquals(1, hidden.size());
218 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
219 assertTrue(cs.getSelected().isEmpty());
223 * Test the method that hides all (possibly disjoint) selected column ranges
225 @Test(groups = { "Functional" })
226 public void testHideSelectedColumns()
228 ColumnSelection cs = new ColumnSelection();
229 int[] sel = { 2, 3, 4, 7, 8, 9, 20, 21, 22 };
234 cs.hideColumns(15, 18);
236 cs.hideSelectedColumns();
237 assertTrue(cs.getSelected().isEmpty());
238 List<int[]> hidden = cs.getHiddenColumns();
239 assertEquals(4, hidden.size());
240 assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
241 assertEquals("[7, 9]", Arrays.toString(hidden.get(1)));
242 assertEquals("[15, 18]", Arrays.toString(hidden.get(2)));
243 assertEquals("[20, 22]", Arrays.toString(hidden.get(3)));
247 * Test the method that gets runs of selected columns ordered by column. If
248 * this fails, HideSelectedColumns may also fail
250 @Test(groups = { "Functional" })
251 public void testgetSelectedRanges()
253 ColumnSelection cs = new ColumnSelection();
254 int[] sel = { 2, 3, 4, 7, 8, 9, 20, 21, 22 };
260 range = cs.getSelectedRanges();
261 assertEquals(3, range.size());
262 assertEquals("[2, 4]", Arrays.toString(range.get(0)));
263 assertEquals("[7, 9]", Arrays.toString(range.get(1)));
264 assertEquals("[20, 22]", Arrays.toString(range.get(2)));
267 range = cs.getSelectedRanges();
268 assertEquals(3, range.size());
269 assertEquals("[0, 4]", Arrays.toString(range.get(0)));
273 * Test the method that reveals a range of hidden columns given the start
274 * column of the range
276 @Test(groups = { "Functional" })
277 public void testRevealHiddenColumns()
279 ColumnSelection cs = new ColumnSelection();
280 cs.hideColumns(5, 8);
282 cs.revealHiddenColumns(5);
283 // hidden columns list now null but getter returns empty list:
284 assertTrue(cs.getHiddenColumns().isEmpty());
285 // revealed columns are marked as selected (added to selection):
286 assertEquals("[10, 5, 6, 7, 8]", cs.getSelected().toString());
288 // calling with a column other than the range start does nothing:
289 cs = new ColumnSelection();
290 cs.hideColumns(5, 8);
291 List<int[]> hidden = cs.getHiddenColumns();
292 cs.revealHiddenColumns(6);
293 assertSame(hidden, cs.getHiddenColumns());
294 assertTrue(cs.getSelected().isEmpty());
297 @Test(groups = { "Functional" })
298 public void testRevealAllHiddenColumns()
300 ColumnSelection cs = new ColumnSelection();
301 cs.hideColumns(5, 8);
302 cs.hideColumns(2, 3);
305 cs.revealAllHiddenColumns();
308 * revealing hidden columns adds them (in order) to the (unordered)
311 assertTrue(cs.getHiddenColumns().isEmpty());
312 assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", cs.getSelected().toString());
315 @Test(groups = { "Functional" })
316 public void testIsVisible()
318 ColumnSelection cs = new ColumnSelection();
319 cs.hideColumns(2, 4);
320 cs.hideColumns(6, 7);
321 assertTrue(cs.isVisible(0));
322 assertTrue(cs.isVisible(-99));
323 assertTrue(cs.isVisible(1));
324 assertFalse(cs.isVisible(2));
325 assertFalse(cs.isVisible(3));
326 assertFalse(cs.isVisible(4));
327 assertTrue(cs.isVisible(5));
328 assertFalse(cs.isVisible(6));
329 assertFalse(cs.isVisible(7));
332 @Test(groups = { "Functional" })
333 public void testGetVisibleContigs()
335 ColumnSelection cs = new ColumnSelection();
336 cs.hideColumns(3, 6);
337 cs.hideColumns(8, 9);
338 cs.hideColumns(12, 12);
340 // start position is inclusive, end position exclusive:
341 int[] visible = cs.getVisibleContigs(1, 13);
342 assertEquals("[1, 2, 7, 7, 10, 11]", Arrays.toString(visible));
344 visible = cs.getVisibleContigs(4, 14);
345 assertEquals("[7, 7, 10, 11, 13, 13]", Arrays.toString(visible));
347 visible = cs.getVisibleContigs(3, 10);
348 assertEquals("[7, 7]", Arrays.toString(visible));
350 visible = cs.getVisibleContigs(4, 6);
351 assertEquals("[]", Arrays.toString(visible));
354 @Test(groups = { "Functional" })
355 public void testInvertColumnSelection()
357 ColumnSelection cs = new ColumnSelection();
361 cs.hideColumns(3, 3);
362 cs.hideColumns(6, 6);
364 // invert selection from start (inclusive) to end (exclusive)
365 // hidden columns are _not_ changed
366 cs.invertColumnSelection(2, 9);
367 assertEquals("[2, 5, 7]", cs.getSelected().toString());
369 cs.invertColumnSelection(1, 9);
370 assertEquals("[1, 4, 8]", cs.getSelected().toString());
373 @Test(groups = { "Functional" })
374 public void testMaxColumnSelection()
376 ColumnSelection cs = new ColumnSelection();
380 assertEquals(513, cs.getMax());
381 cs.removeElement(513);
382 assertEquals(1, cs.getMax());
384 assertEquals(0, cs.getMax());
387 assertEquals(513, cs.getMax());
391 @Test(groups = { "Functional" })
392 public void testMinColumnSelection()
394 ColumnSelection cs = new ColumnSelection();
398 assertEquals(0, cs.getMin());
400 assertEquals(1, cs.getMin());
402 assertEquals(0, cs.getMin());