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));
97 * Test the code used to locate the reference sequence ruler origin
99 @Test(groups = { "Functional" })
100 public void testLocateVisibleBoundsofSequence()
102 ColumnSelection cs = new ColumnSelection();
103 SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
104 assertEquals(2, seq.findIndex(seq.getStart()));
108 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
109 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
111 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
113 // hidden column on gap after end of sequence - should not affect bounds
116 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
117 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
119 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
121 cs.revealAllHiddenColumns();
122 // hidden column on gap before beginning of sequence - should vis bounds by
126 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 2,
127 seq.findIndex(seq.getEnd()) - 2, seq.getStart(),
129 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
131 cs.revealAllHiddenColumns();
132 // hide columns around most of sequence - leave one residue remaining
133 cs.hideColumns(1, 3);
134 cs.hideColumns(6, 11);
136 cs.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]);
137 assertEquals(Arrays.toString(new int[] { 1, 1, 3, 3 }),
138 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
139 cs.revealAllHiddenColumns();
141 // hide whole sequence - should just get location of hidden region
142 // containing sequence
143 cs.hideColumns(1, 11);
144 assertEquals(Arrays.toString(new int[] { 0, 1, 0, 0 }),
145 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
149 @Test(groups = { "Functional" })
150 public void testHideColumns()
152 ColumnSelection cs = new ColumnSelection();
154 List<int[]> hidden = cs.getHiddenColumns();
155 assertEquals(1, hidden.size());
156 assertEquals("[5, 5]", Arrays.toString(hidden.get(0)));
159 assertEquals(2, hidden.size());
160 // two hidden ranges, in order:
161 assertSame(hidden, cs.getHiddenColumns());
162 assertEquals("[3, 3]", Arrays.toString(hidden.get(0)));
163 assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
165 // hiding column 4 expands [3, 3] to [3, 4]
166 // not fancy enough to coalesce this into [3, 5] though
168 hidden = cs.getHiddenColumns();
169 assertEquals(2, hidden.size());
170 assertEquals("[3, 4]", Arrays.toString(hidden.get(0)));
171 assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
173 // clear hidden columns (note they are added to selected)
174 cs.revealAllHiddenColumns();
175 // it is now actually null but getter returns an empty list
176 assertTrue(cs.getHiddenColumns().isEmpty());
178 cs.hideColumns(3, 6);
179 hidden = cs.getHiddenColumns();
180 int[] firstHiddenRange = hidden.get(0);
181 assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
183 // adding a subrange of already hidden should do nothing
184 cs.hideColumns(4, 5);
185 assertEquals(1, hidden.size());
186 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
187 cs.hideColumns(3, 5);
188 assertEquals(1, hidden.size());
189 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
190 cs.hideColumns(4, 6);
191 assertEquals(1, hidden.size());
192 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
193 cs.hideColumns(3, 6);
194 assertEquals(1, hidden.size());
195 assertSame(firstHiddenRange, cs.getHiddenColumns().get(0));
197 cs.revealAllHiddenColumns();
198 cs.hideColumns(2, 4);
199 hidden = cs.getHiddenColumns();
200 assertEquals(1, hidden.size());
201 assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
203 // extend contiguous with 2 positions overlap
204 cs.hideColumns(3, 5);
205 assertEquals(1, hidden.size());
206 assertEquals("[2, 5]", Arrays.toString(hidden.get(0)));
208 // extend contiguous with 1 position overlap
209 cs.hideColumns(5, 6);
210 assertEquals(1, hidden.size());
211 assertEquals("[2, 6]", Arrays.toString(hidden.get(0)));
213 // extend contiguous with overlap both ends:
214 cs.hideColumns(1, 7);
215 assertEquals(1, hidden.size());
216 assertEquals("[1, 7]", Arrays.toString(hidden.get(0)));
220 * Test the method that hides a specified column including any adjacent
221 * selected columns. This is a convenience method for the case where multiple
222 * column regions are selected and then hidden using menu option View | Hide |
225 @Test(groups = { "Functional" })
226 public void testHideColumns_withSelection()
228 ColumnSelection cs = new ColumnSelection();
229 // select columns 4-6
233 // hide column 5 (and adjacent):
236 List<int[]> hidden = cs.getHiddenColumns();
237 assertEquals(1, hidden.size());
238 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
239 // none now selected:
240 assertTrue(cs.getSelected().isEmpty());
242 // repeat, hiding column 4 (5 and 6)
243 cs = new ColumnSelection();
248 hidden = cs.getHiddenColumns();
249 assertEquals(1, hidden.size());
250 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
251 assertTrue(cs.getSelected().isEmpty());
253 // repeat, hiding column (4, 5 and) 6
254 cs = new ColumnSelection();
259 hidden = cs.getHiddenColumns();
260 assertEquals(1, hidden.size());
261 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
262 assertTrue(cs.getSelected().isEmpty());
264 // repeat, with _only_ adjacent columns selected
265 cs = new ColumnSelection();
269 hidden = cs.getHiddenColumns();
270 assertEquals(1, hidden.size());
271 assertEquals("[4, 6]", Arrays.toString(hidden.get(0)));
272 assertTrue(cs.getSelected().isEmpty());
276 * Test the method that hides all (possibly disjoint) selected column ranges
278 @Test(groups = { "Functional" })
279 public void testHideSelectedColumns()
281 ColumnSelection cs = new ColumnSelection();
282 int[] sel = { 2, 3, 4, 7, 8, 9, 20, 21, 22 };
287 cs.hideColumns(15, 18);
289 cs.hideSelectedColumns();
290 assertTrue(cs.getSelected().isEmpty());
291 List<int[]> hidden = cs.getHiddenColumns();
292 assertEquals(4, hidden.size());
293 assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
294 assertEquals("[7, 9]", Arrays.toString(hidden.get(1)));
295 assertEquals("[15, 18]", Arrays.toString(hidden.get(2)));
296 assertEquals("[20, 22]", Arrays.toString(hidden.get(3)));
300 * Test the method that gets runs of selected columns ordered by column. If
301 * this fails, HideSelectedColumns may also fail
303 @Test(groups = { "Functional" })
304 public void testgetSelectedRanges()
306 ColumnSelection cs = new ColumnSelection();
307 int[] sel = { 2, 3, 4, 7, 8, 9, 20, 21, 22 };
313 range = cs.getSelectedRanges();
314 assertEquals(3, range.size());
315 assertEquals("[2, 4]", Arrays.toString(range.get(0)));
316 assertEquals("[7, 9]", Arrays.toString(range.get(1)));
317 assertEquals("[20, 22]", Arrays.toString(range.get(2)));
320 range = cs.getSelectedRanges();
321 assertEquals(3, range.size());
322 assertEquals("[0, 4]", Arrays.toString(range.get(0)));
326 * Test the method that reveals a range of hidden columns given the start
327 * column of the range
329 @Test(groups = { "Functional" })
330 public void testRevealHiddenColumns()
332 ColumnSelection cs = new ColumnSelection();
333 cs.hideColumns(5, 8);
335 cs.revealHiddenColumns(5);
336 // hidden columns list now null but getter returns empty list:
337 assertTrue(cs.getHiddenColumns().isEmpty());
338 // revealed columns are marked as selected (added to selection):
339 assertEquals("[10, 5, 6, 7, 8]", cs.getSelected().toString());
341 // calling with a column other than the range start does nothing:
342 cs = new ColumnSelection();
343 cs.hideColumns(5, 8);
344 List<int[]> hidden = cs.getHiddenColumns();
345 cs.revealHiddenColumns(6);
346 assertSame(hidden, cs.getHiddenColumns());
347 assertTrue(cs.getSelected().isEmpty());
350 @Test(groups = { "Functional" })
351 public void testRevealAllHiddenColumns()
353 ColumnSelection cs = new ColumnSelection();
354 cs.hideColumns(5, 8);
355 cs.hideColumns(2, 3);
358 cs.revealAllHiddenColumns();
361 * revealing hidden columns adds them (in order) to the (unordered)
364 assertTrue(cs.getHiddenColumns().isEmpty());
365 assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", cs.getSelected().toString());
368 @Test(groups = { "Functional" })
369 public void testIsVisible()
371 ColumnSelection cs = new ColumnSelection();
372 cs.hideColumns(2, 4);
373 cs.hideColumns(6, 7);
374 assertTrue(cs.isVisible(0));
375 assertTrue(cs.isVisible(-99));
376 assertTrue(cs.isVisible(1));
377 assertFalse(cs.isVisible(2));
378 assertFalse(cs.isVisible(3));
379 assertFalse(cs.isVisible(4));
380 assertTrue(cs.isVisible(5));
381 assertFalse(cs.isVisible(6));
382 assertFalse(cs.isVisible(7));
385 @Test(groups = { "Functional" })
386 public void testGetVisibleContigs()
388 ColumnSelection cs = new ColumnSelection();
389 cs.hideColumns(3, 6);
390 cs.hideColumns(8, 9);
391 cs.hideColumns(12, 12);
393 // start position is inclusive, end position exclusive:
394 int[] visible = cs.getVisibleContigs(1, 13);
395 assertEquals("[1, 2, 7, 7, 10, 11]", Arrays.toString(visible));
397 visible = cs.getVisibleContigs(4, 14);
398 assertEquals("[7, 7, 10, 11, 13, 13]", Arrays.toString(visible));
400 visible = cs.getVisibleContigs(3, 10);
401 assertEquals("[7, 7]", Arrays.toString(visible));
403 visible = cs.getVisibleContigs(4, 6);
404 assertEquals("[]", Arrays.toString(visible));
407 @Test(groups = { "Functional" })
408 public void testInvertColumnSelection()
410 ColumnSelection cs = new ColumnSelection();
414 cs.hideColumns(3, 3);
415 cs.hideColumns(6, 6);
417 // invert selection from start (inclusive) to end (exclusive)
418 // hidden columns are _not_ changed
419 cs.invertColumnSelection(2, 9);
420 assertEquals("[2, 5, 7]", cs.getSelected().toString());
422 cs.invertColumnSelection(1, 9);
423 assertEquals("[1, 4, 8]", cs.getSelected().toString());
426 @Test(groups = { "Functional" })
427 public void testMaxColumnSelection()
429 ColumnSelection cs = new ColumnSelection();
433 assertEquals(513, cs.getMax());
434 cs.removeElement(513);
435 assertEquals(1, cs.getMax());
437 assertEquals(0, cs.getMax());
440 assertEquals(513, cs.getMax());
444 @Test(groups = { "Functional" })
445 public void testMinColumnSelection()
447 ColumnSelection cs = new ColumnSelection();
451 assertEquals(0, cs.getMin());
453 assertEquals(1, cs.getMin());
455 assertEquals(0, cs.getMin());