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 jalview.analysis.AlignmentGenerator;
29 import jalview.gui.JvOptionPane;
31 import java.util.Arrays;
32 import java.util.List;
34 import org.testng.annotations.BeforeClass;
35 import org.testng.annotations.Test;
37 public class HiddenColumnsTest
40 @BeforeClass(alwaysRun = true)
41 public void setUpJvOptionPane()
43 JvOptionPane.setInteractiveMode(false);
44 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
48 * Test the method that finds the visible column position of an alignment
49 * column, allowing for hidden columns.
51 @Test(groups = { "Functional" })
52 public void testFindColumnPosition()
54 HiddenColumns cs = new HiddenColumns();
55 assertEquals(5, cs.findColumnPosition(5));
57 // hiding column 6 makes no difference
59 assertEquals(5, cs.findColumnPosition(5));
61 // hiding column 4 moves column 5 to column 4
63 assertEquals(4, cs.findColumnPosition(5));
65 // hiding column 4 moves column 4 to position 3
66 assertEquals(3, cs.findColumnPosition(4));
68 // hiding columns 1 and 2 moves column 5 to column 2
70 assertEquals(2, cs.findColumnPosition(5));
72 // check with > 1 hidden column regions
73 // where some columns are in the hidden regions
74 HiddenColumns cs2 = new HiddenColumns();
75 cs2.hideColumns(5, 10);
76 cs2.hideColumns(20, 27);
77 cs2.hideColumns(40, 44);
79 // hiding columns 5-10 and 20-27 moves column 8 to column 4
80 assertEquals(4, cs2.findColumnPosition(8));
82 // and moves column 24 to 13
83 assertEquals(13, cs2.findColumnPosition(24));
85 // and moves column 28 to 14
86 assertEquals(14, cs2.findColumnPosition(28));
88 // and moves column 40 to 25
89 assertEquals(25, cs2.findColumnPosition(40));
91 // check when hidden columns start at 0 that the visible column
93 HiddenColumns cs3 = new HiddenColumns();
94 cs3.hideColumns(0, 4);
95 assertEquals(0, cs3.findColumnPosition(2));
100 * Test the method that finds the visible column position a given distance
101 * before another column
103 @Test(groups = { "Functional" })
104 public void testFindColumnNToLeft()
106 HiddenColumns cs = new HiddenColumns();
108 // test that without hidden columns, findColumnNToLeft returns
109 // position n to left of provided position
110 int pos = cs.subtractVisibleColumns(3, 10);
111 assertEquals(7, pos);
113 // 0 returns same position
114 pos = cs.subtractVisibleColumns(0, 10);
115 assertEquals(10, pos);
117 // overflow to left returns negative number
118 pos = cs.subtractVisibleColumns(3, 0);
119 assertEquals(-3, pos);
121 // test that with hidden columns to left of result column
122 // behaviour is the same as above
123 cs.hideColumns(1, 3);
125 // position n to left of provided position
126 pos = cs.subtractVisibleColumns(3, 10);
127 assertEquals(7, pos);
129 // 0 returns same position
130 pos = cs.subtractVisibleColumns(0, 10);
131 assertEquals(10, pos);
133 // test with one set of hidden columns between start and required position
134 cs.hideColumns(12, 15);
135 pos = cs.subtractVisibleColumns(8, 17);
136 assertEquals(5, pos);
138 // test with two sets of hidden columns between start and required position
139 cs.hideColumns(20, 21);
140 pos = cs.subtractVisibleColumns(8, 23);
141 assertEquals(9, pos);
143 // repeat last 2 tests with no hidden columns to left of required position
144 ColumnSelection colsel = new ColumnSelection();
145 cs.revealAllHiddenColumns(colsel);
147 // test with one set of hidden columns between start and required position
148 cs.hideColumns(12, 15);
149 pos = cs.subtractVisibleColumns(8, 17);
150 assertEquals(5, pos);
152 // test with two sets of hidden columns between start and required position
153 cs.hideColumns(20, 21);
154 pos = cs.subtractVisibleColumns(8, 23);
155 assertEquals(9, pos);
159 @Test(groups = { "Functional" })
160 public void testGetVisibleContigs()
162 HiddenColumns cs = new HiddenColumns();
163 cs.hideColumns(3, 6);
164 cs.hideColumns(8, 9);
165 cs.hideColumns(12, 12);
167 // start position is inclusive, end position exclusive:
168 int[] visible = cs.getVisibleContigs(1, 13);
169 assertEquals("[1, 2, 7, 7, 10, 11]", Arrays.toString(visible));
171 visible = cs.getVisibleContigs(4, 14);
172 assertEquals("[7, 7, 10, 11, 13, 13]", Arrays.toString(visible));
174 visible = cs.getVisibleContigs(3, 10);
175 assertEquals("[7, 7]", Arrays.toString(visible));
177 visible = cs.getVisibleContigs(4, 6);
178 assertEquals("[]", Arrays.toString(visible));
181 @Test(groups = { "Functional" })
182 public void testEquals()
184 HiddenColumns cs = new HiddenColumns();
185 cs.hideColumns(5, 9);
187 // a different set of hidden columns
188 HiddenColumns cs2 = new HiddenColumns();
190 // with no hidden columns
191 assertFalse(cs.equals(cs2));
192 assertFalse(cs2.equals(cs));
194 // with hidden columns added in a different order
195 cs2.hideColumns(6, 9);
196 cs2.hideColumns(5, 8);
198 assertTrue(cs.equals(cs2));
199 assertTrue(cs.equals(cs));
200 assertTrue(cs2.equals(cs));
201 assertTrue(cs2.equals(cs2));
204 @Test(groups = "Functional")
205 public void testCopyConstructor()
207 HiddenColumns cs = new HiddenColumns();
208 cs.hideColumns(10, 11);
209 cs.hideColumns(5, 7);
210 assertEquals("[5, 7]", Arrays.toString(cs.getListOfCols().get(0)));
212 HiddenColumns cs2 = new HiddenColumns(cs);
213 assertTrue(cs2.hasHiddenColumns());
214 assertEquals(2, cs2.getListOfCols().size());
215 // hidden columns are held in column order
216 assertEquals("[5, 7]", Arrays.toString(cs2.getListOfCols().get(0)));
217 assertEquals("[10, 11]", Arrays.toString(cs2.getListOfCols().get(1)));
221 * Test the code used to locate the reference sequence ruler origin
223 @Test(groups = { "Functional" })
224 public void testLocateVisibleBoundsofSequence()
226 // create random alignment
227 AlignmentGenerator gen = new AlignmentGenerator(false);
228 AlignmentI al = gen.generate(50, 20, 123, 5, 5);
230 HiddenColumns cs = al.getHiddenColumns();
231 ColumnSelection colsel = new ColumnSelection();
233 SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
234 assertEquals(2, seq.findIndex(seq.getStart()));
238 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
239 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
240 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
241 seq.findIndex(seq.getEnd()) - 1 }),
242 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
244 // hidden column on gap after end of sequence - should not affect bounds
245 colsel.hideSelectedColumns(13, al.getHiddenColumns());
247 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
248 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
249 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
250 seq.findIndex(seq.getEnd()) - 1 }),
251 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
253 cs.revealAllHiddenColumns(colsel);
254 // hidden column on gap before beginning of sequence - should vis bounds by
256 colsel.hideSelectedColumns(0, al.getHiddenColumns());
258 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 2,
259 seq.findIndex(seq.getEnd()) - 2, seq.getStart(),
260 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
261 seq.findIndex(seq.getEnd()) - 1 }),
262 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
264 cs.revealAllHiddenColumns(colsel);
265 // hide columns around most of sequence - leave one residue remaining
266 cs.hideColumns(1, 3);
267 cs.hideColumns(6, 11);
269 cs.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]);
271 Arrays.toString(new int[] { 1, 1, 3, 3,
272 seq.findIndex(seq.getStart()) - 1,
273 seq.findIndex(seq.getEnd()) - 1 }),
274 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
275 cs.revealAllHiddenColumns(colsel);
277 // hide whole sequence - should just get location of hidden region
278 // containing sequence
279 cs.hideColumns(1, 11);
281 Arrays.toString(new int[] { 0, 1, 0, 0,
282 seq.findIndex(seq.getStart()) - 1,
283 seq.findIndex(seq.getEnd()) - 1 }),
284 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
288 @Test(groups = { "Functional" })
289 public void testLocateVisibleBoundsPathologicals()
291 // test some pathological cases we missed
292 AlignmentI al = new Alignment(new SequenceI[] { new Sequence(
293 "refseqGaptest", "KTDVTI----------NFI-----G----L") });
294 HiddenColumns cs = new HiddenColumns();
295 cs.hideInsertionsFor(al.getSequenceAt(0));
299 + al.getSequenceAt(0).getCharAt(
300 cs.adjustForHiddenColumns(9)));
304 @Test(groups = { "Functional" })
305 public void testHideColumns()
307 // create random alignment
308 AlignmentGenerator gen = new AlignmentGenerator(false);
309 AlignmentI al = gen.generate(50, 20, 123, 5, 5);
311 ColumnSelection colsel = new ColumnSelection();
312 HiddenColumns cs = al.getHiddenColumns();
313 colsel.hideSelectedColumns(5, al.getHiddenColumns());
314 List<int[]> hidden = cs.getListOfCols();
315 assertEquals(1, hidden.size());
316 assertEquals("[5, 5]", Arrays.toString(hidden.get(0)));
318 colsel.hideSelectedColumns(3, al.getHiddenColumns());
319 assertEquals(2, hidden.size());
320 // two hidden ranges, in order:
321 assertSame(hidden, cs.getListOfCols());
322 assertEquals("[3, 3]", Arrays.toString(hidden.get(0)));
323 assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
325 // hiding column 4 expands [3, 3] to [3, 4]
326 // and merges to [5, 5] to make [3, 5]
327 colsel.hideSelectedColumns(4, al.getHiddenColumns());
328 hidden = cs.getListOfCols();
329 assertEquals(1, hidden.size());
330 assertEquals("[3, 5]", Arrays.toString(hidden.get(0)));
332 // clear hidden columns (note they are added to selected)
333 cs.revealAllHiddenColumns(colsel);
334 // it is now actually null but getter returns an empty list
335 assertTrue(cs.getListOfCols().isEmpty());
337 cs.hideColumns(3, 6);
338 hidden = cs.getListOfCols();
339 int[] firstHiddenRange = hidden.get(0);
340 assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
342 // adding a subrange of already hidden should do nothing
343 cs.hideColumns(4, 5);
344 assertEquals(1, hidden.size());
345 assertSame(firstHiddenRange, cs.getListOfCols().get(0));
346 cs.hideColumns(3, 5);
347 assertEquals(1, hidden.size());
348 assertSame(firstHiddenRange, cs.getListOfCols().get(0));
349 cs.hideColumns(4, 6);
350 assertEquals(1, hidden.size());
351 assertSame(firstHiddenRange, cs.getListOfCols().get(0));
352 cs.hideColumns(3, 6);
353 assertEquals(1, hidden.size());
354 assertSame(firstHiddenRange, cs.getListOfCols().get(0));
356 cs.revealAllHiddenColumns(colsel);
357 cs.hideColumns(2, 4);
358 hidden = cs.getListOfCols();
359 assertEquals(1, hidden.size());
360 assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
362 // extend contiguous with 2 positions overlap
363 cs.hideColumns(3, 5);
364 assertEquals(1, hidden.size());
365 assertEquals("[2, 5]", Arrays.toString(hidden.get(0)));
367 // extend contiguous with 1 position overlap
368 cs.hideColumns(5, 6);
369 assertEquals(1, hidden.size());
370 assertEquals("[2, 6]", Arrays.toString(hidden.get(0)));
372 // extend contiguous with overlap both ends:
373 cs.hideColumns(1, 7);
374 assertEquals(1, hidden.size());
375 assertEquals("[1, 7]", Arrays.toString(hidden.get(0)));
379 * Test the method that reveals a range of hidden columns given the start
380 * column of the range
382 @Test(groups = { "Functional" })
383 public void testRevealHiddenColumns()
385 ColumnSelection colsel = new ColumnSelection();
386 HiddenColumns cs = new HiddenColumns();
387 cs.hideColumns(5, 8);
388 colsel.addElement(10);
389 cs.revealHiddenColumns(5, colsel);
390 // hidden columns list now null but getter returns empty list:
391 assertTrue(cs.getListOfCols().isEmpty());
392 // revealed columns are marked as selected (added to selection):
393 assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString());
395 // calling with a column other than the range start does nothing:
396 colsel = new ColumnSelection();
397 cs = new HiddenColumns();
398 cs.hideColumns(5, 8);
399 List<int[]> hidden = cs.getListOfCols();
400 cs.revealHiddenColumns(6, colsel);
401 assertSame(hidden, cs.getListOfCols());
402 assertTrue(colsel.getSelected().isEmpty());
405 @Test(groups = { "Functional" })
406 public void testRevealAllHiddenColumns()
408 HiddenColumns cs = new HiddenColumns();
409 ColumnSelection colsel = new ColumnSelection();
410 cs.hideColumns(5, 8);
411 cs.hideColumns(2, 3);
412 colsel.addElement(11);
413 colsel.addElement(1);
414 cs.revealAllHiddenColumns(colsel);
417 * revealing hidden columns adds them (in order) to the (unordered)
420 assertTrue(cs.getListOfCols().isEmpty());
421 assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", colsel.getSelected()
425 @Test(groups = { "Functional" })
426 public void testIsVisible()
428 HiddenColumns cs = new HiddenColumns();
429 cs.hideColumns(2, 4);
430 cs.hideColumns(6, 7);
431 assertTrue(cs.isVisible(0));
432 assertTrue(cs.isVisible(-99));
433 assertTrue(cs.isVisible(1));
434 assertFalse(cs.isVisible(2));
435 assertFalse(cs.isVisible(3));
436 assertFalse(cs.isVisible(4));
437 assertTrue(cs.isVisible(5));
438 assertFalse(cs.isVisible(6));
439 assertFalse(cs.isVisible(7));
443 * Test for the case when a hidden range encloses more one already hidden
446 @Test(groups = { "Functional" })
447 public void testHideColumns_subsumingHidden()
450 * JAL-2370 bug scenario:
451 * two hidden ranges subsumed by a third
453 HiddenColumns cs = new HiddenColumns();
454 cs.hideColumns(49, 59);
455 cs.hideColumns(69, 79);
456 List<int[]> hidden = cs.getListOfCols();
457 assertEquals(2, hidden.size());
458 assertEquals("[49, 59]", Arrays.toString(hidden.get(0)));
459 assertEquals("[69, 79]", Arrays.toString(hidden.get(1)));
461 cs.hideColumns(48, 80);
462 hidden = cs.getListOfCols();
463 assertEquals(1, hidden.size());
464 assertEquals("[48, 80]", Arrays.toString(hidden.get(0)));
467 * another...joining hidden ranges
469 cs = new HiddenColumns();
470 cs.hideColumns(10, 20);
471 cs.hideColumns(30, 40);
472 cs.hideColumns(50, 60);
473 // hiding 21-49 should merge to one range
474 cs.hideColumns(21, 49);
475 hidden = cs.getListOfCols();
476 assertEquals(1, hidden.size());
477 assertEquals("[10, 60]", Arrays.toString(hidden.get(0)));
480 * another...left overlap, subsumption, right overlap,
481 * no overlap of existing hidden ranges
483 cs = new HiddenColumns();
484 cs.hideColumns(10, 20);
485 cs.hideColumns(10, 20);
486 cs.hideColumns(30, 35);
487 cs.hideColumns(40, 50);
488 cs.hideColumns(60, 70);
490 cs.hideColumns(15, 45);
491 hidden = cs.getListOfCols();
492 assertEquals(2, hidden.size());
493 assertEquals("[10, 50]", Arrays.toString(hidden.get(0)));
494 assertEquals("[60, 70]", Arrays.toString(hidden.get(1)));